在测试环境下，由于需要经常修改代码，反复重启，非常浪费时间，所以我们可以借助 Spring Boot 提供的热加载插件完成热部署

流程图

Spring Boot 热部署原理与模拟 - 图1

Spring Boot 热部署

  1. <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-devtools -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-devtools</artifactId>
  5.     <version>2.3.1.RELEASE</version>
  6. </dependency>

加上这个依赖以后，当我们完成代码的修改以后，可以点击重新编译，完成代码的更新
image.png
那么热部署的原理是什么呢？

其实热部署：就是修改后的 java 文件，从新编译成 class 文件，然后再通过 ClassLoader 加载到 JVM 虚拟机中去，替换 JVM 虚拟中原来的 class 对象

类加载器

JVM 默认提供了三种类加载器

  • BootstrapClassLoad：启动类加载器，存在 JVM 中，加载核心 class 文件
  • ExtensionClassLoad：扩展类加载器，主要加载 lib\ext 包下面的 class 文件
  • ApplicationClassLoad：应用程序类加载器，加载应用程序上下文中的 class 文件

双亲委派（父类委托）机制

双亲委派的英文是：Java parent delegation，其实是早期翻译错误，正确的理解是父类委托机制，当一个类加载器去加载某一个类的时候，默认情况下不会由自己去加载，而是由其父类去加载

Spring Boot 热部署原理与模拟 - 图3

某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载**器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载**。

使用双亲委派模型的好处在于Java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类java.lang.String，它存在在 rt.jar 中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的Bootstrap ClassLoader 进行加载，因此 String 类在程序的各种类加载器环境中都是同一个类。

相反，如果没有双亲委派模型而是由各个类加载器自行加载的话，如果用户编写了一个 java.lang.String 的同名类并放在 ClassPath 中，那系统中将会出现多个不同的 String 类，程序将混乱。因此，如果开发者尝试编写一个与rt.jar 类库中重名的 Java 类，可以正常编译，但是永远无法被加载运行（因为都会向上委派，最终到 BootStrap ClassLoad，它可以加载到了 rt.jar 下的 String，所以你写的 String.class 并没有作用）

这里的 String.class 是指和 原 String.class 具有相同的包名和类名； 同一个 class 如果被不同的 ClassLoad 加载，那么类型也不相同；

ClassLoader 核心代码

先从缓存中读取 Class<?> c = findLoadedClass(name) 这个 class 文件，如果读取到，则直接返回这个 class 对象，如果没有，则调用父类的 ClassLoader 进行递归调用，最终到 Bootstrap ClassLoader 进行加载，如果 BootStrap ClassLoader 没有加载到

在这个过程中，每个类加载器都会尝试先从缓存中加载，加载到了就会直接返回，如果一直到 BootStrap ClassLoader 都没有加载到，则会抛出 ClassNotFoundException 异常信息

  1. protected Class<?> loadClass(String name, boolean resolve)  throws ClassNotFoundException {
  2.     synchronized (getClassLoadingLock(name)) {
  3.         // First, check if the class has already been loaded
  4.         Class<?> c = findLoadedClass(name);
  5.         if (c == null) {
  6.             long t0 = System.nanoTime();
  7.             try {
  8.                 if (parent != null) {
  9.                     c = parent.loadClass(name, false);
  10.                 } else {
  11.                     c = findBootstrapClassOrNull(name);
  12.                 }
  13.             } catch (ClassNotFoundException e) {
  14.             }
  16.             if (c == null) {
  17.                 long t1 = System.nanoTime();
  18.                 c = findClass(name);
  19.                 sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
  20.                 sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
  21.                 sun.misc.PerfCounter.getFindClasses().increment();
  22.             }
  23.         }
  24.         if (resolve) {
  25.             resolveClass(c);
  26.         }
  27.         return c;
  28.     }
  29. }

看了上面所说的类加载机制，就会产生一个问题

既然是 ClassLoader 是父类委托机制，那么如果我们更改了一个 java 文件，编译成 class 文件之后，通过类加载机制，依然会从缓存中读取，我们的修改后的 class 文件也是无效啊，那么应该如何做呢？

所以，我们需要打破父类委托机制，我们可以通过重写从缓存中寻找 class 对象的方法，让我们自定义的 ClassLoader，从缓存中可以获取到 class 对象，这样就可以不走父类委托机制了
**

自定义类加载器

  1. public class MyClassLoader extends ClassLoader {
  3.     // 项目根路径
  4.     private String rootPath;
  6.     // 存储所有需要由这个类加载器加载的类
  7.     private List<String> classes;
  9.     // classPaths 需要被热部署的类路径
  10.     public MyClassLoader(String rootPath, String... hotClassPaths) throws Exception {
  11.         this.rootPath = rootPath;
  12.         this.classes = new ArrayList<>();
  14.         for (String hotClassPath : hotClassPaths) {
  15.             scanClassPath(new File(hotClassPath));
  16.         }
  17.     }
  19.     /**
  20.      * 扫描目录下的 class
  21.      *
  22.      * @param file 类文件
  23.      */
  24.     public void scanClassPath(File file) throws Exception {
  25.         if (file.isDirectory()) {
  26.             File[] files = file.listFiles();
  27.             if (files != null) {
  28.                 for (File subFile : files) {
  29.                     scanClassPath(subFile);
  30.                 }
  31.             }
  32.         } else {
  33.             String fileName = file.getName();
  34.             String filePath = file.getPath();
  35.             String suffix = fileName.substring(fileName.lastIndexOf("."));
  36.             if (".class".equals(suffix)) {
  37.                 InputStream in = new FileInputStream(file);
  38.                 byte[] bytes = new byte[(int) file.length()];
  39.                 in.read(bytes);
  40.                 String className = fileNameToClassName(filePath);
  41.                 // 加载 class 文件，并生成 class 对象，加入到 JVM 虚拟机中去
  42.                 defineClass(className, bytes, 0, bytes.length);
  43.                 classes.add(className);
  44.             }
  45.         }
  46.     }
  48.     /**
  49.      * 文件名转类名
  50.      *
  51.      * @param filePath 文件路径
  52.      */
  53.     private String fileNameToClassName(String filePath) {
  54.         if (rootPath.startsWith("/")) {
  55.             rootPath = rootPath.substring(1);
  56.         }
  57.         String classPath = filePath.replace(rootPath, "").replaceAll("\\\\", ".");
  58.         return classPath.substring(1, classPath.lastIndexOf("."));
  59.     }
  61.     @Override
  62.     public Class<?> loadClass(String name) throws ClassNotFoundException {
  63.         // 因为将该类已经加载到 JVM 中了，所以这里可以查询到
  64.         Class<?> loadedClass = findLoadedClass(name);
  65.         if (loadedClass == null) {
  66.             if (!classes.contains(name)) {
  67.                 return getSystemClassLoader().loadClass(name);
  68.             }
  69.             throw new ClassNotFoundException("没有加载到类文件");
  70.         }
  71.         return loadedClass;
  72.     }
  74.     public static void main(String[] args) throws Exception {
  75.         String rootPath = MyClassLoader.class.getResource("/").getPath();
  76.         rootPath = new File(rootPath).getPath();
  77.         while (true) {
  78.             MyClassLoader myClassLoader = new MyClassLoader(rootPath, rootPath + "/com");
  79.             Class<?> aClass = myClassLoader.loadClass("com.example.spring.boot.classloader.TestClass");
  80.             aClass.getMethod("test").invoke(aClass.newInstance());
  81.             TimeUnit.SECONDS.sleep(2);
  82.         }
  84.     }
  85. }
  87. public class TestClass {
  88.     public void test() {
  89.         ClassLoader classLoader = this.getClass().getClassLoader();
  90.         System.out.println(classLoader + " => TestClass Version-1");
  91.     }
  92. }

这里我们可以看到，当我们修改 Test 类中的方法后，点击编译 Class，此时，就会打印出修改后的内容

image.png

new 对象带来的问题

那么我们如果 new TestClass().test() 也会进行相应的改变么？

  1. public static void main(String[] args) throws Exception {
  2.     String rootPath = MyClassLoader.class.getResource("/").getPath();
  3.     rootPath = new File(rootPath).getPath();
  4.     while (true) {
  5.         MyClassLoader myClassLoader = new MyClassLoader(rootPath, rootPath + "/com");
  6.         Class<?> aClass = myClassLoader.loadClass("com.example.spring.boot.classloader.TestClass");
  7.         aClass.getMethod("test").invoke(aClass.newInstance());
  8.         new TestClass().test();
  9.         TimeUnit.SECONDS.sleep(2);
  10.     }
  12. }

image.png
我们可以看出来，我们 new Test() 出来的 classLoader 是 AppClassLoader，内容依然是 Version-1，并没有随着改变，这也证明了，不同的类加载器加载的对象，是不同的

那么，如何才能做到输入的效果统一呢？

全盘委托机制

即是当一个 classloader 加载一个 Class 的时候，这个 Class 所依赖的和引用的其它 Class 通常也由这个classloader 负责载入

当有 new 关键字需要类加载器加载的时候，JVM 会判断当前调用 new 关键字的类加载器是什么？然后用调用 new 关键字的类加载器来加载

所以我们可以通过全盘委托机制，来修改上面的代码

待解决的几个问题

  • 解决：new 对象的时候，也默认使用我们的类加载器来加载，而不是使用 AppClassLoader，这里可以使用上述的全盘委托机制来解决
  • 能做到监听文件改动的目的，而不是使用死循环来实现

代码实现

Application

我们自己写一个 Application 类，然后让在 Application 中的 run 方法，创建我们的 MyClassLoader，来加载我们需要的目录下的 class 文件

  1. public class Application {
  4.     public static void run(Class<?> clazz, String... packageName) throws Exception {
  5.         String rootPath = MyClassLoader.class.getResource("/").getPath();
  6.         rootPath = new File(rootPath).getPath();
  7.         MyClassLoader myClassLoader = new MyClassLoader(rootPath, packageName);
  8.         startFileChangeListener(rootPath, packageName);
  9.         // 用我们自己类加载器加载程序入口
  10.         start0(myClassLoader);
  11.     }
  13.     public static void start() {
  14.         System.out.println("启动应用程序");
  15.         new TestClass().test();
  16.     }
  18.     public static void stop() {
  19.         System.gc();
  20.         System.runFinalization();
  21.         System.out.println("启动应用退出");
  22.     }
  24.     public static void start0(MyClassLoader myClassLoader) throws Exception {
  25.         Class<?> aClass = myClassLoader.loadClass("com.example.spring.boot.classloader.Application");
  26.         aClass.getMethod("start").invoke(aClass.newInstance());
  27.     }
  29.     public static void startFileChangeListener(String rootPath, String... packageName) throws Exception {
  30.         // 创建监听对象
  31.         FileAlterationObserver observer = new FileAlterationObserver(rootPath);
  32.         observer.addListener(new FileListener(rootPath, packageName));
  33.         // 每 500 毫秒监听一次
  34.         FileAlterationMonitor monitor = new FileAlterationMonitor(500);
  35.         monitor.addObserver(observer);
  36.         monitor.start();
  37.     }
  39. }

文件变动监听

这里使用的是 Apache 的 commons-io 包，来监听文件变动，当文件发送变动的时候，我们会重新调用 Application 类的 start0 方法，进行重新加载类文件到 JVM 中去

  1. package com.example.spring.boot.classloader;
  3. import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
  5. import java.io.File;
  7. public class FileListener extends FileAlterationListenerAdaptor {
  9.     private String rootPath;
  11.     private String[] hotClassPaths;
  13.     public FileListener(String rootPath, String[] hotClassPaths) {
  14.         this.rootPath = rootPath;
  15.         this.hotClassPaths = hotClassPaths;
  16.     }
  18.     @Override
  19.     public void onFileChange(File file) {
  20.         if (file.getName().contains(".class")) {
  21.             try {
  22.                 Application.stop();
  23.                 MyClassLoader myClassLoader = new MyClassLoader(rootPath, hotClassPaths);
  24.                 Application.start0(myClassLoader);
  25.             } catch (Exception e) {
  26.                 e.printStackTrace();
  27.             }
  28.         }
  29.     }
  30. }