Java类加载机制

本文为采集多篇文章整理得到，主要工作中OSGI架构中涉及到类加载器场景较多，所以整合一起

类加载的机制的层次结构

每个编写的”.java”拓展名类文件都存储着需要执行的程序逻辑，这些”.java”文件经过Java编译器编译成拓展名为”.class”的文件，”.class”文件中保存着Java代码经转换后的虚拟机指令，当需要使用某个类时，虚拟机将会加载它的”.class”文件，并创建对应的class对象，将class文件加载到虚拟机的内存，这个过程称为类加载，这里我们需要了解一下类加载的过程，如下：

加载：类加载过程的一个阶段：通过一个类的完全限定查找此类字节码文件，并利用字节码文件创建一个Class对象

 

验证：目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，不会危害虚拟机自身安全。主要包括四种验证，文件格式验证，元数据验证，字节码验证，符号引用验证。

 

准备：为类变量(即static修饰的字段变量)分配内存并且设置该类变量的初始值即0(如static int i=5;这里只将i初始化为0，至于5的值将在初始化时赋值)，这里不包含用final修饰的static，因为final在编译的时候就会分配了，注意这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中。

 

解析：主要将常量池中的符号引用替换为直接引用的过程。符号引用就是一组符号来描述目标，可以是任何字面量，而直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。有类或接口的解析，字段解析，类方法解析，接口方法解析(这里涉及到字节码变量的引用，如需更详细了解，可参考《深入Java虚拟机》)。

 

初始化：类加载最后阶段，若该类具有超类，则对其进行初始化，执行静态初始化器和静态初始化成员变量(如前面只初始化了默认值的static变量将会在这个阶段赋值，成员变量也将被初始化)。

 

这便是类加载的5个过程，而类加载器的任务是根据一个类的全限定名来读取此类的二进制字节流到JVM中，然后转换为一个与目标类对应的java.lang.Class对象实例，在虚拟机提供了3种类加载器，引导（Bootstrap）类加载器、扩展（Extension）类加载器、系统（System）类加载器（也称应用类加载器），下面分别介绍

 

启动（Bootstrap）类加载器

启动类加载器主要加载的是JVM自身需要的类，这个类加载使用C++语言实现的，是虚拟机自身的一部分，它负责将 <JAVA_HOME>/lib路径下的核心类库或-Xbootclasspath参数指定的路径下的jar包加载到内存中，注意必由于虚拟机是按照文件名识别加载jar包的，如rt.jar，如果文件名不被虚拟机识别，即使把jar包丢到lib目录下也是没有作用的(出于安全考虑，Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类)。

 

扩展（Extension）类加载器

扩展类加载器是指Sun公司(已被Oracle收购)实现的sun.misc.Launcher$ExtClassLoader类，由Java语言实现的，是Launcher的静态内部类，它负责加载<JAVA_HOME>/lib/ext目录下或者由系统变量-Djava.ext.dir指定位路径中的类库，开发者可以直接使用标准扩展类加载器。

 

系统（System）类加载器

也称应用程序加载器是指 Sun公司实现的sun.misc.Launcher$AppClassLoader。它负责加载系统类路径java -classpath或-D java.class.path 指定路径下的类库，也就是我们经常用到的classpath路径，开发者可以直接使用系统类加载器，一般情况下该类加载是程序中默认的类加载器，通过ClassLoader#getSystemClassLoader()方法可以获取到该类加载器。

　 在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器相互配合执行的，在必要时，我们还可以自定义类加载器，需要注意的是，Java虚拟机对class文件采用的是按需加载的方式，也就是说当需要使用该类时才会将它的class文件加载到内存生成class对象，而且加载某个类的class文件时，Java虚拟机采用的是双亲委派模式即把请求交由父类处理，它一种任务委派模式，下面我们进一步了解它。

 

理解双亲委派模式

双亲委派模式工作原理

双亲委派模式要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器，请注意双亲委派模式中的父子关系并非通常所说的类继承关系，而是采用组合关系来复用父类加载器的相关代码，类加载器间的关系如下：

 

其实无论是ExtClassLoader还是AppClassLoader都继承URLClassLoader类，因此它们都遵守双亲委托模型，这点是毋庸置疑的。ok~，到此我们对ClassLoader、URLClassLoader、ExtClassLoader、AppClassLoader以及Launcher类间的关系有了比较清晰的了解，同时对一些主要的方法也有一定的认识，这里并没有对这些类的源码进行详细的分析，毕竟没有那个必要，因为我们主要弄得类与类间的关系和常用的方法同时搞清楚双亲委托模式的实现过程，为编写自定义类加载器做铺垫就足够了。ok~，前面出现了很多父类加载器的说法，但每个类加载器的父类到底是谁，一直没有阐明，下面我们就通过代码验证的方式来阐明这答案。

 

类加载器间的关系

我们进一步了解类加载器间的关系(并非指继承关系)，主要可以分为以下4点

 

1. 启动类加载器，由C++实现，没有父类。

 

1. 拓展类加载器(ExtClassLoader)，由Java语言实现，父类加载器为null

 

1. 系统类加载器(AppClassLoader)，由Java语言实现，父类加载器为ExtClassLoader

 

1. 自定义类加载器，父类加载器肯定为AppClassLoader。

 

类与类加载器

在JVM中表示两个class对象是否为同一个类对象存在两个必要条件

 

类的完整类名必须一致，包括包名。

加载这个类的ClassLoader(指ClassLoader实例对象)必须相同。

也就是说，在JVM中，即使这个两个类对象(class对象)来源同一个Class文件，被同一个虚拟机所加载，但只要加载它们的ClassLoader实例对象不同，那么这两个类对象也是不相等的，这是因为不同的ClassLoader实例对象都拥有不同的独立的类名称空间，所以加载的class对象也会存在不同的类名空间中，但前提是覆写loadclass方法，从前面双亲委派模式对loadClass()方法的源码分析中可以知，在方法第一步会通过Class<?> c = findLoadedClass(name);从缓存查找，类名完整名称相同则不会再次被加载，因此我们必须绕过缓存查询才能重新加载class对象。当然也可直接调用findClass()方法，这样也避免从缓存查找。

 

打破双亲委派模型

 

上文提到过双亲委派模型并不是一个强制性的约束模型，而是Java设计者推荐给开发者的类加载器实现方式。在Java的世界中大部分的类加载器都遵循这个模型，但也有例外。

双亲委派模型的一次“被破坏”是由这个模型自身的缺陷所导致的，双亲委派很好地解决了各个类加载器的基础类的统一问题（越基础的类由越上层的加载器进行加载），基础类之所以称为“基础”，是因为它们总是作为被用户代码调用的API，但世事往往没有绝对的完美，如果基础类又要调用回用户的代码，那该怎么办？这并非是不可能的事情，一个典型的例子便是JNDI服务，JNDI现在已经是Java的标准服务，它的代码由启动类加载器去加载（在JDK 1.3时放进去的rt.jar），但JNDI的目的就是对资源进行集中管理和查找，它需要调用由独立厂商实现并部署在应用程序的Class Path下的JNDI接口提供者（SPI，Service Provider Interface）的代码，但启动类加载器不可能“认识”这些代码，因为启动类加载器的搜索范围中找不到用户应用程序类，那该怎么办？为了解决这个问题，Java设计团队只好引入了一个不太优雅的设计：线程上下文类加载器（Thread Context ClassLoader）。这个类加载器可以通过java.lang.Thread类的setContextClassLoader()方法进行设置，如果创建线程时还未设置，它将会从父线程中继承一个，如果在应用程序的全局范围内都没有设置过的话，那这个类加载器默认就是应用程序类加载器（Application ClassLoader）。

有了线程上下文类加载器，就可以做一些“舞弊”的事情了，JNDI服务使用这个线程上下文类加载器去加载所需要的SPI代码，也就是父类加载器请求子类加载器去完成类加载的动作，这种行为实际上就是打通了双亲委派模型的层次结构来逆向使用类加载器，实际上已经违背了双亲委派模型的一般性原则，但这也是无可奈何的事情。Java中所有涉及SPI的加载动作基本上都采用这种方式，例如JNDI、JDBC、JCE、JAXB和JBI等。

双亲委派模型的另一次“被破坏”是由于用户对程序动态性的追求而导致的，这里所说的“动态性”指的是当前一些非常“热门”的名词：代码热替换（HotSwap）、模块热部署（HotDeployment）等，说白了就是希望应用程序能像我们的计算机外设那样，接上鼠标、U盘，不用重启机器就能立即使用，鼠标有问题或要升级就换个鼠标，不用停机也不用重启。对于个人计算机来说，重启一次其实没有什么大不了的，但对于一些生产系统来说，关机重启一次可能就要被列为生产事故，这种情况下热部署就对软件开发者，尤其是企业级软件开发者具有很大的吸引力。Sun公司所提出的JSR-294、JSR-277规范在与JCP组织的模块化规范之争中落败给JSR-291（即OSGi R4.2），虽然Sun不甘失去Java模块化的主导权，独立在发展Jigsaw项目，但目前OSGi已经成为了业界“事实上”的Java模块化标准，而OSGi实现模块化热部署的关键则是它自定义的类加载器机制的实现。每一个程序模块（OSGi中称为Bundle）都有一个自己的类加载器，当需要更换一个Bundle时，就把Bundle连同类加载器一起换掉以实现代码的热替换。

在OSGi环境下，类加载器不再是双亲委派模型中的树状结构，而是进一步发展为更加复杂的网状结构，当收到类加载请求时，OSGi将按照下面的顺序进行类搜索：

1）将以java.*开头的类委派给父类加载器加载。

2）否则，将委派列表名单内的类委派给父类加载器加载。

3）否则，将Import列表中的类委派给Export这个类的Bundle的类加载器加载。

4）否则，查找当前Bundle的Class Path，使用自己的类加载器加载。

5）否则，查找类是否在自己的Fragment Bundle中，如果在，则委派给Fragment Bundle的类加载器加载。

6）否则，查找Dynamic Import列表的Bundle，委派给对应Bundle的类加载器加载。

7）否则，类查找失败。

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

只要有足够意义和理由，突破已有的原则就可认为是一种创新。正如OSGi中的类加载器并不符合传统的双亲委派的类加载器，并且业界对其为了实现热部署而带来的额外的高复杂度还存在不少争议，但在Java程序员中基本有一个共识：OSGi中对类加载器的使用是很值得学习的，弄懂了OSGi的实现，就可以算是掌握了类加载器的精髓。

 

二、OSGi：灵活的类加载器架构

既然说到OSGI，就要来解释一下OSGi是什么，以及它的作用

　　OSGi（Open Service Gateway Initiative）：是OSGi联盟指定的一个基于Java语言的动态模块化规范，这个规范最初是由Sun、IBM、爱立信等公司联合发起，目的是使服务提供商通过住宅网管为各种家用智能设备提供各种服务，后来这个规范在Java的其他技术领域也有不错的发展，现在已经成为Java世界中的“事实上”的模块化标准，并且已经有了Equinox、Felix等成熟的实现。OSGi在Java程序员中最著名的应用案例就是Eclipse IDE

　　OSGi中的每一个模块（称为Bundle）与普通的Java类库区别并不大，两者一般都以JAR格式进行封装，并且内部存储的都是Java Package和Class。但是一个Bundle可以声明它所依赖的Java Package（通过Import-Package描述），也可以声明他允许导出发布的Java Package（通过Export-Package描述）。在OSGi里面，Bundle之间的依赖关系从传统的上层模块依赖底层模块转变为平级模块之间的依赖（至少外观上如此），而且类库的可见性能得到精确的控制，一个模块里只有被Export过的Package才可能由外界访问，其他的Package和Class将会隐藏起来。除了更精确的模块划分和可见性控制外，引入OSGi的另外一个重要理由是，基于OSGi的程序很可能可以实现模块级的热插拔功能，当程序升级更新或调试除错时，可以只停用、重新安装然后启动程序的其中一部分，这对企业级程序开发来说是一个非常有诱惑性的特性

　　OSGi之所以能有上述“诱人”的特点，要归功于它灵活的类加载器架构。OSGi的Bundle类加载器之间只有规则，没有固定的委派关系。例如，某个Bundle声明了一个它依赖的Package，如果有其他的Bundle声明发布了这个Package，那么所有对这个Package的类加载动作都会为派给发布他的Bundle类加载器去完成。不涉及某个具体的Package时，各个Bundle加载器是平级关系，只有具体使用某个Package和Class的时候，才会根据Package导入导出定义来构造Bundle间的委派和依赖

　　另外，一个Bundle类加载器为其他Bundle提供服务时，会根据Export-Package列表严格控制访问范围。如果一个类存在于Bundle的类库中但是没有被Export，那么这个Bundle的类加载器能找到这个类，但不会提供给其他Bundle使用，而且OSGi平台也不会把其他Bundle的类加载请求分配给这个Bundle来处理

　　一个例子：假设存在BundleA、BundleB、BundleC三个模块，并且这三个Bundle定义的依赖关系如下：

　　BundleA：声明发布了packageA，依赖了java.*的包

　　BundleB：声明依赖了packageA和packageC，同时也依赖了Java.*的包

　　BundleC：声明发布了packageC，依赖了packageA

　　那么，这三个Bundle之间的类加载器及父类加载器之间的关系如下图：

　　

　　由于没有涉及到具体的OSGi实现，所以上图中的类加载器没有指明具体的加载器实现，只是一个体现了加载器之间关系的概念模型，并且只是体现了OSGi中最简单的加载器委派关系。一般来说，在OSGi中，加载一个类可能发生的查找行为和委派关系会比上图中显示的复杂，类加载时的查找规则如下：

　　　　1）以java.*开头的类，委派给父类加载器加载

　　　　2）否则，委派列表名单内的类，委派给父类加载器加载

　　　　3）否则，Import列表中的类，委派给Export这个类的Bundle的类加载器加载

　　　　4）否则，查找当前Bundle的ClassPath，使用自己的类加载器加载

　　　　5）否则，查找是否在自己的Fragment Bundle中，如果是，则委派给Fragment bundle的类加载器加载

　　　　6）否则，查找Dynamic Import列表的Bundle，委派给对应Bundle的类加载器加载

　　　　7）否则，查找失败

　　从之前的图可以看出，在OSGi里面，加载器的关系不再是双亲委派模型的树形架构，而是已经进一步发展成了一种更复杂的、运行时才能确定的网状结构。

 

Tomcat的类加载机制

Tomcat的类加载器可以分为两部分，第一个是Tomcat自身所使用的类加载器，会加载jre的lib包及tomcat的lib包的类，遵循类加载的双亲委派机制；第二个是每个Web应用程序用的，每个web应用程序都有自己专用的WebappClassLoader，优先加载/web-inf/lib下的jar中的class文件，这样就隔离了每个web应用程序的影响，但是webappClassLoader没有遵循类加载的双亲委派机制，处理的方法就是在使用webappClassLoader的load加载类会进行过滤，如果有些类被过滤掉还是通过双亲委派机制优先从父加载器中加载类。

 

一、Tomcat类加载器初始化

在tomcat调用Bootstrap进行启动时会调用initClassLoaders创建3个ClassLoader，它们分别是commonLoader,catalinaLoader,sharedLoader，遵循双亲委派机制。commonLoader会根据tomcat的conf/catalina.properties中的配置加载tomcat自身的jar，然后将这个类加载器作为整个tomcat容器的父类加载器。

common.loader="${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"

接下来我们看看这3个类加载器都使用了在什么地方，commonLoader除了在initClassLoader处使用外并没有在其他地方使用，它是作为catalinaLoader和sharedLoader的父类加载器；catalinaLoader在init方法中被设置为当前线程的类加载器。

sharedLoader类加载器作为参数调用了Catalina的setParentClassLoader方法，成为了整个Catalina容器的父类加载器，当然也是WebAppClassLoader的父类加载器。

二、WebAppClassLoader应用类加载器

在tomcat中对每个应用都有一个WebAppClassLoader用来隔绝不同应用之前的class文件，因此WebAppClassLoader的创建工作也是在Context中进行的，在StandardContext的startInternal方法开启一个web应用时会创建类加载器。

在WebappClassLoader的父类WebappClassLoaderBase中实现了start方法

 

在WebappClassLoaderBase中重写了ClassLoader的loadClass方法，在这个实现方法中我们可以一窥tomcat真正的类加载机制，简单来说web应用首先还是去尝试加载jre下面的类这个流程是不可变的，接下来web应用就可以根据设置首先是加载自己应用下的class文件还是tomcat的lib目录下的class文件了，实现逻辑看loadClass的实现机制还是比较简单的，所有通过设置web应用可以遵循类加载的双亲委派机制或者不遵循双亲委派机制了。

@Override     public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {           synchronized (getClassLoadingLock(name)) {             if (log.isDebugEnabled())                 log.debug("loadClass(" + name + ", " + resolve + ")");             Class<?> clazz = null;               // Log access to stopped class loader             checkStateForClassLoading(name);               // (0) Check our previously loaded local class cache                             //从当前ClassLoader的本地缓存中加载类，如果找到则返回             clazz = findLoadedClass0(name);             if (clazz != null) {                 if (log.isDebugEnabled())                     log.debug("  Returning class from cache");                 if (resolve)                     resolveClass(clazz);                 return (clazz);             }               // (0.1) Check our previously loaded class cache                             // 本地缓存没有的情况下，调用ClassLoader的findLoadedClass方法查看jvm是否已经加载过此类，如果已经加载则直接返回。             clazz = findLoadedClass(name);             if (clazz != null) {                 if (log.isDebugEnabled())                     log.debug("  Returning class from cache");                 if (resolve)                     resolveClass(clazz);                 return (clazz);             }               // (0.2) Try loading the class with the system class loader, to prevent             //       the webapp from overriding Java SE classes. This implements             //       SRV.10.7.2                             //通过系统的来加载器加载此类，这里防止应用写的类覆盖了J2SE的类,这句代码非常关键，如果不写的话，                             //就会造成你自己写的类有可能会把J2SE的类给替换调，另外假如你写了一个javax.servlet.Servlet类，放在当前应用的WEB-INF/class中，                             //如果没有此句代码的保证，那么你自己写的类就会替换到Tomcat容器Lib中包含的类。             String resourceName = binaryNameToPath(name, false);               ClassLoader javaseLoader = getJavaseClassLoader();             boolean tryLoadingFromJavaseLoader;             try {                 // Use getResource as it won't trigger an expensive                 // ClassNotFoundException if the resource is not available from                 // the Java SE class loader. However (see                 // https://bz.apache.org/bugzilla/show_bug.cgi?id=58125 for                 // details) when running under a security manager in rare cases                 // this call may trigger a ClassCircularityError.                 tryLoadingFromJavaseLoader = (javaseLoader.getResource(resourceName) != null);             } catch (ClassCircularityError cce) {                 // The getResource() trick won't work for this class. We have to                 // try loading it directly and accept that we might get a                 // ClassNotFoundException.                 tryLoadingFromJavaseLoader = true;             }               if (tryLoadingFromJavaseLoader) {                 try {                     clazz = javaseLoader.loadClass(name);                     if (clazz != null) {                         if (resolve)                             resolveClass(clazz);                         return (clazz);                     }                 } catch (ClassNotFoundException e) {                     // Ignore                 }             }               if (securityManager != null) {                 int i = name.lastIndexOf('.');                 if (i >= 0) {                     try {                         securityManager.checkPackageAccess(name.substring(0,i));                     } catch (SecurityException se) {                         String error = "Security Violation, attempt to use " +                             "Restricted Class: " + name;                         log.info(error, se);                         throw new ClassNotFoundException(error, se);                     }                 }             }                             //判断是否需要委托给父类加载器进行加载，delegate属性默认为false，那么delegatedLoad的值就取决于filter的返回值了，filter中是优先加载tomcat的lib下的class文件                             //filter方法中根据包名来判断是否需要进行委托加载，默认情况下会返回false.因此delegatedLoad为false             boolean delegateLoad = delegate || filter(name, true);               // (1) Delegate to our parent if requested                              //因为delegatedLoad为false,那么此时不会委托父加载器去加载，这里其实是没有遵循parent-first的加载机制。             if (delegateLoad) {                 if (log.isDebugEnabled())                     log.debug("  Delegating to parent classloader1 " + parent);                 try {                     clazz = Class.forName(name, false, parent);                     if (clazz != null) {                         if (log.isDebugEnabled())                             log.debug("  Loading class from parent");                         if (resolve)                             resolveClass(clazz);                         return (clazz);                     }                 } catch (ClassNotFoundException e) {                     // Ignore                 }             }               // (2) Search local repositories                             //调用findClass方法在webapp级别进行加载             if (log.isDebugEnabled())                 log.debug("  Searching local repositories");             try {                 clazz = findClass(name);                 if (clazz != null) {                     if (log.isDebugEnabled())                         log.debug("  Loading class from local repository");                     if (resolve)                         resolveClass(clazz);                     return (clazz);                 }             } catch (ClassNotFoundException e) {                 // Ignore             }               // (3) Delegate to parent unconditionally                             //如果还是没有加载到类，并且不采用委托机制的话，则通过父类加载器去加载。             if (!delegateLoad) {                 if (log.isDebugEnabled())                     log.debug("  Delegating to parent classloader at end: " + parent);                 try {                     clazz = Class.forName(name, false, parent);                     if (clazz != null) {                         if (log.isDebugEnabled())                             log.debug("  Loading class from parent");                         if (resolve)                             resolveClass(clazz);                         return (clazz);                     }                 } catch (ClassNotFoundException e) {                     // Ignore                 }             }         }           throw new ClassNotFoundException(name);     }