💗推荐阅读文章💗

• 🌸JavaSE系列🌸👉1️⃣《JavaSE系列教程》
• 🌺MySQL系列🌺👉2️⃣《MySQL系列教程》
• 🍀JavaWeb系列🍀👉3️⃣《JavaWeb系列教程》
• 🌻SSM框架系列🌻👉4️⃣《SSM框架系列教程》

🎉本博客知识点收录于🎉👉🚀《JavaSE系列教程》🚀—>✈️18【枚举、类加载器、动态代理】✈️

文章目录

• 二、类加载器
• • 2.1 类加载时机
  • 2.3 类加载器
  • • 2.3.1 类加载器的种类
    • 2.3.2 双亲委派机制
    • 2.3.3 双亲委派的好处
    • 2.3.4 URLClassLoader类加载器
    • • 1）加载本地磁盘上的类：
      • 2）加载网络上的类：
    • 2.3.5 自定义类加载器
    • 2.3.6 打破双亲委派
  • 2.2 类的加载过程
  • • 2.2.1 类的生命周期
    • • 1）加载
      • 2）连接
      • 3）初始化

二、类加载器

2.1 类加载时机

我们知道，所有的代码都是运行在内存中的，我们必须把类加载到内存中才能运行；在Java中，所有的Java类都是通过类加载器加载到内存进行执行的；

• 一个类何时被加载？
  • 1）main方法所在的类总是被首先初始化
  • 2）创建该类对象时，首先会将内加载到内存（如果该类存在父类，那么首先加载父类到内存，创建父类的对象（super））
  • 3）访问该类的静态成员时，会将类加载到内存（该静态成员不能被fianl修饰）
  • 4）class.forName(“类的全包名”)

package com.dfbz.demo01;
import org.junit.Test;
/*** @author lscl* @version 1.0* @intro:*/
public class Demo01_类何时被加载 {@Testpublic void test1() throws ClassNotFoundException {
//        new B();          // 先加载A再加载B
//        Integer num = B.num;        // 先加载A再加载BClass clazz = Class.forName("com.dfbz.demo01.B");        // 先加载A再加载B}
}
class A {public static Integer num = 10;static {System.out.println("A loader...");}
}
class B extends A {public static Integer num = 20;static {System.out.println("B loader...");}
}

Tips：不管是用什么方法加载，类从始至终只会加载一次；

2.3 类加载器

2.3.1 类加载器的种类

• 启动类加载器Bootstrap ClassLoader： 是嵌在JVM内核中的加载器，该加载器是用C++语言写的，主要负则加载JAVA_HOME/lib下的类库，启动类加载器无法被应用程序直接使用。
• **扩展类加载器Extension ClassLoader：**该加载器器是用JAVA编写，且它的父加载器是Bootstrap，是由sun.misc.Launcher$ExtClassLoader实现的，主要加载JAVA_HOME/lib/ext目录中的类库。开发者可以这几使用扩展类加载器。
• **系统类加载器App ClassLoader：**系统类加载器，也称为应用程序类加载器，负责加载应用程序classpath目录下的所有jar和class文件（第三方jar）。它的父加载器为Ext ClassLoader。

Tips：这里的父加载器并非是Java中的继承关系，而是我们后面学习双亲委派过程中向上委派的加载器，我们将其称为父加载器；

测试类：

package com.dfbz.demo01;
import com.dfbz.demo02.Demo02;
import com.sun.java.accessibility.AccessBridge;
import org.junit.Test;
/*** @author lscl* @version 1.0* @intro:*/
public class Demo02_类加载器的种类 {@Testpublic void test1(){// Bootstrap类加载器是获取不到的,为nullSystem.out.println("Bootstrap ClassLoader: "+ String.class.getClassLoader());// jre\lib\ext\access-bridge-64.jarSystem.out.println("ExtClassLoader ClassLoader: "+ AccessBridge.class.getClassLoader());System.out.println("AppClassLoader ClassLoader: "+ Demo02.class.getClassLoader());}
}

2.3.2 双亲委派机制

从JDK1.2开始，类的加载过程采用双亲委派机制，它是一种任务委派模式。即把加载类的请求交由父加载器处理，一直到顶层的父加载器（BootstrapClassLoader）；如果父加载器能加载则用父加载器加载，否则才用子加载器加载该类；

• 示例代码：

package com.dfbz.demo01;
import org.junit.Test;
/*** @author lscl* @version 1.0* @intro:*/
public class Demo03_类加载的过程 {@Testpublic void test1() {Class tClass = T.class;System.out.println(tClass);}class T {}
}

JVM在加载类时，会调用类加载器（ClassLoader）的loadClass方法进行加载；
ClassLoader类加载源码：

protected Class loadClass(String name, boolean resolve)throws ClassNotFoundException
{synchronized (getClassLoadingLock(name)) {// 检查该类是否被加载过Class c = findLoadedClass(name);if (c == null) {long t0 = System.nanoTime();try {if (parent != null) {// 使用父加载器加载c = parent.loadClass(name, false);} else {// 如果没有父加载器则使用BootstrapClassLoader加载c = findBootstrapClassOrNull(name);}} catch (ClassNotFoundException e) {// ClassNotFoundException thrown if class not found// from the non-null parent class loader}if (c == null) {// 如果依旧没有加载,则调用自身的findClass方法进行加载long t1 = System.nanoTime();c = findClass(name);// this is the defining class loader; record the statssun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);sun.misc.PerfCounter.getFindClasses().increment();}}if (resolve) {resolveClass(c);}return c;}
}

findClass方法源码：

protected Class findClass(String name) throws ClassNotFoundException {throw new ClassNotFoundException(name);
}

可以看到，默认情况下ClassLoader的findClass方法只是抛出了一个异常而已（这个方法是留给我们写的）

• 双亲委派机制流程图：

• 1）从上图我们可以分析，当一个Demo.class这样的文件要被加载时，首先会在AppClassLoader中检查是否加载过，如果有那就无需再加载了。

• 2）如果没有加载，那么会拿到父加载器（向上委派），然后调用父加载器的loadClass方法进行加载。AppClassLoader的父加载器为ExtClassLoader，而ExtClassLoader并没有重写loadClass方法，因此还是调用ClassLoader类的loadClass方法，相当于是一个递归的操作；

• 3）父类中同理也会先检查自己是否已经加载过，如果没有再往上。注意是个递归的过程，直到到达Bootstrap classLoader之前，都是在检查是否加载过，并不会选择自己去加载。直到BootstrapClassLoader，已经没有父加载器了，这时候开始考虑自己是否能加载了，如果自己无法加载，会下沉到子加载器去加载，一直到最底层，如果没有任何加载器能加载，就会抛出ClassNotFoundException。

BootstrapClassLoader不能加载该类，因此还是为null，然后调用本类的findClass方法；这里需要注意两点：

• 1）本类还是ExtClassLoader
• 2）ExtClassLoader是自身没有findClass方法，但ExtClassLoader继承与URLClassLoader，并且URLClassLoader提供有findClass方法；

接下来调用到URLClassLoader类中的findClass方法来加载该类：

URLClassLoader类中的findClass方法无法加载我们传递的类，然后向上抛出了一个异常；这里需要注意：

• 1）URLClassLoader类中的findClass方法是通过ExtClassLoader调用findClass方法进去的，因此向上抛出异常后，findClass方法后面的代码将不会执行了，并且触发的异常继续往上抛给调用者（调用loadClass的对象）
• 2）ExtClassLoader的loadClass方法是在AppClassLoader中，通过parent.loadClass()调用进去的，因此异常被抛到了这里；

异常被抛到了AppClassLoader中的loadClass方法中，接着尝试使用AppClassLoader的findClass()方法来加载类；

最终交给AppClassLoader完成类的加载：

2.3.3 双亲委派的好处

我们已经了解了Java中类加载的双亲委派机制，**即加载类时交给父加载器加载，如果父加载器不能加载，再交给子加载器加载；**这样做有何好处呢？

• 1）避免类的重复加载：当父类加载器已经加载了该类时，就没有必要子 ClassLoader 再加载一次。
• 2）安全问题：有了双亲委派机制，当有人想要替换系统级别的类或者篡改他的实现时，在双亲委派机制下，在任何的Java代码运行之前，会将所有要用到的系统类提前使用BootstrapClassLoader加载进内存（而当一个类需要被加载时必定会轮到BootstrapClassLoader来加载，只是是否能加载的问题，不能加载的必定不是系统级别的类），所以其他类加载器并没有机会再去加载，从一定程度上防止了危险代码的植入。

在指定的系统包下建立指定的类（由BootstrapClassLoader、ExtClassLoader加载的系统类）：

• Object：

package java.lang;
/*** @author lscl* @version 1.0* @intro:*/
public class Object {static {System.out.println("自定义的Object类被加载了....");}
}

• AccessBridge：

package com.sun.java.accessibility;
/*** @author lscl* @version 1.0* @intro:*/
public class AccessBridge {static {System.out.println("自定义的AccessBridge类被加载了.....");}
}

• 测试类：

package com.dfbz.demo01;
import com.sun.java.accessibility.AccessBridge;
import org.junit.Test;
/*** @author lscl* @version 1.0* @intro:*/
public class Demo04_双亲委派的好处 {@Testpublic void test1() {// java.lang.Object 类在JVM启动时就已经被加载过了,因此不会再被加载了Class