javasec类加载机制

Posted 2023-04-19 海屿-uf9n1x

这篇文章介绍java的类加载机制。

Java是一个依赖于JVM（Java虚拟机）实现的跨平台的开发语言。Java程序在运行前需要先编译成class文件，Java类初始化的时候会调用java.lang.ClassLoader加载类字节码，ClassLoader会调用JVM的native方法（defineClass0/1/2）来定义一个java.lang.Class实例。

ClassLoader加载器

一切的Java类都必须经过JVM加载后才能运行，而ClassLoader的主要作用就是Java类文件的加载。

在JVM类加载器中最顶层的是Bootstrap ClassLoader（引导类加载器）、Extension ClassLoader（扩展类加载器）、App ClassLoader（系统类加载器），AppClassLoader是默认的类加载器，如果类加载时我们不指定类加载器的情况下，默认会使用AppClassLoader加载类，ClassLoader.getSystemClassLoader()返回的系统类加载器也是AppClassLoader。

ClassLoader类有如下核心方法：

1. loadClass（加载指定的Java类）
2. findClass（查找指定的Java类）
3. findLoadedClass（查找JVM已经加载过的类）
4. defineClass（定义一个Java类）
5. resolveClass（链接指定的Java类）

Java类动态加载方式

Java类加载方式分为显式和隐式,显式即我们通常使用Java反射或者ClassLoader来动态加载一个类对象，而隐式指的是类名.方法名()或new类实例。显式类加载方式也可以理解为类动态加载，我们可以自定义类加载器去加载任意的类。

// 反射加载TestHelloWorld示例
Class.forName("com.test.classloader.TestHelloWorld");

// ClassLoader加载TestHelloWorld示例
this.getClass().getClassLoader().loadClass("com.test.classloader.TestHelloWorld");

/*
Class.forName("类名")默认会初始化被加载类的静态属性和方法，
如果不希望初始化类可以使用Class.forName("类名", 是否初始化类, 类加载器)，而ClassLoader.loadClass默认不会初始化类方法。
*/
//隐式
TestHelloWorld.get()
  
Class test = new TestHelloWorld()

其他加载方式：

URLClassLoader 任意类加载：file/http/jar

ClassLoader.defineClass 字节码加载任意类

Unsafe.defineClass 字节码加载

ClassLoader类加载流程

ClassLoader加载com.test.classloader.TestHelloWorld类重要流程如下：

1.ClassLoader会调用public Class<?> loadClass(String name)方法加载com.test.classloader.TestHelloWorld类。
2.调用findLoadedClass方法检查TestHelloWorld类是否已经初始化，如果JVM已初始化过该类则直接返回类对象。
3.如果创建当前ClassLoader时传入了父类加载器（new ClassLoader(父类加载器)）就使用父类加载器加载TestHelloWorld类，否则使用JVM的Bootstrap ClassLoader加载。
4.如果上一步无法加载TestHelloWorld类，那么调用自身的findClass方法尝试加载TestHelloWorld类。
5.如果当前的ClassLoader没有重写了findClass方法，那么直接返回类加载失败异常。如果当前类重写了findClass方法并通过传入的com.test.classloader.TestHelloWorld类名找到了对应的类字节码，那么应该调用defineClass方法去JVM中注册该类。
6.如果调用loadClass的时候传入的resolve参数为true，那么还需要调用resolveClass方法链接类，默认为false。
7.返回一个被JVM加载后的java.lang.Class类对象。

自定义ClassLoader

java.lang.ClassLoader是所有的类加载器的父类，java.lang.ClassLoader有非常多的子类加载器，比如我们用于加载jar包的java.net.URLClassLoader其本身通过继承java.lang.ClassLoader类，重写了findClass方法从而实现了加载目录class文件甚至是远程资源文件。

但是如果com.test.classloader.TestHelloWorld根本就不存在于我们的classpath，那么我们可以使用自定义类加载器重写findClass方法，然后在调用defineClass方法的时候传入TestHelloWorld类的字节码的方式来向JVM中定义一个TestHelloWorld类，最后通过反射机制就可以调用TestHelloWorld类的hello方法了。

package com.test.classloader;

import java.lang.reflect.Method;

public class TestClassLoader extends ClassLoader 

    // TestHelloWorld类名
    private static String testClassName = "com.test.classloader.TestHelloWorld";

    // TestHelloWorld类字节码
    private static byte[] testClassBytes = new byte[]
            -54, -2, -70, -66, 0, 0, 0, 51, 0, 17, 10, 0, 4, 0, 13, 8, 0, 14, 7, 0, 15, 7, 0,
            16, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100,
            101, 1, 0, 15, 76, 105, 110, 101, 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, 101,
            1, 0, 5, 104, 101, 108, 108, 111, 1, 0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108,
            97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 10, 83, 111, 117, 114, 99,
            101, 70, 105, 108, 101, 1, 0, 19, 84, 101, 115, 116, 72, 101, 108, 108, 111, 87, 111,
            114, 108, 100, 46, 106, 97, 118, 97, 12, 0, 5, 0, 6, 1, 0, 12, 72, 101, 108, 108, 111,
            32, 87, 111, 114, 108, 100, 126, 1, 0, 40, 99, 111, 109, 47, 97, 110, 98, 97, 105, 47,
            115, 101, 99, 47, 99, 108, 97, 115, 115, 108, 111, 97, 100, 101, 114, 47, 84, 101, 115,
            116, 72, 101, 108, 108, 111, 87, 111, 114, 108, 100, 1, 0, 16, 106, 97, 118, 97, 47, 108,
            97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 0, 33, 0, 3, 0, 4, 0, 0, 0, 0, 0, 2, 0, 1,
            0, 5, 0, 6, 0, 1, 0, 7, 0, 0, 0, 29, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 1, -79, 0, 0, 0,
            1, 0, 8, 0, 0, 0, 6, 0, 1, 0, 0, 0, 7, 0, 1, 0, 9, 0, 10, 0, 1, 0, 7, 0, 0, 0, 27, 0, 1,
            0, 1, 0, 0, 0, 3, 18, 2, -80, 0, 0, 0, 1, 0, 8, 0, 0, 0, 6, 0, 1, 0, 0, 0, 10, 0, 1, 0, 11,
            0, 0, 0, 2, 0, 12
    ;

    @Override
    public Class<?> findClass(String name) throws ClassNotFoundException 
        // 只处理TestHelloWorld类
        if (name.equals(testClassName)) 
            // 调用JVM的native方法定义TestHelloWorld类
            return defineClass(testClassName, testClassBytes, 0, testClassBytes.length);
        

        return super.findClass(name);
    

    public static void main(String[] args) 
        // 创建自定义的类加载器
        TestClassLoader loader = new TestClassLoader();

        try 
            // 使用自定义的类加载器加载TestHelloWorld类
            Class testClass = loader.loadClass(testClassName);

            // 反射创建TestHelloWorld类，等价于 TestHelloWorld t = new TestHelloWorld();
            Object testInstance = testClass.newInstance();

            // 反射获取hello方法
            Method method = testInstance.getClass().getMethod("hello");

            // 反射调用hello方法,等价于 String str = t.hello();
            String str = (String) method.invoke(testInstance);

            System.out.println(str);
         catch (Exception e) 
            e.printStackTrace();
        
    

双亲委派

当一个类加载器收到类加载请求的时候，它首先不会自己去加载这个类的信息，而是把该请求转发给父类加载器，依次向上。所以所有的类加载请求都会被传递到父类加载器中，只有当父类加载器中无法加载到所需的类，子类加载器才会自己尝试去加载该类。当当前类加载器和所有父类加载器都无法加载该类时，抛出ClassNotFindException异常。
这么做的目的是：

1.防止重复加载同一个.class
2.保证核心.class不被篡改，提高系统安全性

类的卸载

1、 有JVM自带的三种类加载器Bootstrap ClassLoader（引导类加载器）、Extension ClassLoader（扩展类加载器）、App ClassLoader（系统类加载器）加载的类始终不会卸载。因为JVM始终引用这些类加载器，这些类加载器使用引用他们所加载的类，因此这些Class类对象始终是可到达的。
2、由用户自定义类加载器加载的类，是可以被卸载的。

JVM中的Class只有满足以下三个条件，才能被GC回收机制回收，也就是该Class被卸载（unload）：
1.该类所有的实例都已经被GC，也就是JVM中不存在该Class的任何实例
2.加载该类的ClassLoader已经被GC
3.该类的java.lang.Class 对象没有在任何地方被引用，如不能在任何地方通过反射访问该类的方法

tomcat学习笔记Tomcat类加载机制

tomcat学习笔记（四）Tomcat类加载机制

• 类加载机制
• • jvm的类加载机制
  • 双亲委派机制
  • • 双亲委派机制的作用
  • tomcat类加载机制

类加载机制

java类(.java)->字节码文件（.class）->字节码文件需要被加载到jvm内存中（这个过程就是类加载的过程）
类加载器（Classloader，jvm启动的时候先把类加载器读取到内存当中去，其他的类（比如各种jar中的字节码文件，自己开发的代码编译之后的.class文件等））

tomcat的类加载机制是在jvm类加载机制基础之上进行了一些变动。

jvm的类加载机制

jvm的类加载机制中有一个非常重要的角色ClassLoader，类加载器有自己的体系，jvm内置了几种类加载器，他们之间形成父子关系，通过parent属性来定义这种关系。

类加载器	作用
引导启动类加载器BootstrapClassLoader	c++编写，加载java核⼼库 java.*,⽐如rt.jar中的类，构造ExtClassLoader和AppClassLoader
扩展类加载器 ExtClassLoader	java编写，加载扩展库 JAVA_HOME/lib/ext⽬录下的jar中的类，如classpath中的jre ，javax.*或者java.ext.dir指定位置中的类
系统类加载器SystemClassLoader/AppClassLoader	默认的类加载器，搜索环境变量 classpath 中指明的路径

另外：⽤户可以⾃定义类加载器（Java编写，⽤户⾃定义的类加载器，可加载指定路径的 class ⽂件）
当 JVM 运⾏过程中，⽤户⾃定义了类加载器去加载某些类时，会按照下⾯的步骤（⽗类委托机制）
1） ⽤户⾃⼰的类加载器，把加载请求传给⽗加载器，⽗加载器再传给其⽗加载器，⼀直到加载器树的顶层
2）最顶层的类加载器⾸先针对其特定的位置加载，如果加载不到就转交给⼦类
3）如果⼀直到底层的类加载都没有加载到，那么就会抛出异常 ClassNotFoundException
因此，按照这个过程可以想到，如果同样在 classpath 指定的⽬录中和⾃⼰⼯作⽬录中存放相同的class，会优先加载 classpath ⽬录中的⽂件

双亲委派机制

当某个类加载器需要加载某个.class⽂件时，它⾸先把这个任务委托给他的上级类加载器，递归这个操 作，如果上级的类加载器没有加载，⾃⼰才会去加载这个类。

双亲委派机制的作用

1、防⽌重复加载同⼀个.class。通过委托去向上⾯问⼀问，加载过了，就不⽤再加载⼀遍。保证数据 安全。
2、保证核⼼.class不能被篡改。通过委托⽅式，不会去篡改核⼼.class，即使篡改也不会去加载，即使加载也不会是同⼀个.class对象了。不同的加载器加载同⼀个.class也不是同⼀个.class对象。这样保证了class执⾏安全（如果⼦类加载器先加载，那么我们可以写⼀些与java.lang包中基础类同名 的类， 然后再定义⼀个⼦类加载器，这样整个应⽤使⽤的基础类就都变成我们⾃⼰定义的类了。）

tomcat类加载机制

Tomcat的类加载机制相对于jvm的类加载机制做了一些改变。
没有严格的遵从双亲委派机制，打破了双亲委派机制。
tomcat在原有的类加载机制的层次之下又添加了几个类加载器

1、引导类加载器 和 扩展类加载器 的作⽤不变
2、系统类加载器正常情况下加载的是 CLASSPATH 下的类，但是 Tomcat 的启动脚本并未使⽤该变量，⽽是加载tomcat启动的类，⽐如bootstrap.jar，通常在catalina.bat或者catalina.sh中指定。位于CATALINA_HOME/bin下
3、Common 通⽤类加载器加载Tomcat使⽤以及应⽤通⽤的⼀些类，位于CATALINA_HOME/lib下，
⽐如servlet-api.jar
4、Catalina ClassLoader ⽤于加载服务器内部可⻅类，这些类应⽤程序不能访问
5、Shared ClassLoader ⽤于加载应⽤程序共享类，这些类服务器不会依赖
6、Webapp ClassLoader，每个应⽤程序都会有⼀个独⼀⽆⼆的Webapp ClassLoader，他⽤来加载本应⽤程序 /WEB-INF/classes 和 /WEB-INF/lib 下的类。

tomcat 8.5 默认改变了严格的双亲委派机制
⾸先从 Bootstrap Classloader加载指定的类
如果未加载到，则从 /WEB-INF/classes加载
如果未加载到，则从 /WEB-INF/lib/*.jar 加载
如果未加载到，则依次从 System、Common、Shared 加载（在这最后⼀步，遵从双亲委派机制）