类加载器、双亲委派机制与打破（Driver、TCCL、Tomcat等）

以你之姓@ 2023-01-09 15:39 51阅读 0赞

**目录**

类与类加载器、Class< T>

双亲委派模型

1、启动类加载器

扩展类加载器

应用程序类加载器

用户自定义类加载器

线程上下文类加载器TCCL

双亲委派机制

打破双亲委派机制

1. 重写loadClass()方法

2. 使用线程上下文类加载器(TCCL )逆向获取类加载器

3. 代码热替换（Hot Swap）、模块热部署情况

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

## 类与类加载器、Class< T> ##

**对于任意一个类，都必须由加载它的类加载器和这个类本身一起共同确立其在Java虚拟机中的唯一性**，每 一个类加载器，都拥有一个独立的类名称空间。这句话可以表达得更通俗一些：比较两个类是否“相 等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个 Class文件，被同一个Java虚拟机加载，只要加载它们的类加载器不同，那这两个类就必定不相等。

这里所指的“相等”，包括代表类的Class对象的equals()方法、isAssignableFrom()方法、isInstance() 方法的返回结果，也包括了使用instanceof关键字做对象所属关系判定等各种情况。如果没有注意到类 加载器的影响，在某些情况下可能会产生具有迷惑性的结果，代码清单7-8中演示了不同的类加载器对 instanceof关键字运算的结果的影响。

![image-20200807201459475][]

*  Class是访问类型T定义的Java程序入口，在Java代码中，如果你想获取T的定义，如查看其方法定义，字段定义，首先要获取到对应的Class实例；
 *  ClassLoader实例本身对Java而言，也是一个分配在堆中的一个对象，它管理着自己在方法区的一个区域。

## 双亲委派模型 ##

![image-20200807193905594][]

### 1、启动类加载器 ###

*  启动类加载器是使用C/C++语言实现的，是JVM的一部分
 *  它用来加载Java的核心库（`JAVA_HOME/jre/lib/rt.jar`、`resources.jar`或`sun.boot.class.path`路径下的内容），用于提供JVM自身需要的类
 *  并不继承自java.lang.ClassLolader，，没有父加载器。
 *  加载扩展类和应用程序类加载器
 *  出于安全考虑，Bootstrap启动类 加载器只加载包名为java、javax、sun等开头的类

一般而言，\{JRE\_HOME\}/lib下存放着**JVM正常工作所需要的系统类**，如下表所示：

<table> 
 <thead> 
  <tr> 
   <th>文件名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>rt.jar</td> 
   <td>运行环境包，rt即runtime，J2SE 的类定义都在这个包内</td> 
  </tr> 
  <tr> 
   <td>charsets.jar</td> 
   <td>字符集支持包</td> 
  </tr> 
  <tr> 
   <td>jce.jar</td> 
   <td>是一组包，它们提供用于加密、密钥生成和协商以及 Message Authentication Code（MAC）算法的框架和实现</td> 
  </tr> 
  <tr> 
   <td>jsse.jar</td> 
   <td>安全套接字拓展包Java™ Secure Socket Extension</td> 
  </tr> 
  <tr> 
   <td>classlist</td> 
   <td>该文件内表示是引导类加载器应该加载的类的清单</td> 
  </tr> 
  <tr> 
   <td>net.properties</td> 
   <td>JVM 网络配置信息</td> 
  </tr> 
 </tbody> 
</table>

**启动类加载器(Bootstrap ClassLoader）** 加载系统类后，JVM内存会呈现如下格局：

![image-20200807200809382][]

*  引导类加载器将类信息加载到方法区中，以特定方式组织，对于某一个特定的类而言，在方法区中它应该有**运行时常量池、类型信息、字段信息、方法信息、类加载器的引用，对应class实例的引用**等信息。
 *  **类加载器的引用**，由于这些类是由引导类加载器（Bootstrap Classloader）进行加载的，而引导类加载器是有C+ +语言实现的，所以是无法访问的，故而该引用为NULL
 *  **对应cLass实例的引用**，类加载器在加载类信息放到方法区中后，会创建一个对应的Class 类型的实例放到堆（Heap）中，作为开发人员访问方法区中类定义的入口和切入点。

### 扩展类加载器 ###

这个类加载器是在类`sun.misc.Launcher$ExtClassLoader` 中以Java代码的形式实现的。它负责加载\*\*\{JRE\_HOME\}/lib/ext\*\*目录中，或者被`java.ext.dirs`系统变量所 指定的路径中所有的类库。如果用户创建的JAR放在此目录下，也会自动由扩展类加载器加载。

### 应用程序类加载器 ###

·应用程序类加载器（Application Class Loader）：这个类加载器由`sun.misc.Launcher$AppClassLoader`来实现。由于应用程序类加载器是ClassLoader类中的`getSystemClassLoader()`方法的返回值，所以有些场合中也称它为“`系统类加载器`”。它负责加载`用户类路径 （ClassPath）`上所有的类库，开发者同样可以直接在代码中使用这个类加载器。如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是**程序中默认的类加载器**。

### 用户自定义类加载器 ###

用户可以自己定义类加载器来加载类。所有的类加载器都要继承`java.lang.ClassLoader`类。

### 线程上下文类加载器TCCL ###

public Launcher() {
    	...
        try {
            this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
        } catch (IOException var9) {
            throw new InternalError("Could not create application class loader", var9);
        }
        Thread.currentThread().setContextClassLoader(this.loader);
        ...
    }

在`sun.misc.Launcher`中，我们找到了答案，在Launcher初始化的时候，会获取AppClassLoader，然后将其设置为上下文类加载器，而这个AppClassLoader，就是之前上文提到的系统类加载器Application ClassLoader，所以**上下文类加载器默认情况下就是应用程序类加载器（系统加载器）**。

## 双亲委派机制 ##

如果一个类加载器收到类加载请求，它不会首先自己去加载这个类，而是将这个请求委派给父类加载器，每一层次的类加载器都如此，比如从自定义类加载器传到应用程序类加载器，再传到扩展类加载器，最终到启动类加载器，只有当父类加载器在其搜索范围内无法找到所需要的类，并将结果反馈给子类加载器时，子类加载器才会尝试自己去加载这个类。

简述：当某个类加载器需要加载某个`.class`文件时，它首先把这个任务委托给他的**上级**类加载器，递归这个操作，如果上级的类加载器没有加载，自己才会去加载这个类。

*  如果一直到底层的类加载都没有加载到，那么就会抛出异常`ClassNotFoundException`
 *  这里类加载器之间的父子关系一般不是以继承（Inheritance）的关系来实现的，而是通常使用组合（Composition）关系来复用父加载器的代码。

![image-20200808014618733][]

双亲委派实现

//提供class类的二进制名称表示，加载对应class，加载成功，则返回表示该类对应的Class<T> instance 实例
        public Class<?> loadClass(String name) throws ClassNotFoundException {
            return loadClass(name, false);
        }    
        protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
        {
            synchronized (getClassLoadingLock(name)) {
                // 首先，检查是否已经被当前的类加载器记载过了，如果已经被加载，直接返回对应的Class<T>实例
                Class<?> c = findLoadedClass(name);
                    //初次加载
                    if (c == null) {
                    long t0 = System.nanoTime();
                    try {
                        if (parent != null) {
                            //如果有父类加载器，则先让父类加载器加载
                            c = parent.loadClass(name, false);
                        } else {
                            // 没有父加载器，则查看是否已经被引导类加载器加载，有则直接返回
                            c = findBootstrapClassOrNull(name);
                        }
                    } catch (ClassNotFoundException e) {
                        // ClassNotFoundException thrown if class not found
                        // from the non-null parent class loader
                    }
                    // 父加载器加载失败，并且没有被引导类加载器加载，则尝试该类加载器自己尝试加载
                    if (c == null) {
                        // If still not found, then invoke findClass in order
                        // to find the class.
                        long t1 = System.nanoTime();
                        // 自己尝试加载
                        c = findClass(name);
     
                        // this is the defining class loader; record the stats
                        sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                        sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                        sun.misc.PerfCounter.getFindClasses().increment();
                    }
                }
                //是否解析类 
                if (resolve) {
                    resolveClass(c);
                }
                return c;
            }
        }

双亲委派机制的作用:

1.  避免类的重复加载
2.  防止核心API被篡改，保护程序安全

> 参考：
> 
> [java双亲委派机制及作用][java]
> 
> [Java虚拟机原理图解》5. JVM类加载器机制与类加载过程][Java_5. JVM]
> 
> [图解Tomcat类加载机制(阿里面试题)][Tomcat]

## 打破双亲委派机制 ##

### 1. 重写loadClass()方法 ###

双亲委派模型的第一次“被破坏”其实发生在双亲委派模型出现之前——即JDK 1.2面世以前的“远 古”时代。由于双亲委派模型在JDK 1.2之后才被引入，但是类加载器的概念和抽象类 java.lang.ClassLoader则在Java的第一个版本中就已经存在，面对已经存在的用户自定义类加载器的代 码，Java设计者们引入双亲委派模型时不得不做出一些妥协，为了兼容这些已有代码，无法再以技术手段避免loadClass()被子类覆盖的可能性，只能在JDK 1.2之后的java.lang.ClassLoader中添加一个新的 protected方法`findClass()`，并引导用户编写的类加载逻辑时尽可能去重写这个方法，而不是在 loadClass()中编写代码。上节我们已经分析过loadClass()方法，双亲委派的具体逻辑就实现在这里面， 按照loadClass()方法的逻辑，如果父类加载失败，会自动调用自己的findClass()方法来完成加载，**这样既不影响用户按照自己的意愿去加载类，又可以保证新写出来的类加载器是符合双亲委派规则的**。

### 2. 使用线程上下文类加载器(TCCL )逆向获取类加载器 ###

双亲委派模型的第二次“被破坏”是由这个模型自身的缺陷导致的，双亲委派很好地解决了各个类 加载器协作时基础类型的一致性问题（越基础的类由越上层的加载器进行加载），基础类型之所以被 称为“基础”，是因为它们总是作为被用户代码继承、调用的API存在，但程序设计往往没有绝对不变 的完美规则，如果有基础类型又要调用回用户的代码，那该怎么办呢？

这并非是不可能出现的事情，一个典型的例子便是JNDI服务，JNDI现在已经是Java的标准服务， 它的代码由启动类加载器来完成加载（在JDK 1.3时加入到rt.jar的），肯定属于Java中很基础的类型 了。但JNDI存在的目的就是对资源进行查找和集中管理，它需要调用由其他厂商实现并部署在应用程 序的ClassPath下的JNDI服务提供者接口（Service Provider Interface，SPI）的代码，现在问题来了，启 动类加载器是绝不可能认识、加载这些代码的，那该怎么办？

为了解决这个困境，Java的设计团队只好引入了一个不太优雅的设计：`线程上下文类加载器 （Thread Context ClassLoader）`。这个类加载器可以通过java.lang.Thread类的setContext-ClassLoader()方 法进行设置，如果创建线程时还未设置，它将会从父线程中继承一个，如果在应用程序的全局范围内 都没有设置过的话，那这个类加载器默认就是应用程序类加载器。

有了**线程上下文类加载器**，程序就可以做一些“舞弊”的事情了。JNDI服务使用这个线程上下文类加载器去加载所需的SPI服务代码，这是**一种父类加载器去请求子类加载器完成类加载的行为，这种行 为实际上是打通了双亲委派模型的层次结构来逆向使用类加载器，已经违背了双亲委派模型的一般性原则**，但也是无可奈何的事情。**Java中涉及SPI的加载基本上都采用这种方式来完成**，例如JNDI、 **JDBC**、JCE、JAXB和JBI等。不过，当SPI的服务提供者多于一个的时候，代码就只能根据具体提供 者的类型来硬编码判断，为了消除这种极不优雅的实现方式，在JDK 6时，JDK提供了`java.util.ServiceLoader`类，以`META-INF/services`中的配置信息，**辅以责任链模式**，这才算是给SPI的加 载提供了一种相对合理的解决方案。

2.1 JDBC如何打破双亲委派规则？

因为在某些情况下父类加载器需要委托子类加载器去加载class文件。受到加载范围的限制，父类加载器无法加载到需要的文件。

*  以Driver接口为例，由于Driver接口定义在jdk当中的，而其实现由各个数据库的服务商来提供，比如mysql的就写了`MySQL Connector`，那么问题就来了，DriverManager（也由jdk提供）要加载各个实现了Driver接口的实现类，然后进行管理，但是DriverManager由启动类加载器加载，只能记载JAVA\_HOME的lib下文件，而其实现是由服务商提供的，由系统类加载器加载，这个时候就需要启动类加载器来委托子类来加载Driver实现，从而破坏了双亲委派，这里仅仅是举了破坏双亲委派的其中一个情况。

> 更多关于SPI、TCCL与JDBC中Drive的内容参见：
> 
> [【JVM】浅谈双亲委派和破坏双亲委派][JVM]
> 
> [真正理解线程上下文类加载器（多案例分析）][Link 1]

2.2 Tomcat中类加载Spring问题

在Tomcat目录结构中，有三组目录（“/common/*”,“/server/*”和“shared/*”）可以存放公用Java类库，此外还有第四组Web应用程序自身的目录“/WEB-INF/*”，把java类库放置在这些目录中的含义分别是：

*  放置在common目录中：类库可被Tomcat和所有的Web应用程序共同使用。
 *  放置在server目录中：类库可被Tomcat使用，但对所有的Web应用程序都不可见。
 *  放置在shared目录中：类库可被所有的Web应用程序共同使用，但对Tomcat自己不可见。
 *  放置在/WebApp/WEB-INF目录中：类库仅仅可以被此Web应用程序使用，对Tomcat和其他Web应用程序都不可见。

**为了支持这套目录结构，并对目录里面的类库进行加载和隔离，Tomcat自定义了多个类加载器，这些类加载器按照经典的双亲委派模型来实现**，如下图所示

![image-20200808124239445][]

灰色背景的3个类加载器是JDK默认提供的类加载器，这3个加载器的作用前面已经介绍过了。而 CommonClassLoader、CatalinaClassLoader、SharedClassLoader 和 WebAppClassLoader 则是 Tomcat 自己定义的类加载器，它们分别加载 /common/*、/server/*、/shared/\* 和 /WebApp/WEB-INF/\* 中的 Java 类库。其中 WebApp 类加载器和 Jsp 类加载器通常会存在多个实例，每一个 Web 应用程序对应一个 WebApp 类加载器，每一个 JSP 文件对应一个 Jsp 类加载器。

从图中的委派关系中可以看出，CommonClassLoader 能加载的类都可以被 CatalinaClassLoader 和 SharedClassLoader 使用，而 CatalinaClassLoader 和 SharedClassLoader 自己能加载的类则与对方相互隔离。WebAppClassLoader 可以使用 SharedClassLoader 加载到的类，但各个 WebAppClassLoader 实例之间相互隔离。而 **JasperLoader 的加载范围仅仅是这个 JSP 文件所编译出来的那一个 Class，它出现的目的就是为了被丢弃：当服务器检测到 JSP 文件被修改时，会替换掉目前的 JasperLoader 的实例，并通过再建立一个新的 Jsp 类加载器来实现 JSP 文件的 HotSwap 功能**。

Spring加载问题

Tomcat 加载器的实现清晰易懂，并且采用了官方推荐的“正统”的使用类加载器的方式。这时作者提一个问题：**如果有 10 个 Web 应用程序都用到了spring的话，可以把Spring的jar包放到 common 或 shared 目录下让这些程序共享。Spring 的作用是管理每个web应用程序的bean，getBean时自然要能访问到应用程序的类，而用户的程序显然是放在 /WebApp/WEB-INF 目录中的（由 WebAppClassLoader 加载），那么在 CommonClassLoader 或 SharedClassLoader 中的 Spring 容器如何去加载并不在其加载范围的用户程序（/WebApp/WEB-INF/）中的Class呢？**

解答

答案呼之欲出：spring根本不会去管自己被放在哪里，它统统使用TCCL来加载类，而TCCL默认设置为了WebAppClassLoader，也就是说哪个WebApp应用调用了spring，spring就去取该应用自己的WebAppClassLoader来加载bean，简直完美~

源码分析

有兴趣的可以接着看看具体实现。在web.xml中定义的listener为`org.springframework.web.context.ContextLoaderListener`，它最终调用了`org.springframework.web.context.ContextLoader`类来装载bean，具体方法如下（删去了部分不相关内容）：

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
    	try {
    		// 创建WebApplicationContext
    		if (this.context == null) {
    			this.context = createWebApplicationContext(servletContext);
    		}
    		// 将其保存到该webapp的servletContext中		
    		servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
    		// 获取线程上下文类加载器，默认为WebAppClassLoader
    		ClassLoader ccl = Thread.currentThread().getContextClassLoader();
    		// 如果spring的jar包放在每个webapp自己的目录中
    		// 此时线程上下文类加载器会与本类的类加载器（加载spring的）相同，都是WebAppClassLoader
    		if (ccl == ContextLoader.class.getClassLoader()) {
    			currentContext = this.context;
    		}
    		else if (ccl != null) {
    			// 如果不同，也就是上面说的那个问题的情况，那么用一个map把刚才创建的WebApplicationContext及对应的WebAppClassLoader存下来
    			// 一个webapp对应一个记录，后续调用时直接根据WebAppClassLoader来取出
    			currentContextPerThread.put(ccl, this.context);
    		}
    		
    		return this.context;
    	}
    	catch (RuntimeException ex) {
    		logger.error("Context initialization failed", ex);
    		throw ex;
    	}
    	catch (Error err) {
    		logger.error("Context initialization failed", err);
    		throw err;
    	}
    }

具体说明都在注释中，spring考虑到了自己可能被放到其他位置，所以直接用TCCL来解决所有可能面临的情况。

总结

通过上面的两个案例分析，我们可以总结出线程上下文类加载器的适用场景：

1.  **当高层提供了统一接口让低层去实现，同时又要是在高层加载（或实例化）低层的类时，必须通过线程上下文类加载器来帮助高层的ClassLoader找到并加载该类。**
2.  **当使用本类托管类加载，然而加载本类的ClassLoader未知时，为了隔离不同的调用者，可以取调用者各自的线程上下文类加载器代为托管。**

> 转载自：[真正理解线程上下文类加载器（多案例分析）][Link 1]

### 3. 代码热替换（Hot Swap）、模块热部署情况 ###

双亲委派模型的第三次“被破坏”是由于用户对程序动态性的追求而导致的，这里所说的“动态 性”指的是一些非常“热”门的名词：`代码热替换（Hot Swap`）、`模块热部署（Hot Deployment）`等。

OSGI

OSGi实现模块化热部署的关键是它自定义的类加载器机制的实现，每一个程序模块（OSGi中称为 Bundle）都有一个自己的类加载器，**当需要更换一个Bundle时，就把Bundle连同类加载器一起换掉以实现代码的热替换**。在OSGi环境下，类加载器不再双亲委派模型推荐的树状结构，而是进一步发展为更 加复杂的网状结构，当收到类加载请求时，OSGi将按照下面的顺序进行类搜索：

*  1）将以java.\*开头的类，委派给父类加载器加载。
 *  2）否则，将委派列表名单内的类，委派给父类加载器加载。
 *  3）否则，将Import列表中的类，委派给Export这个类的Bundle的类加载器加载。
 *  4）否则，查找当前Bundle的ClassPath，使用自己的类加载器加载。
 *  5）否则，查找类是否在自己的Fragment Bundle中，如果在，则委派给Fragment Bundle的类加载器 加载。
 *  6）否则，查找Dynamic Import列表的Bundle，委派给对应Bundle的类加载器加载。
 *  7）否则，类查找失败。

上面的查找顺序中只有开头两点仍然符合双亲委派模型的原则，其余的类查找都是在平级的类加载器中进行的

> 参考：
> 
> 《深入理解Java虚拟机：JVM高级特性与最佳实践（第3版》

[image-20200807201459475]: /images/20221119/c35cd025b33b4680b22278f2f9c0283d.png
[image-20200807193905594]: /images/20221119/a29abcdcc97c489ea4fe10888c4e70dd.png
[image-20200807200809382]: /images/20221119/b35e5463249e40a88b81d995c89f3378.png
[image-20200808014618733]: /images/20221119/3ee8fbb0a99a4c3da31422994c8211d7.png
[java]: https://www.jianshu.com/p/1e4011617650
[Java_5. JVM]: https://blog.csdn.net/luanlouis/article/details/50529868
[Tomcat]: https://www.cnblogs.com/aspirant/p/8991830.html
[JVM]: https://www.cnblogs.com/joemsu/p/9310226.html
[Link 1]: https://blog.csdn.net/yangcheng33/article/details/52631940
[image-20200808124239445]: /images/20221119/0f0accdbb3c84eb1a40880daf28b1e68.png