1. 什么是热加载
热加载是指能够在不重启服务的状况下让更改的代码生效，热加载能够显著的提高开发以及调试的效率，它是基于 Java 的类加载器实现的，可是因为热加载的不安全性，通常不会用于正式的生产环境。java
2. 热加载与热部署的区别
首先，不论是热加载仍是热部署，均可以在不重启服务的状况下编译/部署项目，都是基于 Java 的类加载器实现的。git
那么二者到底有什么区别呢？github
在部署方式上：面试
- 热部署是在服务器运行时从新部署项目。
- 热加载是在运行时从新加载 class。
在实现原理上：shell
- 热部署是直接从新加载整个应用，耗时相对较高。
- 热加载是在运行时从新加载 class，后台会启动一个线程不断检测你的类是否改变。
在使用场景上：数组
- 热部署更多的是在生产环境使用。
- 热加载则更多的是在开发环境上使用。线上因为安全性问题不会使用，难以监控。
3. 类加载五个阶段
可能你已经发现了，图中一共是7个阶段，而不是5个。是由于图是类的完整生命周期，若是要说只是类加载阶段的话，图里最后的使用（Using）和卸载（Unloading）并不算在内。缓存
简单描述一下类加载的五个阶段：安全
-
加载阶段：找到类的静态存储结构，加载到虚拟机，定义数据结构。用户能够自定义类加载器。服务器
-
验证阶段：确保字节码是安全的，确保不会对虚拟机的安全形成危害。
-
准备阶段：肯定内存布局，肯定内存遍历，赋初始值（注意：是初始值，也有特殊状况）。
-
解析阶段： 将符号变成直接引用。
- 初始化阶段：调用程序自定义的代码。规定有且仅有5种状况必须进行初始化。
- new（实例化对象）、getstatic（获取类变量的值，被final修饰的除外，他的值在编译器时放到了常量池）、putstatic（给类变量赋值）、invokestatic（调用静态方法） 时会初始化
- 调用子类的时候，发现父类尚未初始化，则父类须要当即初始化。
- 虚拟机启动，用户要执行的主类，主类须要当即初始化，如 main 方法。
- 使用 java.lang.reflect包的方法对类进行反射调用方法 是会初始化。
- 当使用JDK 1.7的动态语言支持时， 若是一个java.lang.invoke.MethodHandle实例最后
的解析结果REF_getStatic、 REF_putStatic、 REF_invokeStatic的方法句柄， 而且这个方法句柄
所对应的类没有进行过初始化， 则须要先触发其初始化。
要说明的是，类加载的 5 个阶段中，只有加载阶段是用户能够自定义处理的，而验证阶段、准备阶段、解析阶段、初始化阶段都是用 JVM 来处理的。
4. 实现类的热加载
4.1 实现思路
咱们怎么才能手动写一个类的热加载呢？根据上面的分析，Java 程序在运行的时候，首先会把 class 类文件加载到 JVM 中，而类的加载过程又有五个阶段，五个阶段中只有加载阶段用户能够进行自定义处理，因此咱们若是能在程序代码更改且从新编译后，让运行的进程能够实时获取到新编译后的 class 文件，而后从新进行加载的话，那么理论上就能够实现一个简单的 Java 热加载。
因此咱们能够得出实现思路：
- 实现本身的类加载器。
- 从本身的类加载器中加载要热加载的类。
- 不断轮训要热加载的类 class 文件是否有更新。
- 若是有更新，从新加载。
4.2 自定义类加载器
设计 Java 虚拟机的团队把类的加载阶段放到的 JVM 的外部实现（ 经过一个类的全限定名来获取描述此类的二进制字节流 ）。这样就可让程序本身决定若是获取到类信息。而实现这个加载动做的代码模块，咱们就称之为 “类加载器”。
在 Java 中，类加载器也就是 java.lang.ClassLoader. 因此若是咱们想要本身实现一个类加载器，就须要继承 ClassLoader 而后重写里面 findClass的方法，同时由于类加载器是 双亲委派模型实现（也就说。除了一个最顶层的类加载器以外，每一个类加载器都要有父加载器，而加载时，会先询问父加载器可否加载，若是父加载器不能加载，则会本身尝试加载）因此咱们还须要指定父加载器。
最后根据传入的类路径，加载类的代码看下面。
package net.codingme.box.classloader; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; /** * <p> * 自定义 Java类加载器来实现Java 类的热加载 * * @Author niujinpeng * @Date 2019/10/24 23:22 */ public class MyClasslLoader extends ClassLoader { /** 要加载的 Java 类的 classpath 路径 */ private String classpath; public MyClasslLoader(String classpath) { // 指定父加载器 super(ClassLoader.getSystemClassLoader()); this.classpath = classpath; } @Override protected Class<?> findClass(String name) throws ClassNotFoundException { byte[] data = this.loadClassData(name); return this.defineClass(name, data, 0, data.length); } /** * 加载 class 文件中的内容 * * @param name * @return */ private byte[] loadClassData(String name) { try { // 传进来是带包名的 name = name.replace(".", "//"); FileInputStream inputStream = new FileInputStream(new File(classpath + name + ".class")); // 定义字节数组输出流 ByteArrayOutputStream baos = new ByteArrayOutputStream(); int b = 0; while ((b = inputStream.read()) != -1) { baos.write(b); } inputStream.close(); return baos.toByteArray(); } catch (Exception e) { e.printStackTrace(); } return null; } }
4.3 定义要类型热加载的类
咱们假设某个接口（BaseManager.java）下的某个方法（logic）要进行热加载处理。
首先定义接口信息。
package net.codingme.box.classloader; /** * <p> * 实现这个接口的子类，须要动态更新。也就是热加载 * * @Author niujinpeng * @Date 2019/10/24 23:29 */ public interface BaseManager { public void logic(); }
写一个这个接口的实现类。
package net.codingme.box.classloader; import java.time.LocalTime; /** * <p> * BaseManager 这个接口的子类要实现类的热加载功能。 * * @Author niujinpeng * @Date 2019/10/24 23:30 */ public class MyManager implements BaseManager { @Override public void logic() { System.out.println(LocalTime.now() + ": Java类的热加载"); } }
后面咱们要作的就是让这个类能够经过咱们的 MyClassLoader 进行自定义加载。类的热加载应当只有在类的信息被更改而后从新编译以后进行从新加载。因此为了避免意义的重复加载，咱们须要判断 class 是否进行了更新，因此咱们须要记录 class 类的修改时间，以及对应的类信息。
因此编译一个类用来记录某个类对应的某个类加载器以及上次加载的 class 的修改时间。
package net.codingme.box.classloader; /** * <p> * 封装加载类的信息 * * @Author niujinpeng * @Date 2019/10/24 23:32 */ public class LoadInfo { /** 自定义的类加载器 */ private MyClasslLoader myClasslLoader; /** 记录要加载的类的时间戳-->加载的时间 */ private long loadTime; /** 须要被热加载的类 */ private BaseManager manager; public LoadInfo(MyClasslLoader myClasslLoader, long loadTime) { this.myClasslLoader = myClasslLoader; this.loadTime = loadTime; } public MyClasslLoader getMyClasslLoader() { return myClasslLoader; } public void setMyClasslLoader(MyClasslLoader myClasslLoader) { this.myClasslLoader = myClasslLoader; } public long getLoadTime() { return loadTime; } public void setLoadTime(long loadTime) { this.loadTime = loadTime; } public BaseManager getManager() { return manager; } public void setManager(BaseManager manager) { this.manager = manager; } }
4.4 热加载获取类信息
在实现思路里，咱们知道轮训检查 class 文件是否是被更新过，因此每次调用要热加载的类时，咱们都要进行检查类是否被更新而后决定要不要从新加载。为了方便这步的获取操做，可使用一个简单的工厂模式进行封装。
要注意是加载 class 文件须要指定完整的路径，因此类中定义了 CLASS_PATH 常量。
package net.codingme.box.classloader; import java.io.File; import java.lang.reflect.InvocationTargetException; import java.util.HashMap; import java.util.Map; /** * <p> * 加载 manager 的工厂 * * @Author niujinpeng * @Date 2019/10/24 23:38 */ public class ManagerFactory { /** 记录热加载类的加载信息 */ private static final Map<String, LoadInfo> loadTimeMap = new HashMap<>(); /** 要加载的类的 classpath */ public static final String CLASS_PATH = "D:\\IdeaProjectMy\\lab-notes\\target\\classes\\"; /** 实现热加载的类的全名称(包名+类名 ) */ public static final String MY_MANAGER = "net.codingme.box.classloader.MyManager"; public static BaseManager getManager(String className) { File loadFile = new File(CLASS_PATH + className.replaceAll("\\.", "/") + ".class"); // 获取最后一次修改时间 long lastModified = loadFile.lastModified(); System.out.println("当前的类时间：" + lastModified); // loadTimeMap 不包含 ClassName 为 key 的信息，证实这个类没有被加载，要加载到 JVM if (loadTimeMap.get(className) == null) { load(className, lastModified); } // 加载类的时间戳变化了，咱们一样要从新加载这个类到 JVM。 else if (loadTimeMap.get(className).getLoadTime() != lastModified) { load(className, lastModified); } return loadTimeMap.get(className).getManager(); } /** * 加载 class ，缓存到 loadTimeMap * * @param className * @param lastModified */ private static void load(String className, long lastModified) { MyClasslLoader myClasslLoader = new MyClasslLoader(className); Class loadClass = null; // 加载 try { loadClass = myClasslLoader.loadClass(className); } catch (ClassNotFoundException e) { e.printStackTrace(); } BaseManager manager = newInstance(loadClass); LoadInfo loadInfo = new LoadInfo(myClasslLoader, lastModified); loadInfo.setManager(manager); loadTimeMap.put(className, loadInfo); } /** * 以反射的方式建立 BaseManager 的子类对象 * * @param loadClass * @return */ private static BaseManager newInstance(Class loadClass) { try { return (BaseManager)loadClass.getConstructor(new Class[] {}).newInstance(new Object[] {}); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } return null; } }
4.5 热加载测试
直接写一个线程不断的检测要热加载的类是否是已经更改须要从新加载，而后运行测试便可。
package net.codingme.box.classloader; /** * <p> * * 后台启动一条线程，不断检测是否要刷新从新加载，实现了热加载的类 * * @Author niujinpeng * @Date 2019/10/24 23:53 */ public class MsgHandle implements Runnable { @Override public void run() { while (true) { BaseManager manager = ManagerFactory.getManager(ManagerFactory.MY_MANAGER); manager.logic(); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
主线程：
package net.codingme.box.classloader; public class ClassLoadTest { public static void main(String[] args) { new Thread(new MsgHandle()).start(); } }
代码已经所有准备好了，最后一步，能够启动测试了。若是你是用的是 Eclipse ，直接启动就好了；若是是 IDEA ，那么你须要 DEBUG 模式启动（IDEA 对热加载有必定的限制）。
启动后看到控制台不断的输出：
00:08:13.018: Java类的热加载 00:08:15.018: Java类的热加载
这时候咱们随便更改下 MyManager 类的 logic 方法的输出内容而后保存。
@Override public void logic() { System.out.println(LocalTime.now() + ": Java类的热加载 Oh~~~~"); }
能够看到控制台的输出已经自动更改了（IDEA 在更改后须要按 CTRL + F9）。
代码已经放到Github: https://github.com/niumoo/lab-notes/
<完>
我的网站：https://www.codingme.net
若是你喜欢这篇文章，能够关注公众号，文章第一时间直达 。
关注公众号回复资源能够没有套路的获取全网最火的的 Java 核心知识整理&面试资料。