基本功：你忽略的ClassLoader

待我称王封你为后i 2022-04-11 11:20 191阅读 0赞

ClassLoader 是 Java 届最为神秘的技术之一，不是管是CS还是BS应用，都是由若干个.class文件组织而成的一个完整的Java应用程序。Class Loaders（类加载器）是JVM用于运行来动态加载类的，同时它们也是JRE的一部分，由于Class Loaders的存在，JVM运行Java程序的时候不需要知道底层文件或文件系统。

**目录**

1. 基本概念

2. 双亲委派

2.1 传递性

2.2. ClassLoader类

2.3 Class.forName

2.4 ClassLoader.loadClass vs Class.forName

2.5 依赖隔离

2.6 Thread.contextClassLoader

3. Tomcat 类加载器

4. OSGI类加载器

5. 总结

--------------------

## 1. 基本概念 ##

一般来说，Java 虚拟机使用 Java 类的方式如下：Java 源程序（.java 文件）在经过 Java 编译器编译之后就被转换成 Java 字节代码（.class 文件）。字节码可以来自于磁盘文件 \*.class，也可以是 jar 包里的 \*.class，也可以来自远程服务器提供的字节流，**字节码的本质就是一个字节数组byte\[\]**，它有特定的复杂的内部格式。**很多字节码加密技术就是依靠定制 ClassLoader 来实现的**，先使用工具对字节码文件进行加密，运行时使用定制的 ClassLoader 先解密文件内容再加载这些解密后的字节码。**类加载器负责读取 Java 字节代码，并转换成内存形式的 `java.lang.Class`类的一个实例**。

> **每个 Class 对象的内部都有一个 classLoader 字段来标识自己是由哪个 ClassLoader 加载的**。ClassLoader 就像一个容器，里面装了很多已经加载的 Class 对象。
> 
> *public final class Class<T> implements java.io.Serializable,GenericDeclaration,Type,AnnotatedElement \{  
>     private final ClassLoader classLoader;  
> \}*

**JVM 运行并不是一次性加载所需要的全部类的**，**它是按需加载，也就是延迟加载**。程序在运行的过程中会逐渐遇到很多不认识的新类，这时候就会调用 ClassLoader 来加载这些类。加载完成后就会将 Class 对象存在 ClassLoader 里面，下次就不需要重新加载了。

**思考：类装载方式会有哪些？**后面有答案

## 2. 双亲委派 ##

**JVM 运行实例中会存在多个 ClassLoader**，不同的 ClassLoader 会从不同的地方加载字节码文件。它可以从不同的文件目录加载，也可以从不同的 jar 文件中加载，也可以从网络上不同的静态文件服务器来下载字节码再加载。

JVM 中内置了三个重要的 ClassLoader。URLClassLoader属于jdk 内置，它不但可以加载远程类库，还可以加载本地路径的类库，取决于构造器中不同的地址形式。ExtensionClassLoader 和 AppClassLoader 都是 URLClassLoader 的子类，它们都是从本地文件系统里加载类库。

> **BootstrapClassLoader**
> 
> 负责加载 JVM 运行时核心类，这些类位于 $JAVA\_HOME/lib/rt.jar 文件中，我们常用内置库 [java.xxx][].\* 都在里面，比如 java.util.*、[java.io][].*、java.nio.*、java.lang.* 等等。这个 ClassLoader 比较特殊，它是由 C 代码实现的，我们将它称之为「根加载器」

> **ExtensionClassLoader**
> 
> 负责加载 JVM 扩展类，比如 swing 系列、内置的 js 引擎、xml 解析器 等等，这些库名通常以 javax 开头，它们的 jar 包位于 $JAVA\_HOME/lib/ext/\*.jar 中，有很多 jar 包。

> **AppClassLoader**
> 
> 它才是直接面向我们用户的加载器，它会加载 Classpath 环境变量里定义的路径中的 jar 包和目录。我们自己编写的代码以及使用的第三方 jar 包通常都是由它来加载的。它由 ClassLoader 类提供的静态方法 getSystemClassLoader() 得到，它就是我们所说的「系统类加载器」，我们用户平时编写的类代码通常都是由它加载的。当我们的 main 方法执行的时候，这第一个用户类的加载器就是 AppClassLoader。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70][]

> AppClassLoader 在加载一个未知的类名时，它并不是立即去搜寻 Classpath，它会首先将这个类名称交给 ExtensionClassLoader 来加载，如果 ExtensionClassLoader 可以加载，那么 AppClassLoader 就不用麻烦了。否则它就会搜索 Classpath 。
> 
> 而 ExtensionClassLoader 在加载一个未知的类名时，它也并不是立即搜寻 ext 路径，它会首先将类名称交给 BootstrapClassLoader 来加载，如果 BootstrapClassLoader 可以加载，那么 ExtensionClassLoader 也就不用麻烦了。否则它就会搜索 ext 路径下的 jar 包。
> 
> 这三个 ClassLoader 之间形成了级联的父子关系，每个 ClassLoader 都很懒，尽量把工作交给父亲做，父亲干不了了自己才会干。每个 ClassLoader 对象内部都会有一个 parent 属性指向它的父加载器。

### 2.1 传递性 ###

程序在运行过程中，遇到了一个未知的类，它会选择哪个 ClassLoader 来加载它呢？**虚拟机的策略是使用调用者 Class 对象的 ClassLoader 来加载当前未知的类**。何为调用者 Class 对象？就是在遇到这个未知的类时，虚拟机肯定正在运行一个方法调用（静态方法或者实例方法），这个方法挂在哪个类上面，那这个类就是调用者 Class 对象。前面我们提到每个 Class 对象里面都有一个 classLoader 属性记录了当前的类是由谁来加载的。

因为 ClassLoader 的传递性，所有延迟加载的类都会由初始调用 main 方法的这个 ClassLoader 全全负责，它就是AppClassLoader。

### 2.2. `ClassLoader`类 ###

ClassLoader 里面有三个重要的方法 loadClass()、findClass() 和 defineClass()， 以及parent 属性（ExtensionClassLoader 的 parent =null）。

<table> 
 <thead> 
  <tr> 
   <th colspan="1" style="width:264px;">方法</th> 
   <th colspan="1" style="width:585px;">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:264px;"><code>getParent()</code></td> 
   <td style="width:585px;">返回该类加载器的父类加载器。</td> 
  </tr> 
  <tr> 
   <td style="width:264px;"><code>loadClass(String name)</code></td> 
   <td style="width:585px;">加载名称为&nbsp;<code>name</code>的类，返回的结果是&nbsp;<code>java.lang.Class</code>类的实例。</td> 
  </tr> 
  <tr> 
   <td style="width:264px;"><code>findClass(String name)</code></td> 
   <td style="width:585px;">查找名称为&nbsp;<code>name</code>的类，返回的结果是&nbsp;<code>java.lang.Class</code>类的实例。</td> 
  </tr> 
  <tr> 
   <td style="width:264px;"><code>findLoadedClass(String name)</code></td> 
   <td style="width:585px;">查找名称为&nbsp;<code>name</code>的已经被加载过的类，返回的结果是&nbsp;<code>java.lang.Class</code>类的实例。</td> 
  </tr> 
  <tr> 
   <td style="width:264px;"><code>defineClass(String name, byte[] b, int off, int len)</code></td> 
   <td style="width:585px;">把字节数组&nbsp;<code>b</code>中的内容转换成 Java 类，返回的结果是&nbsp;<code>java.lang.Class</code>类的实例。这个方法被声明为&nbsp;<code>final</code>的。</td> 
  </tr> 
  <tr> 
   <td style="width:264px;"><code>resolveClass(Class&lt;?&gt; c)</code></td> 
   <td style="width:585px;">链接指定的 Java 类。</td> 
  </tr> 
 </tbody> 
</table>

如何自定义一个类加载器呢？

class ClassLoader {
      // 加载入口，定义了双亲委派规则
      Class loadClass(String name) {
        // 是否已经加载了
        Class t = this.findFromLoaded(name);
        if(t == null) {
          // 交给双亲
          t = this.parent.loadClass(name)
        }
        if(t == null) {
          // 双亲都不行，只能靠自己了
          t = this.findClass(name);
        }
        return t;
      }
      
      // 交给子类自己去实现
      Class findClass(String name) {
        throw ClassNotFoundException();
      }
      
      // 组装Class对象
      Class defineClass(byte[] code, String name) {
        return buildClassFromCode(code, name);
      }
    }
    
    class CustomClassLoader extends ClassLoader {
      Class findClass(String name) {
        // 寻找字节码
        byte[] code = findCodeFromSomewhere(name);
        // 组装Class对象
        return this.defineClass(code, name);
      }
    }

自定义类加载器不易破坏双亲委派规则，**不要轻易覆盖 loadClass 方法**。否则可能会导致自定义加载器无法加载内置的核心类库。在使用自定义加载器时，要明确好它的父加载器是谁，**将父加载器通过子类的构造器传入**。如果父类加载器是 null，那就表示父加载器是「根加载器」。

// ClassLoader 构造器  
protected ClassLoader(String name, ClassLoader parent);

双亲委派规则可能会变成三亲委派，四亲委派，取决于你使用的父加载器是谁，它会一直递归委派到根加载器。

### 2.3 Class.forName ###

**类装载的方式有两种：**

*  隐式装载，当碰到通过new 等方式生成对象时，隐式调用类装载器加载对应的类
 *  显式装载，通过class.forname()等方法

当我们在使用 jdbc 驱动时，经常会使用 Class.forName("com.mysql.cj.jdbc.Driver");其原理是 mysql 驱动的 Driver 类里有一个静态代码块，它会在 Driver 类被加载的时候执行。

class Driver \{  
  static \{  
    try \{  
       java.sql.DriverManager.registerDriver(new Driver());  
    \} catch (SQLException E) \{  
       throw new RuntimeException("Can't register driver!");  
    \}  
  \}  
\}  
forName 方法同样也是使用**调用者 Class 对象的 ClassLoader 来加载目标类**。不过 forName 还提供了多参数版本，可以指定使用哪个 ClassLoader 来加载。通过这种形式的 forName 方法可以突破内置加载器的限制，通过**使用自定类加载器允许我们自由加载其它任意来源的类库**。根据 ClassLoader 的传递性，目标类库传递引用到的其它类库也将会使用自定义加载器加载。

### 2.4 ClassLoader.loadClass vs Class.forName ###

具体可以参阅另一篇“[Class.forName和ClassLoader.loadClass][Class.forName_ClassLoader.loadClass]”

### 2.5 依赖隔离 ###

我们平时使用的 maven 是这样解决依赖冲突的，它会从多个冲突的版本中选择一个来使用，如果不同的版本之间兼容性很糟糕，那么程序将无法正常编译运行。Maven 这种形式叫「扁平化」依赖管理。

ClassLoader 可以很好的解决依赖问题。不同版本的软件包使用不同的 ClassLoader 对象来加载，**位于不同 ClassLoader 中名称一样的类实际上是不同的类**。

ClassLoader 固然可以解决依赖冲突问题，不过它也限制了不同软件包的操作界面必须使用反射或接口的方式进行动态调用。Maven 没有这种限制，它依赖于虚拟机的默认懒惰加载策略，运行过程中如果没有显示使用定制的 ClassLoader，那么从头到尾都是在使用 同一个AppClassLoader对象。

### 2.6 Thread.contextClassLoader ###

contextClassLoader「线程上下文类加载器」，**这究竟是什么东西？**

Thread.currentThread().getContextClassLoader().loadClass(name);

它从 JDK 1.2 开始引入的，它产生的背景是：类加载器的代理模式（父类代理子类做类加载器的事情）并不能解决 Java 应用开发中会遇到的类加载器的全部问题。SPI 的接口是 Java 核心库的一部分，SPI 是由引导类加载器来加载的，而SPI 实现的类（在业务系统中）是引导类加载器无法加载，需要应用类加载器完成，jdk就是通过contextClassLoader给予实现。

更多参阅[CurrentClassLoader和ContextClassLoader][CurrentClassLoader_ContextClassLoader]

## 3. Tomcat 类加载器 ##

对于运行在 Java EE™容器中的 Web 应用来说，类加载器的实现方式与一般的 Java 应用有所不同。不同的 Web 容器的实现方式也会有所不同。以 Apache Tomcat 来说，每个 Web 应用都有一个对应的类加载器实例。该类加载器也使用代理模式，所不同的是**它是首先尝试去加载某个类，如果找不到再代理给父类加载器**。**这与一般类加载器的顺序是相反的**。**这是 Java Servlet 规范中的推荐做法，其目的是使得 Web 应用自己的类的优先级高于 Web 容器提供的类**。这种代理模式的一个例外是：Java 核心库的类是不在查找范围之内的。这也是为了保证 Java 核心库的类型安全。

绝大多数情况下，Web 应用的开发人员不需要考虑与类加载器相关的细节。下面给出几条简单的原则：

*  每个 Web 应用自己的 Java 类文件和使用的库的 jar 包，分别放在 WEB-INF/classes和 WEB-INF/lib目录下面。
 *  多个应用共享的 Java 类文件和 jar 包，分别放在 Web 容器指定的由所有 Web 应用共享的目录下面。
 *  当出现找不到类的错误时，检查当前类的类加载器和当前线程的上下文类加载器是否正确。

## 4. OSGI类加载器 ##

OSGi™是 Java 上的动态模块系统。它为开发人员提供了面向服务和基于组件的运行环境，并提供标准的方式用来管理软件的生命周期。OSGi 已经被实现和部署在很多产品上，在开源社区也得到了广泛的支持。Eclipse 就是基于 OSGi 技术来构建的。

OSGi 中的每个模块（bundle）都包含 Java 包和类。模块可以声明它所依赖的需要导入（import）的其它模块的 Java 包和类（通过 `Import-Package`），也可以声明导出（export）自己的包和类，供其它模块使用（通过 `Export-Package`）。也就是说需要能够隐藏和共享一个模块中的某些 Java 包和类。这是通过 OSGi 特有的类加载器机制来实现的。**OSGi 中的每个模块都有对应的一个类加载器**。它负责加载模块自己包含的 Java 包和类。**当它需要加载 Java 核心库的类时（以 `java`开头的包和类），它会代理给父类加载器（通常是启动类加载器）来完成**。**当它需要加载所导入的 Java 类时，它会代理给导出此 Java 类的模块来完成加载**。模块也可以显式的声明某些 Java 包和类，必须由父类加载器来加载。只需要设置系统属性 `org.osgi.framework.bootdelegation`的值即可。

> 假设有两个模块 bundleA 和 bundleB，它们都有自己对应的类加载器 classLoaderA 和 classLoaderB。
> 
> 在 bundleA 中包含类 `com.bundleA.Sample`，并且该类被声明为导出的，也就是说可以被其它模块所使用的。bundleB 声明了导入 bundleA 提供的类 `com.bundleA.Sample`，并包含一个类 `com.bundleB.NewSample`继承自 `com.bundleA.Sample`。在 bundleB 启动的时候，其类加载器 classLoaderB 需要加载类 `com.bundleB.NewSample`，进而需要加载类 `com.bundleA.Sample`。由于 bundleB 声明了类  `com.bundleA.Sample`是导入的，classLoaderB 把加载类  `com.bundleA.Sample`的工作代理给导出该类的 bundleA 的类加载器 classLoaderA。classLoaderA 在其模块内部查找类  `com.bundleA.Sample`并定义它，所得到的类  `com.bundleA.Sample`实例就可以被所有声明导入了此类的模块使用。对于以 `java`开头的类，都是由父类加载器来加载的。如果声明了系统属性 `org.osgi.framework.bootdelegation=com.example.core.*`，那么对于包 `com.example.core`中的类，都是由父类加载器来完成的。

**OSGi 模块的这种类加载器结构，使得一个类的不同版本可以共存在 Java 虚拟机中，带来了很大的灵活性**。不过它的这种不同，也会给开发人员带来一些麻烦，尤其当模块需要使用第三方提供的库的时候。下面提供几条比较好的建议：

*  如果一个类库只有一个模块使用，把该类库的 jar 包放在模块中，在 `Bundle-ClassPath`中指明即可。
 *  如果一个类库被多个模块共用，可以为这个类库单独的创建一个模块，把其它模块需要用到的 Java 包声明为导出的。其它模块声明导入这些类。
 *  如果类库提供了 SPI 接口，并且利用线程上下文类加载器来加载 SPI 实现的 Java 类，有可能会找不到 Java 类。如果出现了 `NoClassDefFoundError`异常，首先检查当前线程的上下文类加载器是否正确。通过 `Thread.currentThread().getContextClassLoader()`就可以得到该类加载器。该类加载器应该是该模块对应的类加载器。如果不是的话，可以首先通过 `class.getClassLoader()`来得到模块对应的类加载器，再通过 `Thread.currentThread().setContextClassLoader()`来设置当前线程的上下文类加载器。

## 5. 总结 ##

ClassLoader相当于类的命名空间，起到了类隔离的作用。位于同一个 ClassLoader 里面的类名是唯一的，不同的 ClassLoader 可以持有同名的类。ClassLoader 是类名称的容器，是类的沙箱。![Class.forName_ClassLoader.loadClass][]

[java.xxx]: https://link.juejin.im?target=http%3A%2F%2Fjava.xxx
[java.io]: https://link.juejin.im?target=http%3A%2F%2Fjava.io
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70]: /images/20220411/8a10b548eeb94025b1dd7e7b486390fc.png
[Class.forName_ClassLoader.loadClass]: /images/20220411/6e9f8ca459d748d1930b10f774604149.png
[CurrentClassLoader_ContextClassLoader]: https://blog.csdn.net/alex_xfboy/article/details/89454713