阅读量:0
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，而系统类加载器和扩展类加载器会公用一个，加载过就不会再次加载，直接返回（所以说类很难卸载，系统类加载器会有很多引用）。
