自定义类加载器实现热加载.md

什么是热加载

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

热加载与热部署的区别

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

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

在部署方式上：

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

在实现原理上：

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

在使用场景上：

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

实现类的热加载

实现思路

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

实现自己的类加载器。

• 从自己的类加载器中加载要热加载的类。
• 不断轮询要热加载的类 class
• 文件是否有更新。
• 如果有更新，重新加载。

自定义类加载器

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

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

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

public class MyClassLoader extends ClassLoader{

    /** 要加载的 Java 类的 classpath 路径 */
    private String classpath;

    public MyClassLoader(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;
    }
}

定义要热加载的类

// 接口
public interface ICountService {
    int count();
}
//实现类
public class CountServiceImpl implements ICountService {
    private int count = 0;
    @Override
    public int count() {
        System.out.println(LocalTime.now() + ": Java类的热加载 Oh~~~~");
        return count ++;
    }
}

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

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

@Data
public class LoadInfo {
    /** 自定义的类加载器 */
    private MyClassLoader myClassLoader;

    /** 记录要加载的类的时间戳-->加载的时间 */
    private long loadTime;

    /** 需要被热加载的类 */
    private ICountService manager;

    public LoadInfo(MyClassLoader myClassLoader, long loadTime) {
        this.myClassLoader = myClassLoader;
        this.loadTime = loadTime;
        }
}

热加载获取类信息

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

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

public class ManagerFactory {
    /** 记录热加载类的加载信息 */
    private static final Map<String, LoadInfo> loadTimeMap = new HashMap<>();
    /** 要加载的类的 classpath */
    public static final String CLASS_PATH = "/Users/koolearn/Documents/ideaData/springboot-learn/springboot-learn/springboot-manage/target/classes";
    /** 实现热加载的类的全名称(包名+类名 ) */
    public static final String MY_MANAGER = "com.lcyanxi.serviceImpl.CountServiceImpl";

    public static ICountService 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) {
        MyClassLoader myClassLoader = new MyClassLoader(className);
        Class loadClass = null;
        // 加载
        try {
            loadClass = myClassLoader.loadClass(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        ICountService manager = newInstance(loadClass);
        LoadInfo loadInfo = new LoadInfo(myClassLoader, lastModified);
        loadInfo.setManager(manager);
        loadTimeMap.put(className, loadInfo);
    }

    /**
     * 以反射的方式创建 ICountService 的子类对象
     * @param loadClass
     * @return
     */
    private static ICountService newInstance(Class loadClass) {
        try {
            return (ICountService)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;
    }
}

热加载测试

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

public class MyClassLoadTest {
    public static void main(String[] args) {
        new Thread(new MsgHandle()).start();
    }
}

class MsgHandle implements Runnable {
    @Override
    public void run() {
        while (true) {
            ICountService manager = ManagerFactory.getManager(ManagerFactory.MY_MANAGER);
            manager.count();
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

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

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

运行结果：

10:02:17.170: Java类的热加载
当前的类时间：0
10:02:19.174: Java类的热加载
当前的类时间：0
10:02:21.177: Java类的热加载 Oh~~~~
当前的类时间：0
10:02:23.181: Java类的热加载 Oh~~~~

原文地址