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