关于java:牛逼自己手写一个热加载～

热加载：在不进行程序运行的状况下，对类（对象）的动静替换

Java 中的类从被加载到内存中到卸载出内存为止，一共经验了七个阶段：加载、验证、筹备、解析、初始化、应用、卸载。

接下来咱们重点解说加载和初始化这两步

在加载的阶段，虚拟机须要实现以下三件事：

通过一个类的全限定名来获取定义此类的 二进制字节流
将这个字节流所代表的的 动态存储构造 转化为 办法区 的运行时数据结构
在内存中生成一个代表这个类的 java.lang.Class 对象，作为办法区这个类的各种数据的拜访入口。

这三步都是通过类加载器来实现的。而官网定义的 Java 类加载器有BootstrapClassLoader、ExtClassLoader、AppClassLoader。这三个类加载器别离负责加载不同门路的类的加载。并造成一个父子构造。

类加载器名称	负责加载目录
`BootstrapClassLoader`	处于类加载器层次结构的最高层，负责 sun.boot.class.path 门路下类的加载，默认为 jre/lib 目录下的外围 API 或 -Xbootclasspath 选项指定的 jar 包
`ExtClassLoader`	加载门路为 java.ext.dirs，默认为 jre/lib/ext 目录或者 -Djava.ext.dirs 指定目录下的 jar 包加载
`AppClassLoader`	加载门路为 java.class.path，默认为环境变量 CLASSPATH 中设定的值。也能够通过 -classpath 选型进行指定

默认状况下，例如咱们应用关键字 new 或者 Class.forName 都是通过 AppClassLoader 类加载器来加载的

正因为是此父子构造，所以默认状况下如果要加载一个类，会优先将此类交给其父类进行加载（直到顶层的 BootstrapClassLoader 也没有），如果父类都没有，那么才会将此类交给子类加载。这就是类加载器的双亲委派规定。

当咱们要应用一个类的执行办法或者属性时，类必须是加载到内存中并且实现初始化的。那么类是什么时候被初始化的呢？有以下几种状况

应用 new 关键字实例化对象的时候、读取或者设置一个类的动态字段、以及调用一个类的静态方法。
应用 java.lang.reflect 包的办法对类进行反射调用时，如果类没有进行初始化，那么先进行初始化。
初始化一个类的时候，如果发现其父类没有进行初始化，则先触发父类的初始化。
当虚拟机启动时，用户须要制订一个执行的主类 (蕴含 main() 办法的那个类)虚构机会先初始化这个主类。

在下面咱们晓得了在默认状况下，类加载器是遵循双亲委派规定的。所以咱们要实现热加载，那么咱们须要加载的那些类就不能交给零碎加载器来实现。所以咱们要自定义类加载器来写咱们本人的规定。

要想实现本人的类加载器，只须要继承 ClassLoader 类即可。而咱们要突破双亲委派规定，那么咱们就必须要重写 loadClass 办法，因为默认状况下 loadClass 办法是遵循双亲委派的规定的。

public class CustomClassLoader extends ClassLoader{

    private static final String CLASS_FILE_SUFFIX = ".class";

    //AppClassLoader 的父类加载器
    private ClassLoader extClassLoader;

    public CustomClassLoader(){ClassLoader j = String.class.getClassLoader();
        if (j == null) {j = getSystemClassLoader();
            while (j.getParent() != null) {j = j.getParent();
            }
        }
        this.extClassLoader = j ;
    }

    protected Class<?> loadClass(String name, boolean resolve){

        Class cls = null;
        cls = findLoadedClass(name);
        if (cls != null){return cls;}
        // 获取 ExtClassLoader
        ClassLoader extClassLoader = getExtClassLoader() ;
        // 确保自定义的类不会笼罩 Java 的外围类
        try {cls = extClassLoader.loadClass(name);
            if (cls != null){return cls;}
        }catch (ClassNotFoundException e){ }
        cls = findClass(name);
        return cls;
    }

    @Override
    public Class<?> findClass(String name) {byte[] bt = loadClassData(name);
        return defineClass(name, bt, 0, bt.length);
    }

    private byte[] loadClassData(String className) {
        // 读取 Class 文件呢
        InputStream is = getClass().getClassLoader().getResourceAsStream(className.replace(".", "/")+CLASS_FILE_SUFFIX);
        ByteArrayOutputStream byteSt = new ByteArrayOutputStream();
        // 写入 byteStream
        int len =0;
        try {while((len=is.read())!=-1){byteSt.write(len);
            }
        } catch (IOException e) {e.printStackTrace();
        }
        // 转换为数组
        return byteSt.toByteArray();}

    public ClassLoader getExtClassLoader(){return extClassLoader;}
}

为什么要先获取 ExtClassLoader 类加载器呢？其实这里是借鉴了 Tomcat 外面的设计，是为了防止咱们自定义的类加载器笼罩了一些外围类。例如java.lang.Object。

为什么是获取 ExtClassLoader 类加载器而不是获取 AppClassLoader 呢？这是因为如果咱们获取了 AppClassLoader 进行加载，那么不还是双亲委派的规定了吗？

这里咱们应用 ScheduledThreadPoolExecutor 来进行周期性的监控文件是否批改。在程序启动的时候记录文件的最初批改工夫。随后周期性的查看文件的最初批改工夫是否改变。如果改变了那么就从新生成类加载器进行替换。这样新的文件就被加载进内存中了。

首先咱们建设一个须要监控的文件：

public class Test {public void test(){System.out.println("Hello World! Version one");
    }
}

咱们通过在程序运行时批改版本号，来动静的输入版本号。

接下来咱们建设周期性执行的工作类。

public class WatchDog implements Runnable{

    private Map<String,FileDefine> fileDefineMap;

    public WatchDog(Map<String,FileDefine> fileDefineMap){this.fileDefineMap = fileDefineMap;}

    @Override
    public void run() {File file = new File(FileDefine.WATCH_PACKAGE);
        File[] files = file.listFiles();
        for (File watchFile : files){long newTime = watchFile.lastModified();
            FileDefine fileDefine = fileDefineMap.get(watchFile.getName());
            long oldTime = fileDefine.getLastDefine();
            // 如果文件被批改了, 那么从新生成累加载器加载新文件
            if (newTime!=oldTime){fileDefine.setLastDefine(newTime);
                loadMyClass();}
        }
    }

    public void loadMyClass(){
        try {CustomClassLoader customClassLoader = new CustomClassLoader();
            Class<?> cls = customClassLoader.loadClass("com.example.watchfile.Test",false);
            Object test = cls.newInstance();
            Method method = cls.getMethod("test");
            method.invoke(test);
        }catch (Exception e){System.out.println(e);
        }
    }
}

能够看到在下面的 gif 演示图中咱们简略的实现了热加载的性能。

在下面的办法调用中咱们是应用了 getMethod() 办法来调用的。此时或者会有疑难，为什么不间接将 newInstance() 强转为 Test 类呢？

如果咱们应用了强转的话，代码会变成这样 Test test = (Test) cls.newInstance()。然而在运行的时候会抛ClassCastException 异样。这是为什么呢？因为在 Java 中确定两个类是否相等，除了看他们两个类文件是否雷同以外还会看他们的类加载器是否雷同。所以即便是同一个类文件，如果是两个不同的类加载器来加载的，那么它们的类型就是不同的。

WatchDog类是由咱们 new 进去的。所以默认是 AppClassLoader 来加载的。所以 test 变量的申明类型是 WatchDog 办法中的一个属性，所以也是由 AppClassLoader 来加载的。因而两个类不雷同。

该如何解决呢？问题就出在了 = 号单方的类不一样，那么咱们给它搞成一样不就行了吗？怎么搞？答案就是接口。默认状况下，如果咱们实现了一个接口，那么此接口个别都是以子类的加载器为主的。意思就是如果没有特殊要求的话，例如A implements B 如果 A 的加载器是自定义的。那么 B 接口的加载器也是和子类是一样的。

所以咱们要将接口的类加载器搞成是 AppClassLoader 来加载。

所以自定义加载器中退出这一句：

if ("com.example.watchfile.ITest".equals(name)){
    try {cls = getSystemClassLoader().loadClass(name);
    } catch (ClassNotFoundException e) { }
    return cls;
}

建设接口：

public interface ITest {void test();
}

这样咱们就能欢快的调用了。间接调用其办法。不会抛异样，因为 = 号单方的类是一样的。

CustomClassLoader customClassLoader = new CustomClassLoader();
Class<?> cls = customClassLoader.loadClass("com.example.watchfile.Test",false);
ITest test = (ITest) cls.newInstance();
test.test();

参考文章：

https://www.ibm.com/developer…
https://www.jianshu.com/p/d8f…

作者：不学有数的程序员 \
链接：https://www.jianshu.com/p/d8f…
近期热文举荐：

1.600+ 道 Java 面试题及答案整顿(2021 最新版)

2. 终于靠开源我的项目弄到 IntelliJ IDEA 激活码了，真香！

3. 阿里 Mock 工具正式开源，干掉市面上所有 Mock 工具！

4.Spring Cloud 2020.0.0 正式公布，全新颠覆性版本！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

关于java:牛逼自己手写一个热加载～

Java ClassLoader 简述

加载

初始化

如何实现热加载？

实现本人的类加载器

监控 class 文件

优化