手写一个JVM自定义类加载器-CSDN博客

本文链接：https://blog.csdn.net/m0_72397750/article/details/140672998

1. 自定义类加载器的意义

隔离加载类：在某些框架内进行中间件与应用的模块隔离，把类加载到不同的环境。比如：阿里内某容器框架通过自定义类加载器确保应用中依赖的jar包不会影响到中间件运行时使用的jar包。再比如：Tomcat这类Web应用服务器，内部自定义了好几种类加载器，用于隔离同一个Web应用服务器上的不同应用程序。（类的仲裁–>类冲突）
修改类加载的方式：类的加载模型并非强制，除Bootstrap外，其他的加载并非一定要引入，或者根据实际情况在某个时间点进行按需进行动态加载。
扩展加载源：比如从数据库、网络、甚至是电视机机顶盒进行加载。
防止源码泄漏：Java代码容易被编译和篡改，可以进行编译加密。那么类加载也需要自定义，还原加密的字节码。

2. 手写一个自定义类加载器

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * @author polaris
 * @version 1.0
 * ClassName UserClassLoader
 * Package main.java.classloader
 * Description
 * @create 2024-07-21 20:06
 */
public class CustomerClassLoader extends ClassLoader{
    private String rootPath;
    public CustomerClassLoader (String rootPath){
        this.rootPath = rootPath;
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String filePath = rootPath + "\\" + name.replace(".", "\\") + ".class";
        //获取指定路径的class文件对应的二进制流数据
        byte[] data = getBytesFromPath(filePath);
        return defineClass(name,data,0,data.length);
    }
    public byte[] getBytesFromPath(String path){
        FileInputStream fis = null;
        ByteArrayOutputStream baos = null;
        try {
            fis = new FileInputStream(path);
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while((len=fis.read(buffer))!=-1){
                baos.write(buffer,0,len);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                assert fis != null;
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                assert baos != null;
                baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return new byte[0];
    }
    public static void main (String[] args){
        try {
            String rootDir = "G:\\JavaLearning2023\\20_JVMJava虚拟机\\尚硅谷宋红康JVM精讲与GC调优\\JVMdachang\\chapter02_classload\\src";

            //######################自定义类加载器1
            CustomerClassLoader loader1 = new CustomerClassLoader(rootDir);
            Class<?> clazz1 = loader1.loadClass("com.atguigu.java3.User");
            System.out.println("----------自定义类加载器1----------");
            System.out.println("获取到的Class1实例："+clazz1);
            System.out.println("Class1的类加载器："+clazz1.getClassLoader());
            System.out.println("类加载器的父类加载器："+clazz1.getClassLoader().getParent());
            Class<?> clazz11 = loader1.findClass("com.atguigu.java3.User");
            System.out.println("获取到的Class11实例："+clazz11);
            System.out.println("Class11的类加载器："+clazz11.getClassLoader());
            System.out.println("类加载器的父类加载器："+clazz11.getClassLoader().getParent());

            //######################自定义类加载器2
            CustomerClassLoader loader2 = new CustomerClassLoader(rootDir);
            Class clazz2 = loader2.findClass("com.atguigu.java3.User");
            System.out.println("----------自定义类加载器2----------");
            System.out.println("获取到的Class2实例："+clazz2);
            System.out.println("Class2的类加载器："+clazz2.getClassLoader());
            System.out.println("类加载器的父类加载器："+clazz2.getClassLoader().getParent());
            System.out.println("clazz1==clazz2 :" + (clazz1 == clazz2));//clazz1与clazz2对应了不同的类模板结构。
            System.out.println("clazz11==clazz2 :" + (clazz11 == clazz2));//clazz11与clazz2对应了不同的类模板结构。
            Class clazz22 = loader2.loadClass("com.atguigu.java3.User");
            System.out.println("获取到的Class22实例："+clazz22);
            System.out.println("Class22的类加载器："+clazz22.getClassLoader());
            System.out.println("类加载器的父类加载器："+clazz22.getClassLoader().getParent());
            System.out.println("clazz22==clazz2 :" + (clazz22 == clazz2));//clazz22与clazz2对应了相同的类模板结构。
            //######################自定义类加载器3
            CustomerClassLoader loader3 = new CustomerClassLoader(rootDir);
            Class<?> clazz3 = loader3.loadClass("com.atguigu.java3.User");
            System.out.println("----------自定义类加载器3----------");
            System.out.println("获取到的Class3实例："+clazz3);
            System.out.println("Class3的类加载器："+clazz3.getClassLoader());
            System.out.println("类加载器的父类加载器："+clazz3.getClassLoader().getParent());
            System.out.println("clazz1==clazz3 :" + (clazz1 == clazz3));//clazz1与clazz3对应了相同的类模板结构。
            //######################系统类加载器
            System.out.println("----------系统类加载器----------");
            Class clazz4 = ClassLoader.getSystemClassLoader().loadClass("com.atguigu.java3.User");
            System.out.println("获取到的Class4实例："+clazz4);
            System.out.println("Class4的类加载器："+clazz4.getClassLoader());
            System.out.println("类加载器的父类加载器："+clazz4.getClassLoader().getParent());
            System.out.println("clazz1==clazz4 :" + (clazz1 == clazz4));//clazz1与clazz4对应了相同的类模板结构。
            //######################new对象的加载器
            System.out.println("----------new对象的加载器----------");
            com.atguigu.java3.User user = new com.atguigu.java3.User();
            Class<? extends com.atguigu.java3.User> clazz5 = user.getClass();
            System.out.println("获取到的Class5实例："+clazz5);
            System.out.println("Class5的类加载器："+clazz5.getClassLoader());
            System.out.println("类加载器的父类加载器："+clazz5.getClassLoader().getParent());
            System.out.println("clazz1==clazz5 :" + (clazz1 == clazz5));//clazz1与clazz5对应了相同的类模板结构。
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}
输出
----------自定义类加载器1----------
获取到的Class1实例：class com.atguigu.java3.User
Class1的类加载器：sun.misc.Launcher$AppClassLoader@18b4aac2
类加载器的父类加载器：sun.misc.Launcher$ExtClassLoader@4b67cf4d
获取到的Class11实例：class com.atguigu.java3.User
Class11的类加载器：com.atguigu.java3.CustomerClassLoader@7ea987ac
类加载器的父类加载器：sun.misc.Launcher$AppClassLoader@18b4aac2
----------自定义类加载器2----------
获取到的Class2实例：class com.atguigu.java3.User
Class2的类加载器：com.atguigu.java3.CustomerClassLoader@29453f44
类加载器的父类加载器：sun.misc.Launcher$AppClassLoader@18b4aac2
clazz1==clazz2 :false
clazz11==clazz2 :false
获取到的Class22实例：class com.atguigu.java3.User
Class22的类加载器：com.atguigu.java3.CustomerClassLoader@29453f44
类加载器的父类加载器：sun.misc.Launcher$AppClassLoader@18b4aac2
clazz22==clazz2 :true
----------自定义类加载器3----------
获取到的Class3实例：class com.atguigu.java3.User
Class3的类加载器：sun.misc.Launcher$AppClassLoader@18b4aac2
类加载器的父类加载器：sun.misc.Launcher$ExtClassLoader@4b67cf4d
clazz1==clazz3 :true
----------系统类加载器----------
获取到的Class4实例：class com.atguigu.java3.User
Class4的类加载器：sun.misc.Launcher$AppClassLoader@18b4aac2
类加载器的父类加载器：sun.misc.Launcher$ExtClassLoader@4b67cf4d
clazz1==clazz4 :true
----------new对象的加载器----------
获取到的Class5实例：class com.atguigu.java3.User
Class5的类加载器：sun.misc.Launcher$AppClassLoader@18b4aac2
类加载器的父类加载器：sun.misc.Launcher$ExtClassLoader@4b67cf4d
clazz1==clazz5 :true

说明：

在自定义类加载器1中

用**loadClass()**方法加载，虽然是自定义类加载器，但是还是用的是系统类加载器AppClassLoader，其父类加载器是扩展类ExtClassLoader，这是因为基于双亲委派机制，会先向上层父类加载器请求加载，这里AppClassLoader正好管理了classpath下的所有类，就加载了User类，就没有loader1什么事了。

用**findClass()**方法加载，跳过了双亲委派机制，直接用当前类加载器加载，所以是CustomerClassLoader，其父类加载器是AppClassLoader。

而在自定义类加载器2中

用**findClass()**方法加载跳过了双亲委派机制，直接用当前类加载器加载，所以是CustomerClassLoader，其父类加载器是AppClassLoader。虽然都是自定义类加载器，但是是不同的类加载器实例，所以获取到Class实例clazz11和clazz2不同，clazz1和clazz就更不等了。

用**loadClass()**方法加载，会先检查是否已经被加载过了，发现已经用CustomerClassLoader加载过了，就会直接返回clazz2。

在自定义类加载器3中

还是用**loadClass()**方法加载，会先检查是否已经被加载过了，还没有加载过，根据双亲委派机制用AppClassLoader加载，但系统类加载器共用了clazz1的，已经加载过直接返回实例，所以clazz3和clazz1相同。

在系统类加载器中

用loadclass()方法加载，会先检查是否已经被加载过了，系统类加载器共用了clazz1的，已经加载过直接返回实例，所以clazz4和clazz1相同。

new的对象的加载器

由于new的时classpath下的类，所以默认用系统类加载器，系统类加载器共用了clazz1的，已经加载过直接返回实例，所以clazz5和clazz1相同。

注意：不同的类加载器实例的缓存（是否已经加载过）是不共通的，所以clazz4并不会等于clazz2，而系统类加载器和扩展类加载器会公用一个，加载过就不会再次加载，直接返回（所以说类很难卸载，系统类加载器会有很多引用）。