Java中的递归类加载器

Question

我需要定义一个ClassLoader，它可以从它们各自的类文件中动态地重新加载某些类。原因是类在运行时开始后发生了变化。

目前我有一个类加载器，可以从其文件中加载一个类。我需要进一步加载这个类所依赖的所有类，并且这些类都在更改的类列表中。

简单解释，我有一个ClassLoader 类，它覆盖loadClass 方法以在所需的类在列表中时加载更改的类文件。否则，它使用默认（父）类加载器加载类。

是否也可以使用相同的类加载器从主要加载的类（重新）加载类定义中的类？

所以，一个简单的例子

Class A {
    static method() {
        B b = new B();
        C c = new C();
        // do something with B and C
    }
}
Class B {
    public X x = new X();
}

当我用MyCustomClassLoader 加载类A 时，我给它一个类列表，其中包含A 和C f.e.因为我知道这些类的类文件（bin/A.class）已更改。因此，它应该从类A 手动加载文件，并且在加载B 和C 时，它应该检查它们是否在更改的类列表中。当它们不是时，可以使用默认的类加载器加载它们，否则它将与 A 一样，递归地（因此还要检查 B 所依赖的类）。

我可以从文件加载，但没有递归。我也知道此方法不会全局覆盖 Java new 运算符。但我只需要运行一个更改的类，但它的依赖项也发生了变化。

编辑： 请注意，使用Instrumentation 无法实现这一点。它的文档引用了以下内容，包括retransformClasses() 和redefineClasses()。

重新转换可能会改变方法体、常量池和属性。重新转换不得添加、删除或重命名字段或方法，更改方法的签名或更改继承。这些限制可能会在未来的版本中取消。

所以我做了一个工作代理来更改方法体，但只有当我注意到它在方法创建或删除时崩溃时，我才发现了这段文字。

Answer 1

我终于让它工作了。我做了以下课程：

我相信这里的关键是resolveClass() 方法。虽然文档没有提供任何有用的信息，但我相信这种方法可以确保在加载一个类之后，所有使用的类也会被加载。

每次更改的班级再次更改或新班级更改时，您都需要创建一个新班级。

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Set;

/**
 * This class provides dynamic loading in the sense that the given class and 
 * other changed classes are loaded from disk, not from cache.
 * Ensures most recent version is used for those classes.
 */
public class DynamicClassLoader extends ClassLoader{

    private Set<String> classes;

    public DynamicClassLoader(Set<String> changedClasses) {
        this.classes = changedClasses;
    }

    /**
     * Dynamically loads the class from it's binary file. 
     * Classes this class depends on will only be loaded dynamically when 
     * they are in list of changed classes given at construction.
     * @throws ClassNotFoundException 
     */
    public Class<?> dynamicallyLoadClass(String name) 
        throws ClassNotFoundException {
        classes.add(name);
        return loadClass(name);
    }

    /**
     * Finds the class dynamically, contrary to Class.forname which can use 
     * cached copies.
     * This means it forces a reload of the class data.
     * Source: http://stackoverflow.com/questions/3971534/
     */
    @Override
    protected Class<?> findClass(String s) throws ClassNotFoundException {
        try {
            byte[] bytes;
            bytes = loadClassData(s);
            return defineClass(s, bytes, 0, bytes.length);
        } catch (IOException e) {
            e.printStackTrace();
            throw new ClassNotFoundException();
        }
    }

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException{
        return loadClass(name, true);
    }

    /**
     * Overridden to not check the parent's loadClass method first.
     */
    @Override
    protected Class<?> loadClass(String name, boolean resolve) 
        throws ClassNotFoundException {
        Class<?> clazz = findLoadedClass(name);
        if(clazz != null)
            return clazz;

        if(classes.contains(name)) {
            clazz = findClass(name);
            resolveClass(clazz);
            return clazz;
        }
        return super.loadClass(name, resolve);
    }

    /**
     * Load class data from byte code.
     * 
     * @param className
     * @return
     * @throws IOException
     */
    protected byte[] loadClassData(String className) throws IOException {
        File f = new File("bin/" 
            + className.replaceAll("\\.", "/") + ".class");
        int size = (int) f.length();
        byte buff[] = new byte[size];
        FileInputStream fis = new FileInputStream(f);
        DataInputStream dis = new DataInputStream(fis);
        dis.readFully(buff);
        dis.close();
        return buff;
    }
}

Answer 2

我强烈建议您使用java.lang.instrument 来完成您想要完成的任务，而不是使用类加载器。具体来说，通过实现ClassFileTransformer 接口，注册代理，并使用注册期间传递给代理的Instrumentation 实例的redefineClasses() 和/或retransformClasses() 方法。

请注意，当您重新定义一个类时，之前的类定义的现有实例不会受到影响。无论使用自定义 ClassLoaders 还是检测工具，都无法解决这个问题。

This page in particular 你会发现关于如何使用仪器来完成你想做的事情的信息非常丰富。