Java 热加载

1. 什么是热加载

热加载是指可以在不重启服务的情况下让更改的代码生效,热加载可以显著的提升开发以及调试的效率,它是基于 Java 的类加载器实现的,但是由于热加载的不安全性,一般不会用于正式的生产环境。

2. 热加载与热部署的区别

首先,不管是热加载还是热部署,都可以在不重启服务的情况下编译/部署项目,都是基于 Java 的类加载器实现的。

那么两者到底有什么区别呢?

在部署方式上:

  • 热部署是在服务器运行时重新部署项目。
  • 热加载是在运行时重新加载 class

在实现原理上:

  • 热部署是直接重新加载整个应用,耗时相对较高。
  • 热加载是在运行时重新加载 class,后台会启动一个线程不断检测你的类是否改变。

在使用场景上:

  • 热部署更多的是在生产环境使用。
  • 热加载则更多的是在开发环境上使用。线上由于安全性问题不会使用,难以监控。

3. 类加载五个阶段

可能你已经发现了,图中一共是7个阶段,而不是5个。是因为图是类的完整生命周期,如果要说只是类加载阶段的话,图里最后的使用(Using)和卸载(Unloading)并不算在内。

简单描述一下类加载的五个阶段:

  1. 加载阶段:找到类的静态存储结构,加载到虚拟机,定义数据结构。用户可以自定义类加载器。
  2. 验证阶段:确保字节码是安全的,确保不会对虚拟机的安全造成危害。
  3. 准备阶段:确定内存布局,确定内存遍历,赋初始值(注意:是初始值,也有特殊情况)。
  4. 解析阶段:将符号变成直接引用。
  5. 初始化阶段:调用程序自定义的代码。规定有且仅有5种情况必须进行初始化。
    1. new(实例化对象)、getstatic(获取类变量的值,被final修饰的除外,他的值在编译器时放到了常量池)、putstatic(给类变量赋值)、invokestatic(调用静态方法) 时会初始化
    2. 调用子类的时候,发现父类还没有初始化,则父类需要立即初始化。
    3. 虚拟机启动,用户要执行的主类,主类需要立即初始化,如 main 方法。
    4. 使用 java.lang.reflect包的方法对类进行反射调用方法 是会初始化。
    5. 当使用JDK 1.7的动态语言支持时, 如果一个java.lang.invoke.MethodHandle实例最后
      的解析结果

      REF_getStatic、 REF_putStatic、 REF_invokeStatic

      的方法句柄, 并且这个方法句柄所对应的类没有进行过初始化, 则需要先触发其初始化。

要说明的是,类加载的 5 个阶段中,只有加载阶段是用户可以自定义处理的,而验证阶段、准备阶段、解析阶段、初始化阶段都是用 JVM 来处理的。

4. 实现类的热加载

4.1 实现思路

我们怎么才能手动写一个类的热加载呢?根据上面的分析,Java 程序在运行的时候,首先会把 class 类文件加载到 JVM 中,而类的加载过程又有五个阶段,五个阶段中只有加载阶段用户可以进行自定义处理,所以我们如果能在程序代码更改且重新编译后,让运行的进程可以实时获取到新编译后的 class 文件,然后重新进行加载的话,那么理论上就可以实现一个简单的 Java 热加载。

所以我们可以得出实现思路:

  1. 实现自己的类加载器。
  2. 从自己的类加载器中加载要热加载的类。
  3. 不断轮训要热加载的类 class 文件是否有更新。
  4. 如果有更新,重新加载。

4.2 自定义类加载器

设计 Java 虚拟机的团队把类的加载阶段放到的 JVM 的外部实现(  通过一个类的全限定名来获取描述此类的二进制字节流  )。这样就可以让程序自己决定如果获取到类信息。而实现这个加载动作的代码模块,我们就称之为 “类加载器”。

在 Java 中,类加载器也就是  ClassLoader. 所以如果我们想要自己实现一个类加载器,就需要继承 ClassLoader 然后重写里面 findClass的方法,同时因为类加载器是 双亲委派模型实现(也就说。除了一个最顶层的类加载器之外,每个类加载器都要有父加载器,而加载时,会先询问父加载器能否加载,如果父加载器不能加载,则会自己尝试加载)所以我们还需要指定父加载器。

最后根据传入的类路径,加载类的代码看下面。

  1. package net.codingme.box.classloader;

  2.  

  3.  

    import java.io.ByteArrayOutputStream;

  4.  

    import java.io.File;

  5.  

    import java.io.FileInputStream;

  6.  

  7.  

    /**

  8.  

    * <p>

  9.  

    * 自定义 Java类加载器来实现Java 类的热加载

  10.  

    */

  11.  

    public class MyClasslLoader extends ClassLoader {

  12.  

  13.  

    /** 要加载的 Java 类的 classpath 路径 */

  14.  

    private String classpath;

  15.  

  16.  

    public MyClasslLoader(String classpath) {

  17.  

    // 指定父加载器

  18.  

    super(ClassLoader.getSystemClassLoader());

  19.  

    this.classpath = classpath;

  20.  

    }

  21.  

  22.  

    @Override

  23.  

    protected Class<?> findClass(String name) throws ClassNotFoundException {

  24.  

    byte[] data = this.loadClassData(name);

  25.  

    return this.defineClass(name, data, 0, data.length);

  26.  

    }

  27.  

  28.  

    /**

  29.  

    * 加载 class 文件中的内容

  30.  

    *

  31.  

    * @param name

  32.  

    * @return

  33.  

    */

  34.  

    private byte[] loadClassData(String name) {

  35.  

    try {

  36.  

    // 传进来是带包名的

  37.  

    name = name.replace(".", "//");

  38.  

    FileInputStream inputStream = new FileInputStream(new File(classpath + name + ".class"));

  39.  

    // 定义字节数组输出流

  40.  

    ByteArrayOutputStream baos = new ByteArrayOutputStream();

  41.  

    int b = 0;

  42.  

    while ((b = inputStream.read()) != -1) {

  43.  

    baos.write(b);

  44.  

    }

  45.  

    inputStream.close();

  46.  

    return baos.toByteArray();

  47.  

    } catch (Exception e) {

  48.  

    e.printStackTrace();

  49.  

    }

  50.  

    return null;

  51.  

    }

  52.  

    }

4.3 定义要类型热加载的类

我们假设某个接口(BaseManager.java)下的某个方法(logic)要进行热加载处理。

首先定义接口信息。

  1. package net.codingme.box.classloader;

  2.  

  3.  

    /**

  4.  

    * <p>

  5.  

    * 实现这个接口的子类,需要动态更新。也就是热加载

  6.  

    */

  7.  

    public interface BaseManager {

  8.  

  9.  

    public void logic();

  10.  

    }

写一个这个接口的实现类。

  1. package net.codingme.box.classloader;

  2.  

  3.  

    import java.time.LocalTime;

  4.  

  5.  

    /**

  6.  

    * <p>

  7.  

    * BaseManager 这个接口的子类要实现类的热加载功能。

  8.  

    */

  9.  

    public class MyManager implements BaseManager {

  10.  

  11.  

    @Override

  12.  

    public void logic() {

  13.  

    System.out.println(LocalTime.now() + ": Java类的热加载");

  14.  

    }

  15.  

    }

后面我们要做的就是让这个类可以通过我们的 MyClassLoader 进行自定义加载。类的热加载应当只有在类的信息被更改然后重新编译之后进行重新加载。所以为了不意义的重复加载,我们需要判断 class 是否进行了更新,所以我们需要记录 class 类的修改时间,以及对应的类信息。

所以编译一个类用来记录某个类对应的某个类加载器以及上次加载的 class 的修改时间。

  1. package net.codingme.box.classloader;

  2.  

  3.  

    /**

  4.  

    * <p>

  5.  

    * 封装加载类的信息

  6.  

    */

  7.  

    public class LoadInfo {

  8.  

  9.  

    /** 自定义的类加载器 */

  10.  

    private MyClasslLoader myClasslLoader;

  11.  

  12.  

    /** 记录要加载的类的时间戳-->加载的时间 */

  13.  

    private long loadTime;

  14.  

  15.  

    /** 需要被热加载的类 */

  16.  

    private BaseManager manager;

  17.  

  18.  

    public LoadInfo(MyClasslLoader myClasslLoader, long loadTime) {

  19.  

    this.myClasslLoader = myClasslLoader;

  20.  

    this.loadTime = loadTime;

  21.  

    }

  22.  

  23.  

    public MyClasslLoader getMyClasslLoader() {

  24.  

    return myClasslLoader;

  25.  

    }

  26.  

  27.  

    public void setMyClasslLoader(MyClasslLoader myClasslLoader) {

  28.  

    this.myClasslLoader = myClasslLoader;

  29.  

    }

  30.  

  31.  

    public long getLoadTime() {

  32.  

    return loadTime;

  33.  

    }

  34.  

  35.  

    public void setLoadTime(long loadTime) {

  36.  

    this.loadTime = loadTime;

  37.  

    }

  38.  

  39.  

    public BaseManager getManager() {

  40.  

    return manager;

  41.  

    }

  42.  

  43.  

    public void setManager(BaseManager manager) {

  44.  

    this.manager = manager;

  45.  

    }

  46.  

    }

4.4 热加载获取类信息

在实现思路里,我们知道轮训检查 class 文件是不是被更新过,所以每次调用要热加载的类时,我们都要进行检查类是否被更新然后决定要不要重新加载。为了方便这步的获取操作,可以使用一个简单的工厂模式进行封装。

要注意是加载 class 文件需要指定完整的路径,所以类中定义了 CLASS_PATH 常量。

  1. package net.codingme.box.classloader;

  2.  

  3.  

    import java.io.File;

  4.  

    import java.lang.reflect.InvocationTargetException;

  5.  

    import java.util.HashMap;

  6.  

    import java.util.Map;

  7.  

  8.  

    /**

  9.  

    * <p>

  10.  

    * 加载 manager 的工厂

  11.  

    *

  12.  

    */

  13.  

    public class ManagerFactory {

  14.  

  15.  

    /** 记录热加载类的加载信息 */

  16.  

    private static final Map<String, LoadInfo> loadTimeMap = new HashMap<>();

  17.  

  18.  

    /** 要加载的类的 classpath */

  19.  

    public static final String CLASS_PATH = "D:\\IdeaProjectMy\\lab-notes\\target\\classes\\";

  20.  

  21.  

    /** 实现热加载的类的全名称(包名+类名 ) */

  22.  

    public static final String MY_MANAGER = "net.codingme.box.classloader.MyManager";

  23.  

  24.  

    public static BaseManager getManager(String className) {

  25.  

    File loadFile = new File(CLASS_PATH + className.replaceAll("\\.", "/") + ".class");

  26.  

    // 获取最后一次修改时间

  27.  

    long lastModified = loadFile.lastModified();

  28.  

    System.out.println("当前的类时间:" + lastModified);

  29.  

    // loadTimeMap 不包含 ClassName 为 key 的信息,证明这个类没有被加载,要加载到 JVM

  30.  

    if (loadTimeMap.get(className) == null) {

  31.  

    load(className, lastModified);

  32.  

    } // 加载类的时间戳变化了,我们同样要重新加载这个类到 JVM。

  33.  

    else if (loadTimeMap.get(className).getLoadTime() != lastModified) {

  34.  

    load(className, lastModified);

  35.  

    }

  36.  

    return loadTimeMap.get(className).getManager();

  37.  

    }

  38.  

  39.  

    /**

  40.  

    * 加载 class ,缓存到 loadTimeMap

  41.  

  42.  

    * @param className

  43.  

    * @param lastModified

  44.  

    */

  45.  

    private static void load(String className, long lastModified) {

  46.  

    MyClasslLoader myClasslLoader = new MyClasslLoader(className);

  47.  

    Class loadClass = null;

  48.  

    // 加载

  49.  

    try {

  50.  

    loadClass = myClasslLoader.loadClass(className);

  51.  

    } catch (ClassNotFoundException e) {

  52.  

    e.printStackTrace();

  53.  

    }

  54.  

  55.  

    BaseManager manager = newInstance(loadClass);

  56.  

    LoadInfo loadInfo = new LoadInfo(myClasslLoader, lastModified);

  57.  

    loadInfo.setManager(manager);

  58.  

    loadTimeMap.put(className, loadInfo);

  59.  

    }

  60.  

  61.  

    /**

  62.  

    * 以反射的方式创建 BaseManager 的子类对象

  63.  

  64.  

    * @param loadClass

  65.  

    * @return

  66.  

    */

  67.  

    private static BaseManager newInstance(Class loadClass) {

  68.  

    try {

  69.  

    return (BaseManager)loadClass.getConstructor(new Class[] {}).newInstance(new Object[] {});

  70.  

    } catch (InstantiationException e) {

  71.  

    e.printStackTrace();

  72.  

    } catch (IllegalAccessException e) {

  73.  

    e.printStackTrace();

  74.  

    } catch (InvocationTargetException e) {

  75.  

    e.printStackTrace();

  76.  

    } catch (NoSuchMethodException e) {

  77.  

    e.printStackTrace();

  78.  

    }

  79.  

    return null;

  80.  

    }

  81.  

    }

4.5  热加载测试

直接写一个线程不断的检测要热加载的类是不是已经更改需要重新加载,然后运行测试即可。

  1. package net.codingme.box.classloader;

  2.  

  3.  

    /**

  4.  

    * <p>

  5.  

    *

  6.  

    * 后台启动一条线程,不断检测是否要刷新重新加载,实现了热加载的类

  7.  

  8.  

    */

  9.  

    public class MsgHandle implements Runnable {

  10.  

    @Override

  11.  

    public void run() {

  12.  

    while (true) {

  13.  

    BaseManager manager = ManagerFactory.getManager(ManagerFactory.MY_MANAGER);

  14.  

    manager.logic();

  15.  

    try {

  16.  

    Thread.sleep(2000);

  17.  

    } catch (InterruptedException e) {

  18.  

    e.printStackTrace();

  19.  

    }

  20.  

    }

  21.  

    }

  22.  

    }

主线程:

  1. package net.codingme.box.classloader;

  2.  

  3.  

    public class ClassLoadTest {

  4.  

    public static void main(String[] args) {

  5.  

    new Thread(new MsgHandle()).start();

  6.  

    }

  7.  

    }

代码已经全部准备好了,最后一步,可以启动测试了。如果你是用的是 Eclipse ,直接启动就行了;如果是 IDEA ,那么你需要 DEBUG 模式启动(IDEA 对热加载有一定的限制)。

启动后看到控制台不断的输出:

  1. 00:08:13.018: Java类的热加载

  2.  

    00:08:15.018: Java类的热加载

这时候我们随便更改下 MyManager 类的 logic 方法的输出内容然后保存。

  1. Override

  2.  

    public void logic() {

  3.  

    System.out.println(LocalTime.now() + ": Java类的热加载 Oh~~~~");

  4.  

    }

可以看到控制台的输出已经自动更改了(IDEA 在更改后需要按 CTRL + F9)。

原文地址:https://www.cnblogs.com/ko88/p/11790300.html

时间: 2024-11-05 16:04:06

Java 热加载的相关文章

原来热加载如此简单,手动写一个 Java 热加载吧

1. 什么是热加载 热加载是指可以在不重启服务的情况下让更改的代码生效,热加载可以显著的提升开发以及调试的效率,它是基于 Java 的类加载器实现的,但是由于热加载的不安全性,一般不会用于正式的生产环境. 2. 热加载与热部署的区别 首先,不管是热加载还是热部署,都可以在不重启服务的情况下编译/部署项目,都是基于 Java 的类加载器实现的. 那么两者到底有什么区别呢? 在部署方式上: 热部署是在服务器运行时重新部署项目. 热加载是在运行时重新加载 class. 在实现原理上: 热部署是直接重新

java热加载

应用服务器一般都支持热部署(Hot Deployment),更新代码时把新编译的确类 替换旧的就行,后面的程序就执行新类中的代码.这也是由各种应用服务器的独 有的类加载器层次实现的.那如何在我们的程序中也实现这种热加载功能呢?即 要在虚拟机不关闭的情况下(比如一个),换个类,JVM 就知道加载这个新类,执 行新类中的逻辑呢?下面就简单演示这样一个热加载的例子,首先大致了解一下 类加载器. 标准 Java 启动器的类加载器层次 1. 引导类加载器(bootstrap): 加载内核 API,如 rt

Java热加载的实现

应用服务器一般都支持热部署或者热加载(Hot Deployment或者Hot Swap),即更新代码保存时把新编译类替换旧的类,后面的程序就执行新类中的代码.这也是由各种应用服务器的独有的类加载器层次实现的. 那如何在我们的程序中也实现这种热加载功能呢? 即要在不重启JVM虚拟机的情况下,换个类,JVM就知道加载这个新类,执行新类中的逻辑. 首先大致了解一下类加载器: 标准 Java 启动器的类加载器层次 1. 引导类加载器(bootstrap):加载内核 API,如 rt.jar(java.l

java的热部署和热加载

ps:热部署和热加载其实是两个类似但不同的概念,之前理解不深,so,这篇文章重构了下. 一.热部署与热加载 在应用运行的时升级软件,无需重新启动的方式有两种,热部署和热加载. 对于Java应用程序来说,热部署就是在服务器运行时重新部署项目,热加载即在在运行时重新加载class,从而升级应用. 二.实现原理 热加载的实现原理主要依赖java的类加载机制,在实现方式可以概括为在容器启动的时候起一条后台线程,定时的检测类文件的时间戳变化,如果类的时间戳变掉了,则将类重新载入. 对比反射机制,反射是在运

springboot热部署(一)——Java热部署与热加载原理

一.概述 在应用运行的时升级软件,无需重新启动的方式有两种,热部署和热加载. 对于Java应用程序来说, 热部署就是在服务器运行时重新部署项目,——生产环境 热加载即在在运行时重新加载class,从而升级应用.——开发环境 原文地址:https://www.cnblogs.com/jiangbei/p/8438733.html

Eclipse tomcat插件禁用热加载

Eclipse中的tomcat插件默认是开户了热加载,只要是修改了java文件一保存,tomcat自动编译.加载.发布,很吃内存. 关闭方法: 打开eclipse,找到server项: 双击打开,修改: 如图保存即可.

[Eclipse] - 集成Tomcat热加载插件

使用Eclipse + Tomcat,要使用热加载,总是会重启tomcat webapp. 可以使用这个插件:jrebel 如果是Tomcat 7.0+版本,需要使用jrebel5.5.1+的版本,不然总会报一些错误. 使用方法: 1) 下载jrebel 5.5.1+ 2) 右键项目,选择: 3) 找到"VM arguments": 里头填入: -Dcatalina.base="E:\JavaProject\.metadata\.plugins\org.eclipse.wst

idea开发maven项目热加载

JavaWeb项目,尤其是一些大型项目,在开发过程中,启动项目耗费的时间就不短.大大的拖慢了开发速度!在这分享一种不需要插件就能实现热加载的方法! 默认已经创建好一个Maven项目 点击此按钮 点击 加号 按钮,选择Maven Name随便起名即可,最右边选择要注意选择Maven Model.最下边二个原样写上,点击确定即可! 附带Maven Tomcat插件配置代码 <!-- 配置Tomcat插件 --> <plugin> <groupId>org.apache.to

[Eclipse] - 集成JBoss7热加载和自动发布

使用Eclipse + JBoss开发时,总是要重启项目或JBoss,烦人.下面方法可以很简单的实现Eclipse + JBoss热加载和自动发布. 我的环境是JBoss 7.1.1 Final 1) 下载这个:jboss-as-web-7.1.1.Final-RECOMPILE.jar http://files.cnblogs.com/HD/jboss-as-web-7.1.1.Final-RECOMPILE.jar.zip 2) 把这个jar包放到这个目录下:jboss-as-7.1.1.F