Java中的类加载器

1、启动类加载器（Bootstrap Class Loader）

这个类加载器主要负责加载存放在<JAVA_HOME>\lib目录下的类库。

public class TEST_CL{
       public static void main(String[] args) {
           System.out.println(String.class.getClassLoader());    }}

输出结果为null，则表示由Bootstrap类加载器加载。

2、扩展类加载器（Extension Class Loader）

这个类加载器主要负责加载<JAVA_HOME>\lib\ext目录下的类库。

在这里插入图片描述

随便找一个类。

public class TEST_CL{
       public static void main(String[] args) {
           System.out.println(com.sun.java.accessibility.AccessBridge.class.getClassLoader());    }}

sun.misc.Launcher$ExtClassLoader@677327b6

3、应用程序类加载器（Application Class Loader）

这个类加载器主要负责加载用户类路径（ClassPath）上所有的类库。

public class TEST_CL{
       public static void main(String[] args) {
           System.out.println(TEST_CL.class.getClassLoader());    }}

sun.misc.Launcher$AppClassLoader@18b4aac2

双亲委派模型

在这里插入图片描述

双亲委派的工作模式

如果一个类加载器收到了类加载的请求，它首先会看看是否有加载过，如果没有它不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到最顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去完成加载。

父类加载器并不是父子继承关系，而是组合关系，父加载器是通过成员变量定义的。

双亲委派的好处

出于安全性考虑Java中的类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类java.lang.Object，它存放在rt.jar之中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的启动类加载器进行加载，因此Object类在程序的各种类加载器环境中都能够保证是同一个类。反之，如果没有使用双亲委派模型，都由各个类加载器自行去加载的话，如果用户自己也编写了一个名为java.lang.Object的类，并放在程序的ClassPath中，那系统中就会出现多个不同的Object类，Java类型体系中最基础的行为也就无从保证，应用程序将会变得一片混乱。

源码分析

省略部分源码

public abstract class ClassLoader {
   	//加载器的父类也是ClassLoader	private final ClassLoader parent;    protected Class
    loadClass(String name, boolean resolve)        throws ClassNotFoundException    {
           synchronized (getClassLoadingLock(name)) {
               // First, check if the class has already been loaded            Class
    c = findLoadedClass(name);            if (c == null) {
                   long t0 = System.nanoTime();                try {
                       if (parent != null) {
                       	//如果之前没有加载过，并且父加载器不为空，则委托给父类加载                        c = parent.loadClass(name, false);                    } else {
                       	//parent为null则表示已经是Bootstrap类加载器了，此时要么返回加载到的class，要么返回null                        c = findBootstrapClassOrNull(name);                    }                } catch (ClassNotFoundException e) {
                       // ClassNotFoundException thrown if class not found                    // from the non-null parent class loader                }								//如果父类加载器没加载到，则调用本身的findClass加载                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;        }    }}

打破双亲委派

JNDI

JNDI的代码由启动类加载器来完成加载，但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的加载提供了一种相对合理的解决方案。

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虚拟机》（第三版）周志明

转载地址：http://sllrb.baihongyu.com/

你可能感兴趣的文章