ClassLoader原理

作者: 是什么样的心情 | 来源:发表于2019-06-01 23:51 被阅读0次

SpringBoot热部署使用
Hook机制学习(四) -插件加载机制
ClassLoader原理
ClassLoader原理
热修复原理与基础范例
初识ClassLoader
Android插件化原理(Small)
Android进阶解密⑤—热修复
Java ClassLoader原理
ClassLoader 原理分析

一. 什么是ClassLoader?

大家都知道，编译完后的java项目是由若干个.class文件组织而成的，当程序在运行时，即会调用该程序的一个入口函数来调用系统的相关功能，而这些功能都被封装在不同的class文件当中，所以经常要从这个class文件中要调用另外一个class文件中的方法，如果另外一个文件不存在的，则会引发系统异常。而程序在启动的时候，并不会一次性加载程序所要用的所有class文件，而是根据程序的需要，通过Java的类加载机制（ClassLoader）来动态加载某个class文件到内存当中的，从而只有class文件被载入到了内存之后，才能被其它class所引用。所以ClassLoader就是用来动态加载class文件到内存当中用的。

二. Java默认提供的三个ClassLoader

2.1 Bootstrap ClassLoader

称为启动类加载器，是Java类加载层次中最顶层的类加载器，负责加载JDK中的核心类库，如：rt.jar、resources.jar、charsets.jar等，可通过如下程序获得该类加载器从哪些地方加载了相关的jar或class文件：

URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();  
for (int i = 0; i < urls.length; i++) {  
  System.out.println(urls[i].toExternalForm());  
}

以下内容是上述程序从本机JDK环境所获得的结果：

file:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/resources.jar
file:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/rt.jar
file:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/sunrsasign.jar
file:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/jsse.jar
file:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/jce.jar
file:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/charsets.jar
file:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/jfr.jar
file:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/classes

其实上述结果也是通过查找sun.boot.class.path这个系统属性所得知的。

System.out.println(System.getProperty("sun.boot.class.path"));

打印结果：

/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/resources.jar:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/rt.jar:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/sunrsasign.jar:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/jsse.jar:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/jce.jar:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/charsets.jar:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/lib/jfr.jar:/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.212.b04-0.el7_6.x86_64/jre/classes

2.2 Extension ClassLoader

称为扩展类加载器，负责加载Java的扩展类库，默认加载JAVA_HOME/jre/lib/ext/目下的所有jar。

2.3 App ClassLoader

称为系统类加载器，负责加载应用程序classpath目录下的所有jar和class文件。
注意： 除了Java默认提供的三个ClassLoader之外，用户还可以根据需要定义自已的ClassLoader，而这些自定义的ClassLoader都必须继承自java.lang.ClassLoader类，也包括Java提供的另外二个ClassLoader（Extension ClassLoader和App ClassLoader）在内，但是Bootstrap ClassLoader不继承自ClassLoader，因为它不是一个普通的Java类，底层由C++编写，已嵌入到了JVM内核当中，当JVM启动后，Bootstrap ClassLoader也随着启动，负责加载完核心类库后，并构造Extension ClassLoader和App ClassLoader类加载器。

三. ClassLoader加载类的原理

3.1 原理介绍

ClassLoader使用的是双亲委托模型来搜索类的，每个ClassLoader实例都有一个父类加载器的引用（不是继承的关系，是一个包含的关系），虚拟机内置的类加载器（Bootstrap ClassLoader）本身没有父类加载器，但可以用作其它ClassLoader实例的的父类加载器。当一个ClassLoader实例需要加载某个类时，它会试图亲自搜索某个类之前，先把这个任务委托给它的父类加载器，这个过程是由上至下依次检查的，首先由最顶层的类加载器Bootstrap ClassLoader试图加载，如果没加载到，则把任务转交给Extension ClassLoader试图加载，如果也没加载到，则转交给App ClassLoader 进行加载，如果它也没有加载得到的话，则返回给委托的发起者，由它到指定的文件系统或网络等URL中加载该类。如果它们都没有加载到这个类时，则抛出ClassNotFoundException异常。否则将这个找到的类生成一个类的定义，并将它加载到内存当中，最后返回这个类在内存中的Class实例对象。
ClassLoader的体系架构：

ClassLoader.png

3.2 为什么要使用双亲委托这种模型呢？

类数据共用。只需父加载器加载一次类到虚拟机，节省虚拟机方法区空间。
避免篡改核心类。核心类由系统类加载器加载，避免子加载器替换核心类造成各种问题。

3.3 未使用双亲委托模型的情况

双亲委托模型机制是在loadclass()方法里实现的，如果重写loadclass方法则就破坏了此机制
上层类加载器加载的类需要使用由下层类加载器加载的类。
比如JDBC的DriveManager类的getConntection(String url, java.util.Properties info, Class<?> caller)方法：

    //  Worker method called by the public getConnection() methods.
    private static Connection getConnection(
        String url, java.util.Properties info, Class<?> caller) throws SQLException {
        /*
         * When callerCl is null, we should check the application's
         * (which is invoking this class indirectly)
         * classloader, so that the JDBC driver class outside rt.jar
         * can be loaded from here.
         */
        ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
        synchronized(DriverManager.class) {
            // synchronize loading of the correct classloader.
            if (callerCL == null) {
                callerCL = Thread.currentThread().getContextClassLoader();
            }
        }

        if(url == null) {
            throw new SQLException("The url cannot be null", "08001");
        }

        println("DriverManager.getConnection(\"" + url + "\")");

        // Walk through the loaded registeredDrivers attempting to make a connection.
        // Remember the first exception that gets raised so we can reraise it.
        SQLException reason = null;

        for(DriverInfo aDriver : registeredDrivers) {
            // If the caller does not have permission to load the driver then
            // skip it.
            if(isDriverAllowed(aDriver.driver, callerCL)) {
                try {
                    println("    trying " + aDriver.driver.getClass().getName());
                    Connection con = aDriver.driver.connect(url, info);
                    if (con != null) {
                        // Success!
                        println("getConnection returning " + aDriver.driver.getClass().getName());
                        return (con);
                    }
                } catch (SQLException ex) {
                    if (reason == null) {
                        reason = ex;
                    }
                }

            } else {
                println("    skipping: " + aDriver.getClass().getName());
            }

        }

        // if we got here nobody could connect.
        if (reason != null)    {
            println("getConnection failed: " + reason);
            throw reason;
        }

        println("getConnection: no suitable driver found for "+ url);
        throw new SQLException("No suitable driver found for "+ url, "08001");
    }

方法首先去获取调用类的类加载器，如果为null，则通过Tread.getContextClassLoader()方法获取，获取到后用来加载Driver的实现类。子线程的Thread Context ClassLoader 如果没有设置，则默认设置为父线程的Thread Context ClassLoader，初始线程的Thread Context ClassLoader 默认为App ClassLoader

OSGI 热部署
笔者对此技术不熟悉，暂不表述

3.3 JVM在搜索类的时候，又是如何判定两个class是相同的呢？

类名相同
同一个类加载器实例加载
验证：
在web服务器上建一个org.classloader.simple.NetClassLoaderSimple.java类

package org.classloader.simple;

public class NetClassLoaderSimple {
    private NetClassLoaderSimple instance;

    public void setNetClassLoaderSimple(Object obj) {
        this.instance = (NetClassLoaderSimple) obj;
    }
}

org.classloader.simple.NetClassLoaderSimple类的setNetClassLoaderSimple方法接收一个Object类型参数，并将它强制转换成org.classloader.simple.NetClassLoaderSimple类型。
测试两个class是否相同

          package classloader;  
            public class NewworkClassLoaderTest {  
              public static void main(String[] args) {  
                  try {  
                  //测试加载网络中的class文件  
                  String rootUrl = "http://localhost:8080/httpweb/classes";  
                  String className = "org.classloader.simple.NetClassLoaderSimple";  
                  NetworkClassLoader ncl1 = new NetworkClassLoader(rootUrl);  
                  NetworkClassLoader ncl2 = new NetworkClassLoader(rootUrl);  
                  Class<?> clazz1 = ncl1.loadClass(className);  
                  Class<?> clazz2 = ncl2.loadClass(className);  
                  Object obj1 = clazz1.newInstance();  
                  Object obj2 = clazz2.newInstance();  
                  clazz1.getMethod("setNetClassLoaderSimple", Object.class).invoke(obj1, obj2);  
                  } catch (Exception e) {  
                  e.printStackTrace();  
                  }  
          }  
        }

首先获得网络上一个class文件的二进制名称，然后通过自定义的类加载器NetworkClassLoader创建两个实例，并根据网络地址分别加载这份class，并得到这两个ClassLoader实例加载后生成的Class实例clazz1和clazz2，最后将这两个Class实例分别生成具体的实例对象obj1和obj2，再通过反射调用clazz1中的setNetClassLoaderSimple方法。
查看测试结果

ClassLoadTestResult1.jpg

结论：从结果中可以看出，虽然是同一份class字节码文件，但是由于被两个不同的ClassLoader实例所加载，所以JVM认为它们就是两个不同的类。
延伸：一些热部署的方法就是重新创建一个类加载器实例，再用这个类加载器加载修改过的class文件

四. 定义自已的ClassLoader

既然JVM已经提供了默认的类加载器，为什么还要定义自已的类加载器呢？
因为Java中提供的默认ClassLoader，只加载指定目录下的jar和class，如果我们想加载其它位置的类或jar时，比如：我要加载网络上的一个class文件，通过动态加载到内存之后，要调用这个类中的方法实现我的业务逻辑。在这样的情况下，默认的ClassLoader就不能满足我们的需求了，所以需要定义自己的ClassLoader。
定义自已的类加载器分为两步：

继承java.lang.ClassLoader
重写父类的findClass方法
父类有那么多方法，为什么偏偏只重写findClass方法？
因为JDK已经在loadClass方法中帮我们实现了ClassLoader搜索类的算法，当在loadClass方法中搜索不到类时，loadClass方法就会调用findClass方法来搜索类，所以我们只需重写该方法即可。如没有特殊的要求，一般不建议重写loadClass搜索类的算法。
示例：自定义一个NetworkClassLoader，用于加载网络上的class文件

package classloader;  

import java.io.ByteArrayOutputStream;  
import java.io.InputStream;  
import java.net.URL;  

/** 
 * 加载网络class的ClassLoader 
 */  
public class NetworkClassLoader extends ClassLoader {  

    private String rootUrl;  

    public NetworkClassLoader(String rootUrl) {  
        this.rootUrl = rootUrl;  
    }  

    @Override  
    protected Class<?> findClass(String name) throws ClassNotFoundException {  
        Class clazz = null;//this.findLoadedClass(name); // 父类已加载     
        //if (clazz == null) {  //检查该类是否已被加载过  
            byte[] classData = getClassData(name);  //根据类的二进制名称,获得该class文件的字节码数组  
            if (classData == null) {  
                throw new ClassNotFoundException();  
            }  
            clazz = defineClass(name, classData, 0, classData.length);  //将class的字节码数组转换成Class类的实例  
        //}   
        return clazz;  
    }  

    private byte[] getClassData(String name) {  
        InputStream is = null;  
        try {  
            String path = classNameToPath(name);  
            URL url = new URL(path);  
            byte[] buff = new byte[1024*4];  
            int len = -1;  
            is = url.openStream();  
            ByteArrayOutputStream baos = new ByteArrayOutputStream();  
            while((len = is.read(buff)) != -1) {  
                baos.write(buff,0,len);  
            }  
            return baos.toByteArray();  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            if (is != null) {  
               try {  
                  is.close();  
               } catch(IOException e) {  
                  e.printStackTrace();  
               }  
            }  
        }  
        return null;  
    }  

    private String classNameToPath(String name) {  
        return rootUrl + "/" + name.replace(".", "/") + ".class";  
    }  

}

测试类：

package classloader;  

public class ClassLoaderTest {  

    public static void main(String[] args) {  
        try {  
            /*ClassLoader loader = ClassLoaderTest.class.getClassLoader();  //获得ClassLoaderTest这个类的类加载器 
            while(loader != null) { 
                System.out.println(loader); 
                loader = loader.getParent();    //获得父加载器的引用 
            } 
            System.out.println(loader);*/  

            String rootUrl = "http://localhost:8080/httpweb/classes";  
            NetworkClassLoader networkClassLoader = new NetworkClassLoader(rootUrl);  
            String classname = "org.classloader.simple.NetClassLoaderTest";  
            Class clazz = networkClassLoader.loadClass(classname);  
            System.out.println(clazz.getClassLoader());  

        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  

}

打印结果：

ClassLoaderResult2.jpg

下图是web服务器的目录结构：

ClassLoaderTestResult3.jpg

目前常用web服务器中都定义了自己的类加载器，用于加载web应用指定目录下的类库（jar或class），如：Weblogic、Jboss、tomcat等，下面以Tomcat为例，展示该web容器都定义了哪些个类加载器：

新建一个web工程httpweb
新建一个ClassLoaderServletTest，用于打印web容器中的ClassLoader层次结构

import java.io.IOException;  
import java.io.PrintWriter;
import javax.servlet.ServletException;  
import javax.servlet.http.HttpServlet;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  

public class ClassLoaderServletTest extends HttpServlet {  

    public void doGet(HttpServletRequest request, HttpServletResponse response)  
            throws ServletException, IOException {  

        response.setContentType("text/html");  
        PrintWriter out = response.getWriter();  
        ClassLoader loader = this.getClass().getClassLoader();  
        while(loader != null) {  
            out.write(loader.getClass().getName()+"<br/>");  
            loader = loader.getParent();  
        }  
        out.write(String.valueOf(loader));  
        out.flush();  
        out.close();  
    }  

    public void doPost(HttpServletRequest request, HttpServletResponse response)  
            throws ServletException, IOException {  
        this.doGet(request, response);  
    }  

}

配置Servlet，并启动服务

<?xml version="1.0" encoding="UTF-8"?>  
<web-app version="2.4"   
    xmlns="http://java.sun.com/xml/ns/j2ee"   
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee   

http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

  <servlet>  
    <servlet-name>ClassLoaderServletTest</servlet-name>  
    <servlet-class>ClassLoaderServletTest</servlet-class>  
  </servlet>  

  <servlet-mapping>  
    <servlet-name>ClassLoaderServletTest</servlet-name>  
    <url-pattern>/servlet/ClassLoaderServletTest</url-pattern>  
  </servlet-mapping>  
  <welcome-file-list>  
    <welcome-file>index.jsp</welcome-file>  
  </welcome-file-list>  
</web-app>

访问Servlet，获得显示结果

ClassLoaderTestResult4.jpg

五. ClassLoader使用案例

5.1 tomcat

先看下tomcat类加载器的结构

tomcat_classloader.png

可以看到，tomcat 沿用经典的双亲委托模型，Common类加载器加载公共类（/common/*），Catalina类加载器加载tomcat服务器专用的类(/server/*)，Shared类加载器加载被各个web项目共享的类(/shared/*)，WebApp类加载器加载各个Web项目，每个Web项目使用不同WebApp类加载器实例实现各个项目的隔离（各个类加载器实例只加载自己路径的class文件，如果有相同名称的class，由于使用类加载器实例不同，在jvm中也会被当作不同的类来处理）。每个JSP文件都有一个类加载器实例对应，当tomcat检测到某个JSP文件被修改后，会替换到它对应的类加载器，并使用新的类加载器重新加载JSP文件所对应的class文件，这就实现了JSP文件的热部署

参考资料

Java ClassLoader 原理详细分析

SpringBoot热部署使用
devtools的原理深层原理是使用了两个ClassLoader，一个Classloader加载那些不会改变的类...
Hook机制学习(四) -插件加载机制
weishu_博客一：Classloader加载的基本原理基本原理：系统通过ClassLoader加载了需要的...
ClassLoader原理
什么是ClassLoader java的源代码通过javac编译后，生成字节码(.class文件)，通过jvm解析...
ClassLoader原理
一. 什么是ClassLoader? 大家都知道，编译完后的java项目是由若干个.class文件组织而成的，当程...
热修复原理与基础范例
原理 ClassLoader 与双亲委托热修复建立的基础是 ClassLoader 的加载机制。 Androi...
初识ClassLoader
ClassLoader原理 ClassLoader使用双亲委托模型来对类进行搜索加载。除了最基础的BootStra...
Android插件化原理(Small)
插件化原理(small) ClassLoader DexClassLoader 和 PathClassLoader...
Android进阶解密⑤—热修复
在此之前已经总结过ClassLoader的原理，以及通过ClassLoader方式实现的热修复思路，实现热修复的方...
Java ClassLoader原理
ClassLoader概念 ClassLoader是用来动态加载class文件到内存中的机制，程序在启动时，并不会...
ClassLoader 原理分析
一. 什么是ClassLoader 程序在启动的时候，并不会一次性加载程序所要用的所有class文件，而是根据程序...

ClassLoader原理

一. 什么是ClassLoader?

二. Java默认提供的三个ClassLoader

2.1 Bootstrap ClassLoader

2.2 Extension ClassLoader

2.3 App ClassLoader

三. ClassLoader加载类的原理

3.1 原理介绍

3.2 为什么要使用双亲委托这种模型呢？

3.3 未使用双亲委托模型的情况

3.3 JVM在搜索类的时候，又是如何判定两个class是相同的呢？

四. 定义自已的ClassLoader

五. ClassLoader使用案例

5.1 tomcat

参考资料

相关文章

SpringBoot热部署使用

Hook机制学习(四) -插件加载机制

ClassLoader原理

ClassLoader原理

热修复原理与基础范例

初识ClassLoader

Android插件化原理(Small)

Android进阶解密⑤—热修复

Java ClassLoader原理

ClassLoader 原理分析

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读