使用 类加载器 并不会导致类的主动初始化，他只是执行了加载过程中的加载阶段。

1. 三大类加载器

  • BootStrap ClassLoader：根类加载器，由 C++ 编写，负责 虚拟机核心类库 的加载，比如整个 java.lang 包都是根加载器加载的，即 JAVA_HOME\jre\lib 目录下的资源
  • Extension ClassLoader：扩展类加载器，由 java 语言编写，加载 JAVA_HOME\jre\lb\ext 目录下的资源
  • Application ClassLoader：系统类加载器，加载 classpath 路径下的类库资源以及二方三方jar包，他的父加载器是扩展类加载器，同时他也是自定义类加载器的默认父加载器。

【注意】每个ClassLoader都维护了一份自己的名称空间， 同一个名称空间里不能出现两个同名的类。
image.png
image.png

2. 双亲委托机制

也称：父委托机制，当一个类加载器被调用了loadClass之后，它并不会直接将其加载，而是先交给当前类加载器的父加载器尝试加载直到最顶层的父加载器，然后再依次向下进行加载。

image.png

3. 自定义类加载器

所有的自定义类加载器都必须直接或间接的继承 ClassLoader抽象类 ，同时必须实现 findClass() 方法，否则会抛出 Class 找不到的异常。为了保证类加载时不使用根类加载器、扩展类加载器进行类加载，可以采用破坏双亲委托机制的方式，编写自定义类加载器，需要注意重写 loadClass() 方法。

  • 直接或间接继承 ClassLoader 抽象类
  • 重写 findClass() 方法：否则会报类找不见异常

  • 重写 loadClass() 方法：破坏双亲委托机制

    1. public class BrokerDelegateClassLoader extends ClassLoader {
    3.   /** 自定义类加载路径 */
    4.   private final static Path DEFAULT_CLASS_DIR = Paths.get("E:", "tmp_dir", "classloader");
    6.   /** class文件的存储目录 */
    7.   private final Path classDir;
    9.   public BrokerDelegateClassLoader() {
    10.       super();
    11.       this.classDir = DEFAULT_CLASS_DIR;
    12.   }
    14.   public BrokerDelegateClassLoader(String classDir) {
    15.       super();
    16.       this.classDir = Paths.get(classDir);
    17.   }
    19.   public BrokerDelegateClassLoader(String classDir, ClassLoader parent) {
    20.       super(parent);
    21.       this.classDir = Paths.get(classDir);
    22.   }
    24.   /** 重写findClass()方法，否则会报类找不见异常 */
    25.   @Override
    26.   protected Class<?> findClass(String name) throws ClassNotFoundException {
    27.       byte[] bytes = null;
    28.       try {
    29.           bytes = this.readClassBytes(name);
    30.           if (null == bytes || bytes.length == 0) {
    31.               throw new ClassNotFoundException("Can not load this class " + name);
    32.           }
    33.       } catch (IOException e) {
    34.           e.printStackTrace();
    35.       }
    36.       return this.defineClass(name, bytes, 0, bytes.length);
    37.   }
    39.   /**
    40.    * 将二进制文件读取到内存中
    41.    * @param name
    42.    * @return
    43.    * @throws ClassNotFoundException
    44.    */
    45.   private byte[] readClassBytes(String name) throws ClassNotFoundException, IOException {
    46.       String classPath = name.replace(".", "/");
    47.       Path classFullPath = classDir.resolve(Paths.get(classPath + ".class"));
    48.       if (!classFullPath.toFile().exists()) {
    49.           throw new ClassNotFoundException("The class " + name + " not found.");
    50.       }
    52.       try (ByteArrayOutputStream stream = new ByteArrayOutputStream()) {
    53.           Files.copy(classFullPath, stream);
    54.           return stream.toByteArray();
    55.       } catch (IOException e) {
    56.           throw new ClassNotFoundException("load the class " + name + " occur error.", e);
    57.       }
    58.   }
    60.   @Override
    61.   protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    62.       /** 1.根据类的全路径名称进行加锁，确保每一个类在多线程情况下只被加载一次 */
    63.       synchronized (getClassLoadingLock(name)) {
    64.           /**
    65.            * findLoadedClass 为本地 native 方法
    66.            *   => 在已加载类的缓存中查看该类是否已经被加载，是则直接返回
    67.            */
    68.           Class<?> loadedClass = findLoadedClass(name);
    69.           /** 若缓存中没有被加载的类，则需要对其进行首次加载 */
    70.           if (loadedClass == null) {
    71.               /** 如果类的全路径以java或javax开头，则直接委托给系统类加载器进行加载 */
    72.               if (name.startsWith("java.") || name.startsWith("javax")) {
    73.                   try {
    74.                       loadedClass = getSystemClassLoader().loadClass(name);
    75.                   } catch (Exception e) {
    76.                       // TODO
    77.                   }
    78.               } else {
    79.                   try {
    80.                       /** 使用自定义类加载器进行加载 */
    81.                       loadedClass = this.findClass(name);
    82.                   } catch (ClassNotFoundException e) {
    83.                       // TODO
    84.                   }
    85.                   /** 若自定义类加载器仍旧没有完成对类的加载，则委托给父类加载器或者系统类加载器加载 */
    86.                   if (loadedClass == null) {
    87.                       if (getParent() != null) {
    88.                           loadedClass = getParent().loadClass(name);
    89.                       } else {
    90.                           loadedClass = getSystemClassLoader().loadClass(name);
    91.                       }
    92.                   }
    93.               }
    94.           }
    95.           /** 经过一系列尝试之后，还是无法对类进行加载，则抛出无法找到类的异常 */
    96.           if (loadedClass == null) {
    97.               throw new ClassNotFoundException("The class " + name + " not found.");
    98.           }
    99.           if (resolve) {
    100.               resolveClass(loadedClass);
    101.           }
    102.           return loadedClass;
    103.       }
    104.   }
    105. }

    4. 实例：热部署

    热部署：即在程序运行时进行某个模块功能的升级，甚至在不停止服务的前提下增加新的功能。

【注意】热部署首先要卸载掉加载该模块所有 Class 的类加载器，卸载类加载器会导致所有类的卸载，显然我们无法对JVM三大内置类加载器进行卸载，我们只有通过控制自定义类加载器才能实现该功能。即破坏掉双亲/父委托机制。