概述
所谓机制就是某种流程规范或运作模式。简单来说，将类文件加载到JVM中的过程，需要对这个过程进行限定和约束，这就是Java类加载的机制。
具体说来，对Java类加载机制的描述可以从三个方面：
- 按需加载 需要某一个类时才会加载
- 加载时，加载器的选择由双亲委派机制决定
- 加载的具体流程
类加载器
按照java虚拟机规范中的定义,类加载器分为2大类:
- 引导类加载器(bootstrap classLoader)
- 自定义加载器(派生自抽象类classLoader的所有类: 拓展类加载器，应用类加载器，自定义加载器)
每一种类加载器都有其特定的职能，比如引导类加载器主要负责加载核心类库，如rt.jar，扩展类加载器负责lib/ext，应用类加载器负责类路径classpath下的类。这样设计的好处是实现了模块化管理和加载类的隔离
加载机制
双亲委派
其实就是类加载时的加载策略,因为jvm中类加载器不止一个,且分工不同，多个类加载器如何协同工作呢?所以jvm中定义了一个策略:
优先以上级加载为准,只加载一次,这种策略保证了java核心类库的安全,也保证了基础类型的一致性,外部同名的类不会污染核心类库。
java中类加载器的顶级类ClassLoader,所有自定义类加载器都继承自它，所以它的类加载流程就是java类加载的默认流程，即双亲委派。看源码：
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException{synchronized (getClassLoadingLock(name)) {// 检查类是否已加载Class<?> c = findLoadedClass(name);if (c == null) {long t0 = System.nanoTime();// 优先使用父类try {// 向上找父类加载器，直到 bootstraploaderif (parent != null) { // parent也是一个ClassLoader，所以会继续循环向上委派c = parent.loadClass(name, false);} else {c = findBootstrapClassOrNull(name);}} catch (ClassNotFoundException e) {// ClassNotFoundException thrown if class not found// from the non-null parent class loader}//然后才是自己if (c == null) {// If still not found, then invoke findClass in order// to find the class.long t1 = System.nanoTime();c = findClass(name);// this is the defining class loader; record the statssun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);sun.misc.PerfCounter.getFindClasses().increment();}}if (resolve) {resolveClass(c);}return c;}
}所以，想要打破这种加载机制，核心是调整loadClass()逻辑
loadClass(){//不去调用super.loadClass，否则还是先向上委派加载// 优先自己加载try{findClass();}finally{// 自己加载不了，决定是否向上委派（自定义来源的加载器，通常向上委派也没用）super.loadClass();}
}
Class<?> findClass(){// 从网络、文件系统等
}自定义类加载器
从网络中加载类，需要自定义类加载器。
自定义类加载器通常需要重写classLoader中的loadClass()和findClass()方法。
// 自定义加载逻辑：何时使用自定义类加载器
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {Class<?> c = findLoadedClass(name);if (c == null && useMyClassLoaderLoad.contains(name)){//特殊的类让我自己加载c = findClass(name);if (c != null){return c;}}return super.loadClass(name);
}
// 自定义Class的寻找过程
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {//return super.findClass(name);//根据文件系统路径加载class文件，并返回byte数组byte[] classBytes = getClassByte(name);//调用ClassLoader提供的方法，将二进制数组转换成Class类的实例return defineClass(name, classBytes, 0, classBytes.length);
}网络类加载器子类必须定义方法findClass和loadClassData来从网络加载类。一旦它下载了组成类的字节，它应该使用方法defineClass来创建一个类实例
ClassLoader loader = new NetworkClassLoader(host, port);
Object main = loader.loadClass("Main", true).newInstance();// 自定义加载器
class NetworkClassLoader extends ClassLoader {String host;int port;public Class findClass(String name) {byte[] b = loadClassData(name);// 使用defineClass创建一个Class实例return defineClass(name, b, 0, b.length);}// 从网络获取类文件的二进制数据private byte[] loadClassData(String name) {// load the class data from the connection. . .}
}实现热部署
public class MyClassLoader extends ClassLoader {//用于读取.Class文件的路径private String swapPath;//用于标记这些name的类是先由自身加载的private Set<String> useMyClassLoaderLoad;public MyClassLoader(String swapPath, Set<String> useMyClassLoaderLoad) {this.swapPath = swapPath;this.useMyClassLoaderLoad = useMyClassLoaderLoad;}@Overridepublic Class<?> loadClass(String name) throws ClassNotFoundException {Class<?> c = findLoadedClass(name);if (c == null && useMyClassLoaderLoad.contains(name)){//特殊的类让我自己加载c = findClass(name);if (c != null){return c;}}return super.loadClass(name);}@Overrideprotected Class<?> findClass(String name) {//根据文件系统路径加载class文件，并返回byte数组byte[] classBytes = getClassByte(name);//调用ClassLoader提供的方法，将二进制数组转换成Class类的实例return defineClass(name, classBytes, 0, classBytes.length);}private byte[] getClassByte(String name) {String className = name.substring(name.lastIndexOf('.') + 1, name.length()) + ".class";try {FileInputStream fileInputStream = new FileInputStream(swapPath + className);byte[] buffer = new byte[1024];int length = 0;ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();while ((length = fileInputStream.read(buffer)) > 0){byteArrayOutputStream.write(buffer, 0, length);}return byteArrayOutputStream.toByteArray();} catch (IOException e) {e.printStackTrace();}return new byte[]{};}
}// 热部署的类
public class Test {public void printVersion(){System.out.println("当前版本是1哦");}
}// 定时任务持续扫描public static void main(String[] args) {//创建一个2s执行一次的定时任务new Timer().schedule(new TimerTask() {@Overridepublic void run() {String swapPath = MyClassLoader.class.getResource("").getPath() + "swap/";String className = "com.example.Test";//每次都实例化一个ClassLoader，这里传入swap路径，和需要特殊加载的类名MyClassLoader myClassLoader = new MyClassLoader(swapPath, Sets.newHashSet(className));try {//使用自定义的ClassLoader加载类，并调用printVersion方法。Object o = myClassLoader.loadClass(className).newInstance();o.getClass().getMethod("printVersion").invoke(o);} catch (InstantiationException |IllegalAccessException |ClassNotFoundException |NoSuchMethodException |InvocationTargetException ignored) {}}}, 0,2000);}加载与卸载
从外部加载包括：文件系统，网络
public class Plugin01 {public void print(){System.out.println("Plugin01执行");}
}//maven打包
<build><finalName>plugin01</finalName>
</build>/*** 类加载器-模块插拔* 1.自定义几个类,模拟不同插件* 2.通过自定义类加载器加载* 3.卸载则是通过GC来完成* 4.通过VisualVM查看是否卸载成功** @author wangyuanye* @date 2024/8/3**/
public class LoadUnloadDemo {// 外部jar路径static String path1 = "/Users/mars/code/java/demo-classloader/demo-plugin01/target/plugin01.jar";static String path2 = "/Users/mars/code/java/demo-classloader/demo-plugin02/target/plugin02.jar";public static void main(String[] args) throws Exception{File plugin01 = new File(path1);File plugin02 = new File(path2);URL plugin01Url = plugin01.toURI().toURL();URL plugin02Url = plugin02.toURI().toURL();// 加载plugin1MyPluginClassloader classloader1 = new MyPluginClassloader(new URL[]{plugin01Url});Class<?> plugin01Class = classloader1.loadClass("org.wyy.Plugin01");Object o1 = plugin01Class.newInstance();plugin01Class.getMethod("print").invoke(o1);// 加载plugin2MyPluginClassloader classloader2 = new MyPluginClassloader(new URL[]{plugin02Url});Class<?> plugin02Class = classloader2.loadClass("org.wyy.Plugin02");Object o2 = plugin02Class.newInstance();plugin02Class.getMethod("print").invoke(o2);// 卸载o1 = null;o2 = null;// 1.使用软引用包装，观察回收情况,需要代码中调用GCSystem.gc();WeakReference<Object> p1 = new WeakReference<>(o1);WeakReference<Object> p2 = new WeakReference<>(o2);if (p1.get() == null) {System.out.println("plugin1 has been unloaded.");} else {System.out.println("plugin1 is still loaded.");}if (p2.get() == null) {System.out.println("plugin2 has been unloaded.");} else {System.out.println("plugin2 is still loaded.");}// 2.或使用visualVM观察,可在visualVM中手动GCThread.sleep(500000);}
}GC前：
GC后：
plugin被卸载
堆Dump：
Tomcat中的类加载
官网：类加载器工作原理
Tomcat 在初始化时创建以下类加载器：
Bootstrap
此类加载器包含 Java 虚拟机提供的基本运行时类，以及系统扩展目录 ( $JAVA_HOME/jre/lib/ext) 中 JAR 文件中的任何类。
System
此类加载器通常根据CLASSPATH环境变量的内容进行初始化。所有此类类对于 Tomcat 内部类和 Web 应用程序均可见。
Common
此类加载器包含对 Tomcat 内部类和所有 Web 应用程序均可见的附加类。
WebappX
为部署在单个 Tomcat 实例中的每个 Web 应用程序创建一个类加载器。Web/WEB-INF/classes应用程序目录中所有未打包的类和资源以及 Web 应用程序目录下 JAR 文件中的类和资源都只/WEB-INF/lib对该 Web 应用程序可见，而对其他 Web 应用程序不可见。
Webapp ClassLoader的加载机制
WebappClassLoaderBaseloadClass() 流程如下：
// 1.尝试从已加载的类缓存中获取
// 2.首先使用引导类加载(防止覆盖java se中的类)
ClassLoader javaseLoader = getJavaseClassLoader();
// 3.加载失败，继续判断是否开启了 委派
if (delegateLoad) {clazz = Class.forName(name, false, parent);
}
// 4.webappClassLoader自己从/WEB-INF/下尝试获取
clazz = findClass(name);
// 5.委派给父类
if (!delegateLoad) {clazz = Class.forName(name, false, parent);
}从 Web 应用程序的角度来看，类或资源加载按以下顺序查找以下存储库：JVM 的引导类
你的 Web 应用程序的/WEB-INF/classes
您的 Web 应用程序的/WEB-INF/lib/*.jar
系统类加载器类（如上所述）
常见的类加载器类（如上所述）
如果 Web 应用程序类加载器 配置了 <Loader delegate="true"/> 以下顺序：JVM 的引导类
系统类加载器类（如上所述）
常见的类加载器类（如上所述）
你的 Web 应用程序的/WEB-INF/classes
您的 Web 应用程序的/WEB-INF/lib/*.jar总结：
- 始终是JVM的引导类加载器优先加载，防止污染java 核心类
- 开启委派则由父类尝试加载，然后是自己
- 未开启则先自己，再父类。
同名类在JVM是否冲突
在JVM中，类是通过类加载器实例和类的全限定名（包括包名和类名）的组合来唯一标识的。因此，即使两个类具有相同的全限定名，如果它们由不同的类加载器实例加载，它们在JVM中也会被视为不同的类。
如果试图使用同一个类加载器实例加载两个具有相同全限定名的类，那么JVM会抛出ClassNotFoundException或LinkageError，因为在同一个类加载器的命名空间内，一个类的全限定名必须是唯一的。
代码演示加载同名类到JVM中
// 自定义类加载器
public class CustomClassLoader extends ClassLoader{private String classPath;public CustomClassLoader(String classPath) {this.classPath = classPath;}@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {try {byte[] data = transFile2Byte(name);return defineClass(name, data, 0, data.length);} catch (Exception e) {e.printStackTrace();}return null;}// 处理文件流private byte[] transFile2Byte(String name) throws Exception {String path = name.replace('.', '/').concat(".class");FileInputStream fileInputStream = new FileInputStream(classPath + "/" + path);int len = fileInputStream.available();byte[] data = new byte[len];fileInputStream.read(data);fileInputStream.close();return data;}@Overrideprotected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {synchronized (getClassLoadingLock(name)) {// First, check if the class has already been loadedClass<?> c = findLoadedClass(name);if (c == null) {if (!name.startsWith("org.mars.frame")) {c = this.getParent().loadClass(name);} else {c = findClass(name);}}if (resolve) {resolveClass(c);}return c;}}
}// 测试加载同名类
public static void main(String[] args) throws Exception {String path = "/Users/mars/codeSpace/0bat/3source_code/7tomcat-demo/frame1/target/classes/";String path2 = "/Users/mars/codeSpace/0bat/3source_code/7tomcat-demo/frame2/target/classes/";CustomClassLoader classLoader = new CustomClassLoader(path);Class<?> clazz = classLoader.loadClass("org.mars.frame.Utils");Object obj = clazz.newInstance();Method method = clazz.getDeclaredMethod("info", null);method.invoke(obj, null);System.out.println(obj.getClass().getName());System.out.println(clazz.getClassLoader().getClass().getName());System.out.println("==================");CustomClassLoader classLoader2 = new CustomClassLoader(path2);Class<?> clazz2 = classLoader2.loadClass("org.mars.frame.Utils");Object obj2 = clazz2.newInstance();Method method2 = clazz2.getDeclaredMethod("info", null);method2.invoke(obj2, null);System.out.println(obj.getClass().getName());System.out.println(clazz2.getClassLoader().getClass().getName());
}// 执行结果
FamousFrame v1.0
org.mars.frame.Utils
load_policy.CustomClassLoader
==================
FamousFrame v2.0
org.mars.frame.Utils
load_policy.CustomClassLoader欢迎评论、收藏，请勿转载！！！
![[Spring] SpringBoot统一功能处理与图书管理系统](https://i-blog.csdnimg.cn/direct/3e5d61d075e145db9ec359b0284a9406.png)
