自定义类加载实现

最新推荐文章于 2024-05-22 18:18:00 发布

小怪兽你干啥

最新推荐文章于 2024-05-22 18:18:00 发布

阅读量468

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/zyq1084577627/article/details/105710844

版权

java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Java 热加载与热部署

什么是热加载
热加载与热部署的区别
类加载五个阶段
实现类的热加载
自定义类加载器

什么是热加载

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

热加载与热部署的区别

首先，不管是热加载还是热部署，都可以在不重启服务的情况下编译/部署项目，都是基于 Java 的类加载器实现的。
那么两者到底有什么区别呢？

在部署方式上：

热部署是在服务器运行时重新部署项目。
热加载是在运行时重新加载 class。
在实现原理上：
热部署是直接重新加载整个应用，耗时相对较高。
热加载是在运行时重新加载 class，后台会启动一个线程不断检测你的类是否改变。

在使用场景上：

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

类加载五个阶段

在这里插入图片描述
简单描述一下类加载的五个阶段：

加载阶段：找到类的静态存储结构，加载到虚拟机，定义数据结构。用户可以自定义类加载器。
验证阶段：确保字节码是安全的，确保不会对虚拟机的安全造成危害。
准备阶段：确定内存布局，确定内存遍历，赋初始值（注意：是初始值，也有特殊情况）。
解析阶段：将符号变成直接引用。
初始化阶段：调用程序自定义的代码。规定有且仅有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 来处理的。

实现类的热加载

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

自定义类加载器

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

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

public class MyClassLoader extends ClassLoader {

    private String classpath;

    public MyClassLoader( String classPath) {
        super(ClassLoader.getSystemClassLoader());
        this.classpath = classPath;
    }

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

    private byte[] loadClassData(String name) {
        try {
            // 传进来是带包名的
            name = name.replace(".", "//");
            FileInputStream inputStream = new FileInputStream(new File(classpath + name + ".class"));
            // 定义字节数组输出流
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            int b = 0;
            while ((b = inputStream.read()) != -1) {
                byteArrayOutputStream.write(b);
            }
            inputStream.close();
            return byteArrayOutputStream.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

自定义要热加载的接口

public interface BaseManager {
    public void logic();
}

定义要实现的接口

public class MyManager implements BaseManager {
    @Override
    public void logic() {
        System.out.println(LocalTime.now() + ": Java类的热加载 66666");
    }
}

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

@Data
public class LoadInfo {
    private MyClassLoader myClassLoader;
    private long loadTime;
    private BaseManager 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 = "H:\\study\\eureka-server\\target\\classes\\";
    /**
     * 实现热加载的类的全名称(包名+类名 )
     */
    public static final String MY_MANAGER = "com.example.eureka.server.test.MyManager";
    public static BaseManager getBaseManager(String className) {
        File loadFile = new File(CLASS_PATH + className.replaceAll("\\.", "/") + ".class");
        long lastModified = loadFile.lastModified();
        System.out.println("当前的类时间：" + lastModified);
        if (loadTimeMap.get(className) == null) {
            load(className, lastModified);
        } // 加载类的时间戳变化了，我们同样要重新加载这个类到 JVM。
        else if (loadTimeMap.get(className).getLoadTime() != lastModified) {
            load(className, lastModified);
        }
        return loadTimeMap.get(className).getManager();
    }

    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();
        }
        BaseManager manager = newInstance(loadClass);
        LoadInfo loadInfo = new LoadInfo(myClassLoader, lastModified);
        loadInfo.setManager(manager);
        loadTimeMap.put(className, loadInfo);
    }

    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 (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }
}

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

public class TestClassLoad {
    public static void main(String[] args) {
        new Thread(() -> handler()).start();
    }
    private static void handler() {
        while (true) {
            BaseManager manager = ManagerFactory.getBaseManager(ManagerFactory.MY_MANAGER);
            manager.logic();
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

启动后查看控制台，修改类实现可以看到加载后的效果。
在这里插入图片描述
参考整理自：Java 热加载

小怪兽你干啥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
自定义类加载实现

Java 热加载与热部署什么是热加载热加载与热部署的区别类加载五个阶段实现类的热加载自定义类加载器什么是热加载热加载是指可以在不重启服务的情况下让更改的代码生效，热加载可以显著的提升开发以及调试的效率，它是基于 Java 的类加载器实现的，但是由于热加载的不安全性，一般不会用于正式的生产环境。热加载与热部署的区别首先，不管是热加载还是热部署，都可以在不重启服务的情况下编译/部署项目，都是基...
复制链接

扫一扫

专栏目录