日志追踪-类加载器扩展-实战手写热部署

╰半橙微兮° 2023-01-15 02:15 43阅读 0赞

### 文章目录 ###

*   *  目标
     *  热部署
     *   *  Spring dev-tools 与 JReble
         *   *  实现方式
         *  Spring dev-tools源码分析
         *  两个机制
         *   *  全盘委托机制
             *  双亲委派机制
         *  一些问题
         *  实战-热部署
         *   *  代码实战
             *   *  自定义类加载器
                 *  Class文件监听
                 *  重新加载类方法
                 *  入口程序和测试代码
             *  测试
         *  扩展

## 目标 ##

*  使用自定义ClassLoader 实现热部署
    
    参考：[Spring-Boot-Devtools 热部署源码详解 与 双亲委派机制（单步源码级分析）][Spring-Boot-Devtools _ _]
    
    [class卸载、热替换和Tomcat的热部署的分析][class_Tomcat] 建议阅读
    
    [HotSwap和JRebel原理][HotSwap_JRebel]
    
    [深入探索 Java 热部署][Java]
    
    [class卸载、热替换和Tomcat的热部署的分析][class_Tomcat 1]

## 热部署 ##

代码更改后无需等待构建就会重新部署，对于java语言，在不手动重启JVM情况下，自动加载变化的java文件，并将其重新加载到JVM中。在日常开发中，针对SpringBoot工程最常用到的热部署插件就是Spring-devtools或者JReble，检测到class文件有所变化，就会重启服务。

优点：

*  无需手动重启，跳过重建服务的步骤，重启服务时间更短。
 *  几乎实时的更改可见性，代码更改时就会立即反应出来。

缺点：

*  重建服务有局限性，有些代码的更改，可能并不一定生效。

其实最大的好处在于节省时间，对于大型工程，开发阶段启动一次服务实例，可能长达几分钟，如果修改一块代码，就重启调试，将会非常浪费时间。使用热部署技术，会缩短重启服务时间，让程序员更关注开发本身，更加节省时间。

[为何java一般情况不易热部署？][java]

[**spring-boot-devtools**][spring-boot-devtools]

### Spring dev-tools 与 JReble ###

这两种热部署插件简单使用可以参考：[SpringBoot热部署][SpringBoot]

Spring dev-tools与 JReble 都是热部署插件，但是方式并不一样。并且JReble 的功能会更强大。

#### 实现方式 ####

Spring dev-tools 实现热部署原理：

使用两个类加载器来实现，不变的类（例如：第三方的jar的类）被基类加载器所加载，正在开发的类将被Restart类加载器所加载。dev-tools在程序启动后，会启动一个文件监听器（FileSystemWatcher），监听编译目录（/target）中Class文件的变化,当检测到某些Class文件发生变化，就会触发重新加载的动作。将修改的Class文件记录下来，重新创建Restart类加载器实例，加载变化的class文件。而基类加载器加载的不变的类，则不用再重新加载。这样就比“冷启动”重启快的多。

缺点：

*  每次都新建类加载器加载类，原来加载的类会被遗留在内存中，直到被垃圾回收才会释放内存。
 *  某些类的修改，不一定能重启成功

JRable 实现热部署原理：

看下这篇文章吧，我还没有领略到含义。。 [HotSwap和JRebel原理][HotSwap_JRebel]

还有一种热部署实现方式，基于字节码增强技术与自定类加载器结合：

简单策略：使用自定义类加载器加载正在开发的类，当类发生变化，使用字节码增强技术，修改原有class的内容，也就是及时定义java类的有限功能。但是这个仅仅只能修改方法主体，在实际环境下，并不实用。

[JRebel如何工作？][JRebel]

### Spring dev-tools源码分析 ###

从dev-tools的源码分析，看下大神的思路：

[Spring-Boot-Devtools 热部署源码详解 与 双亲委派机制（单步源码级分析）][Spring-Boot-Devtools _ _] 可以参考

具体源码，请参考上述文章，很清晰。简单说下，后续流程dev-tools 的做法。

// 文件监听器监听到class文件发生变化，就会发布Spring的文件修改事件，当监听到事件发布，就会执行如下代码
    @Bean
    ApplicationListener<ClassPathChangedEvent> restartingClassPathChangedEventListener(
        FileSystemWatcherFactory fileSystemWatcherFactory) { 
        return (event) -> { 
            // 判断重启标识
            if (event.isRestartRequired()) { 
                // 获取Restarter实例，执行restart 方法
                Restarter.getInstance().restart(new FileWatchingFailureHandler(fileSystemWatcherFactory));
            }
        };
    }
     
    // ====================================================================================
        /** * Restart the running application. * @param failureHandler a failure handler to deal with application that doesn't start */
        public void restart(FailureHandler failureHandler) { 
            if (!this.enabled) { 
                this.logger.debug("Application restart is disabled");
                return;
            }
            this.logger.debug("Restarting application");
            // 获取一个线程，执行写好的call 方法
            // call 实质上执行了当前线程的 start() 方法， 那么也就是会执行 run 方法
             // run 方法实质上执行了就是如下的代码
            getLeakSafeThread().call(() -> { 
                Restarter.this.stop();
                Restarter.this.start(failureHandler);
                return null;
            });
        }

*  Restarter.this.stop() 销毁流程
    
        /** * Stop the application. * @throws Exception in case of errors */
            protected void stop() throws Exception { 
                this.logger.debug("Stopping application");
                // 获取一个锁
                this.stopLock.lock();
                try { 
                    for (ConfigurableApplicationContext context : this.rootContexts) { 
                        // 调用close
                        context.close();
                        this.rootContexts.remove(context);
                    }
                    // 清除缓存
                    cleanupCaches();
                    if (this.forceReferenceCleanup) { 
                         // 通过强制执行OutOfMemoryError错误来清除所有软/弱引用。
                        forceReferenceCleanup();
                    }
                }
                finally { 
                    // 释放锁
                    this.stopLock.unlock();
                }
                // 调用 gc() 告知虚拟机进行垃圾回收（只是告知，并不一定执行）
                System.gc();
                // 强制调用已经失去引用的对象的finalize方法,用来，确保释放实例占用的全部资源
                System.runFinalization();
            }
    
    一个有意思的操作：
    
    创建一个list ，死循环追加一个long数组，直到发生OutOfMemoryError 错误，来清除所有的软引用和弱引用
    
        /** * Cleanup any soft/weak references by forcing an {@link OutOfMemoryError} error. * 通过强制执行OutOfMemoryError错误来清除所有软/弱引用。 */
            private void forceReferenceCleanup() { 
                try { 
                    final List<long[]> memory = new LinkedList<>();
                    while (true) { 
                        memory.add(new long[102400]);
                    }
                }
                catch (OutOfMemoryError ex) { 
                    // Expected
                }
            }
 *  重启服务
    
        // 启动
        protected void start(FailureHandler failureHandler) throws Exception { 
            do { 
                Throwable error = doStart();
                if (error == null) { 
                    return;
                }
                if (failureHandler.handle(error) == Outcome.ABORT) { 
                    return;
                }
            }
            while (true);
        }
         
        private Throwable doStart() throws Exception { 
                Assert.notNull(this.mainClassName, "Unable to find the main class to restart");
                URL[] urls = this.urls.toArray(new URL[0]);
                ClassLoaderFiles updatedFiles = new ClassLoaderFiles(this.classLoaderFiles);
                // 重新创建RestartClassLoader
                ClassLoader classLoader = new RestartClassLoader(this.applicationClassLoader, urls, updatedFiles, this.logger);
                if (this.logger.isDebugEnabled()) { 
                    this.logger.debug("Starting application " + this.mainClassName + " with URLs " + Arrays.asList(urls));
                }
                // 执行重启操作
                return relaunch(classLoader);
            }
        
        
        
        protected Throwable relaunch(ClassLoader classLoader) throws Exception { 
            RestartLauncher launcher = new RestartLauncher(classLoader, this.mainClassName, this.args,
                                                           this.exceptionHandler);
            launcher.start();
            launcher.join();
            return launcher.getError();
        }
        
        // --- 关注下这个
        @Override
            public void run() { 
                try { 
                    // 使用RestartClassLoader 调用loadClass 方法，实质上加载的是 Springboot 我们定义的入口 main 的类
                    Class<?> mainClass = getContextClassLoader().loadClass(this.mainClassName);
                    // 获取到这个class 后，使用反射再次执行 main方法，也就代表着Spring boot 工程的重启
                    Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
                    mainMethod.invoke(null, new Object[] {  this.args });
                }
                catch (Throwable ex) { 
                    this.error = ex;
                    getUncaughtExceptionHandler().uncaughtException(this, ex);
                }
            }

[Spring事件监听机制][Spring]

### 两个机制 ###

#### 全盘委托机制 ####

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

比如Test类中，创建了一个User对象（new User()）,如果Test类是被 MyClassLoader 加载的，那么User对象也会被 MyClassLoader所加载。

#### 双亲委派机制 ####

不过多介绍，可以参考之前的文章。但是实现热部署，**需要破坏双亲委派模型，实现正在开发的类被我们自定义类加载器所加载**

### 一些问题 ###

1.  类修改后为什么要重新创建类加载器加载类？
    
    因为类加载器每一个类只能加载一次，如果加载多次，会报异常

Exception in thread "main" java.lang.LinkageError: loader (instance of  fun/gengzi/codecopy/business/classloader/hotdeployment/HotDeploymentClassLoader): attempted  duplicate class definition for name: "fun/gengzi/codecopy/business/classloader/hotdeployment/TestCode"

1.  经常看到一些文章，经常提到使用创建新的自定义类加载器加载类，之前的这些类占用的资源需要释放，那么原有的类和类加载器的销毁怎么实现？
    
    从上述源码分析，确实有对一些对象和缓存的清除，并且显示的调用了gc方法，来告知JVM回收资源。但是不能确定这些类和类加载器被垃圾回收，垃圾回收是不受控制的，所以无法真正实现销毁。但是能清除一部分算一部分，如果热部署的次数过多，可能也会发生OutOfMemoryError 错误.
    
    引用一部分内容:
    
        1、有启动类加载器加载的类型在整个运行期间是不可能被卸载的(jvm和jls规范).
        
        2、被系统类加载器和标准扩展类加载器加载的类型在运行期间不太可能被卸载，因为系统类加载器实例或者标准扩展类的实例基本上在整个运行期间总能直接或者间接的访问的到，其达到unreachable的可能性极小.(当然，在虚拟机快退出的时候可以，因为不管ClassLoader实例或者Class(java.lang.Class)实例也都是在堆中存在，同样遵循垃圾收集的规则).
        
        3、被开发者自定义的类加载器实例加载的类型只有在很简单的上下文环境中才能被卸载，而且一般还要借助于强制调用虚拟机的垃圾收集功能才可以做到.可以预想，稍微复杂点的应用场景中(尤其很多时候，用户在开发自定义类加载器实例的时候采用缓存的策略以提高系统性能)，被加载的类型在运行期间也是几乎不太可能被卸载的(至少卸载的时间是不确定的).
        
        综合以上三点， 一个已经加载的类型被卸载的几率很小至少被卸载的时间是不确定的.同时，我们可以看的出来，开发者在开发代码时候，不应该对虚拟机的类型卸载做任何假设的前提下来实现系统中的特定功能.
2.  使用自定义类加载器,执行loadClass方法,也只是返回一个Class对象,可以通过newInstance()方法实例化,但是上述热部署流程,也仅仅只加载了入口main类,但是在真实业务代码中，都是通过new 的形式.那么对于new 对象这种实例化的方式,怎么保证他们也被自定义类加载器加载?
    
    也就是上面介绍的全盘委托机制.

### 实战-热部署 ###

需求：实现热部署基本功能，支持修改类，无需手动重启，即可生效。

思路：仿照dev-tools的思路，大致分为：自定义类加载，Class文件监听，重新加载类，入口程序几个模块

工具类：这里引入了 hutool工具包，提供一些便捷操作

#### 代码实战 ####

环境：JDK1.8

源码参考：[codecopy][]

##### 自定义类加载器 #####

java文档指出自定义类加载器，最好重写findClass方法来实现。原因就是重写loadClass，可能会破坏双亲委派，导致类加载失败。但是为了打破双亲委派模型，还是需要重写一下loadClass，但是对于不是我们正在开发的类，都还交给父类的类加载loadClass实现

import cn.hutool.core.io.FileUtil;
    import cn.hutool.core.io.file.FileReader;
     
    import java.io.File;
    import java.net.URL;
     
    /** * <h1>热部署classloader</h1> * * @author gengzi * @date 2021年3月31日22:25:52 */
    public class HotDeploymentClassLoaderV3 extends ClassLoader { 
        public static String dir;
     
        static { 
            // 获取target 加载的路径
            URL resource = Thread.currentThread().getContextClassLoader().getResource("");
            dir = resource.getPath();
        }
     
        @Override
        public Class<?> loadClass(String name) throws ClassNotFoundException { 
            // 加锁
            synchronized (getClassLoadingLock(name)){ 
                // 判断当前包名类，是否在当前用户classpath 下，如果存在，就执行自定义的findclass
                // 不是，就走父类的类加载器
                String file = dir + File.separator + (name.replace(".", "/")) + ".class";
                if(FileUtil.exist(file)){ 
                    // 执行findclass
                    Class<?> aClass = findClass(name);
                    if(aClass == null){ 
                        throw new ClassNotFoundException("未找到该类");
                    }
                    return aClass;
                }
                return super.loadClass(name);
            }
        }
     
     
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException { 
            String file = dir + File.separator + (name.replace(".", "/")) + ".class";
            FileReader fileReader = new FileReader(file);
            byte[] bytes = fileReader.readBytes();
            // 调用defineClass 将二进制数据转化为class对象
            return defineClass(name, bytes, 0, bytes.length);
        }
     
    }

> 注意，如果设置当前类加载器的父类类加载器，可以通过构造方法指定，或者使用反射设置

##### Class文件监听 #####

文件监听主要是依靠jdk提供的 WatchService ，这里调用了hutool 中提供的工具实现。

import cn.hutool.core.io.watch.WatchMonitor;
    import cn.hutool.core.io.watch.Watcher;
    import cn.hutool.core.lang.Console;
    import lombok.SneakyThrows;
     
    import java.io.File;
    import java.nio.file.Path;
    import java.nio.file.WatchEvent;
     
    /** * <h1>文件监听</h1> * <p> * 利用hutool封装的文件监听方法，监听class文件的变化 * * @author gengzi * @date 2021年4月14日14:00:57 */
    public class CheckListener { 
     
        /** * 监听方法 * 持续监听，检索代码变化，这里只监听文件或目录的修改事件 * * @param file 被监听的目录或者文件 */
        public static void listener(File file) { 
            WatchMonitor watchMonitor = WatchMonitor.create(file, WatchMonitor.ENTRY_MODIFY);
            watchMonitor.setWatcher(new Watcher() { 
                @Override
                public void onCreate(WatchEvent<?> event, Path currentPath) { 
                    Object obj = event.context();
                    Console.log("创建：{}-> {}", currentPath, obj);
                }
     
                @SneakyThrows
                @Override
                public void onModify(WatchEvent<?> event, Path currentPath) { 
                    Object obj = event.context();
                    Console.log("修改：{}-> {}", currentPath, obj);
                    // 重新创建classloader 加载对应类
                    SysApplication.restart();
                }
     
                @Override
                public void onDelete(WatchEvent<?> event, Path currentPath) { 
                    Object obj = event.context();
                    Console.log("删除：{}-> {}", currentPath, obj);
                }
     
                @Override
                public void onOverflow(WatchEvent<?> event, Path currentPath) { 
                    Object obj = event.context();
                    Console.log("Overflow：{}-> {}", currentPath, obj);
                }
            });
            //设置监听目录的最大深入，目录层级大于制定层级的变更将不被监听，默认只监听当前层级目录
            watchMonitor.setMaxDepth(3);
            //启动监听
            watchMonitor.start();
        }
     
     
    }

##### 重新加载类方法 #####

这里加入了验证方法 test ，会通过new实例化TestCode 对象。

import cn.hutool.core.io.FileUtil;
    import lombok.SneakyThrows;
     
    import java.io.File;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.net.URL;
     
    public class SysApplication { 
     
     
        // 测试 TestCode 修改内容是否生效
        public void test() { 
            new TestCode();
        }
     
        /** * run * <p> * 利用全盘委托机制，加载当前类。那么当前类下面 new 对象的类，都会使用加载当前类的类加载器 */
        @SneakyThrows
        public static void run(Class clazz) { 
     
            URL resource = Thread.currentThread().getContextClassLoader().getResource("");
            String path = resource.getPath();
            String filepath = path + clazz.getPackage().getName().replace(".", "/");
            System.out.println("启动--------");
            restart();
            // 开启文件监听
            File file = FileUtil.file(filepath);
            CheckListener.listener(file);
        }
     
     
        public static void restart() throws IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException { 
            // 获取当前类的全限定名称
            String name = SysApplication.class.getName();
            // 创建自定义类加载器
            HotDeploymentClassLoaderV3 hotDeploymentClassLoaderV3 = new HotDeploymentClassLoaderV3();
            Class<?> aClass = hotDeploymentClassLoaderV3.loadClass(name);
            // 实例化
            Object object = aClass.newInstance();
            // 调用test方法
            Method test = aClass.getMethod("test");
            test.invoke(object);
        }
    }

##### 入口程序和测试代码 #####

/** * <h1>程序入口</h1> * * @author gengzi * @date 2021年4月13日17:16:05 */
    public class Application { 
        public static void main(String[] args) { 
            SysApplication.run(Application.class);
        }
     
    }

测试代码：

public class TestCode { 
     
        static { 
            System.out.println("TestCode类加载器:" + TestCode.class.getClassLoader());
        }
     
        public TestCode() { 
            System.out.println("version2.0");
        }
    }

#### 测试 ####

通过入口程序启动，然后修改TestCode的代码， 把构造方法打印的文本更新为 version3.0 ,看TestCode是否被重新加载，验证热部署是否生效。

> 注意：文件监听的目录是target目录，如果idea没有配置自动编译，需要手动编译（Build），将修改的java类转化为Class文件到target目录中。

日志：

## 启动
    启动--------
    TestCode类加载器:fun.gengzi.codecopy.business.classloader.hotdeployment.v2.HotDeploymentClassLoaderV3@12bb4df8
    ### 构造方法打印
    version2.0
    ## 修改TestCode 代码，触发文件监听
    修改：D:\ideaworkspace\codecopy\codecopy\target\classes\fun\gengzi\codecopy\business\classloader\hotdeployment\v2-> TestCode.class
    TestCode类加载器:fun.gengzi.codecopy.business.classloader.hotdeployment.v2.HotDeploymentClassLoaderV3@62ffb83c
    ### 构造方法打印
    version3.0

### 扩展 ###

**实战-代码加密**

[10行代码破解大部分Java Class加密][10_Java Class]

[基于ClassLoader的java代码加密的经验分享][ClassLoader_java]

> 听说点赞关注的人，身体健康，一夜暴富，升职加薪迎娶白富美!!!
> 
> [点我领取每日福利][Link 1]  
> 微信公众号：**耿子blog**  
> GitHub地址：**[gengzi][]**  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center]

[Spring-Boot-Devtools _ _]: https://blog.csdn.net/cxlswh/article/details/113926878
[class_Tomcat]: https://www.hollischuang.com/archives/594
[HotSwap_JRebel]: https://www.hollischuang.com/archives/598
[Java]: https://www.hollischuang.com/archives/592
[class_Tomcat 1]: http://www.blogjava.net/heavensay/archive/2012/11/07/389685.html
[java]: https://www.zhihu.com/question/61040749
[spring-boot-devtools]: https://github.com/spring-projects/spring-boot/tree/master/spring-boot-project/spring-boot-devtools
[SpringBoot]: https://gengzi.blog.csdn.net/article/details/112694308
[JRebel]: https://www.jrebel.com/learn/how-does-jrebel-work
[Spring]: https://zhuanlan.zhihu.com/p/101128672
[codecopy]: https://github.com/gengzi/codecopy/tree/master/src/main/java/fun/gengzi/codecopy/business/classloader/hotdeployment/v2
[10_Java Class]: https://zhuanlan.zhihu.com/p/25868761
[ClassLoader_java]: https://my.oschina.net/passerman/blog/1825437
[Link 1]: https://gengzi.github.io/Code-animal/#/./docs/fuli/README
[gengzi]: https://github.com/gengzi
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/390bcef3a99440aa946cd2fc1b550896.png