如何用Java反射测试存在依赖关系的多个编译类？

架构老林

2026-6-21

问题描述

我们正在为大学课程开发一款Java编译器，需要用Java反射测试编译后的文件。之前测试单个类没问题，但现在要处理存在相互依赖的多个类：手里有两个byte[]，分别是待测试类MultipleClasses1和它依赖的MultipleClasses2的字节码，目标是生成能调用getDeclaredConstructors()等方法的Class<?>对象，但尝试的方法都失败了：

把两个类的字节码合并成一个byte[]，报错：java.lang.ClassFormatError: Extra bytes at the end of class file MultipleClasses1
只加载MultipleClasses1的字节码，抛出异常：java.lang.NoClassDefFoundError: MultipleClasses2 (wrong name: MultipleClasses1)
尝试自定义ByteClassLoader，问题仍未解决

示例代码

MultipleClasses1.java

public class MultipleClasses1 {
    MultipleClasses2 anotherClass;

    public MultipleClasses1() {
        this.anotherClass = new MultipleClasses2();
    }

    public int getIFromAnotherClass() {
        return this.anotherClass.i;
    }
}

MultipleClasses2.java

public class MultipleClasses2 {
    int i;

    public MultipleClasses2() {
        this.i = 4;
    }
}

BytecodeTestUtil.java（原错误实现）

public class BytecodeTestUtil {

    private final Class<?> clazz;
    private final Object instance;
    private static final Logger LOGGER = Logger.getLogger(BytecodeTestUtil.class.getName());

    public BytecodeTestUtil(List<String> sourceFilePaths, String className) throws Exception {
        byte[] resultBytecode = new byte[0];
        for (byte[] bytecode : Compiler.generateByteCodeArrayFromFiles(sourceFilePaths)) {
            int neededLength = resultBytecode.length + bytecode.length;
            byte[] result = new byte[neededLength];
            System.arraycopy(resultBytecode, 0, result, 0, resultBytecode.length);
            System.arraycopy(bytecode, 0, result, resultBytecode.length, bytecode.length);
            resultBytecode = result;
        }

        byte[] finalResultBytecode = resultBytecode;
        ClassLoader classLoader = new ClassLoader() {
            @Override
            protected Class<?> findClass(String name) {
                return defineClass(name, finalResultBytecode, 0, finalResultBytecode.length);
            }
        };

        try {
            clazz = classLoader.loadClass(className);
            this.instance = clazz.getDeclaredConstructor().newInstance();
        } catch (ClassNotFoundException | SecurityException | NoSuchMethodException e) {
            LOGGER.log(Level.SEVERE, "Exception occur", e);
            throw new RuntimeException(e);
        }
    }
}

ByteClassLoader.java（自定义类加载器）

public class ByteClassLoader extends ClassLoader {

    // 存储类名与对应字节码的映射
    private final Map<String, byte[]> classesBytes = new HashMap<>();

    public ByteClassLoader() {
        super(ClassLoader.getSystemClassLoader());
    }

    // 向加载器添加类字节码
    public void addClass(String name, byte[] classData) {
        classesBytes.put(name, classData);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = classesBytes.get(name);
        if (classData == null) {
            throw new ClassNotFoundException(name);
        }
        return defineClass(name, classData, 0, classData.length);
    }
}

解决方案

核心问题分析

你的ByteClassLoader本身逻辑没问题，但使用方式有误；而BytecodeTestUtil里合并字节码的做法完全错误——Java类文件是独立的，不能直接拼接成一个字节数组加载，每个类必须单独通过defineClass加载。

正确实现步骤

1. 正确使用`ByteClassLoader`

确保先将所有依赖类的字节码添加到类加载器，再加载目标类：

// 假设已获取两个类的字节码：mc1Bytecode（MultipleClasses1）、mc2Bytecode（MultipleClasses2）
ByteClassLoader classLoader = new ByteClassLoader();
// 先添加依赖类
classLoader.addClass("MultipleClasses2", mc2Bytecode);
// 再添加目标类
classLoader.addClass("MultipleClasses1", mc1Bytecode);

// 加载目标类并测试
Class<?> targetClass = classLoader.loadClass("MultipleClasses1");
Constructor<?> constructor = targetClass.getDeclaredConstructor();
Object instance = constructor.newInstance();
Method getMethod = targetClass.getMethod("getIFromAnotherClass");
int result = (int) getMethod.invoke(instance);
System.out.println(result); // 输出4，验证成功

2. 重构`BytecodeTestUtil`

彻底移除合并字节码的错误逻辑，改用ByteClassLoader管理多类字节码：

public class BytecodeTestUtil {

    private final Class<?> clazz;
    private final Object instance;
    private static final Logger LOGGER = Logger.getLogger(BytecodeTestUtil.class.getName());

    // 修改构造参数为类名-字节码的映射，确保每个类对应正确的字节码
    public BytecodeTestUtil(Map<String, byte[]> classBytecodeMap, String className) throws Exception {
        ByteClassLoader classLoader = new ByteClassLoader();
        // 批量添加所有类的字节码
        for (Map.Entry<String, byte[]> entry : classBytecodeMap.entrySet()) {
            classLoader.addClass(entry.getKey(), entry.getValue());
        }

        try {
            clazz = classLoader.loadClass(className);
            this.instance = clazz.getDeclaredConstructor().newInstance();
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException e) {
            LOGGER.log(Level.SEVERE, "Exception occur", e);
            throw new RuntimeException(e);
        }
    }

    // 若需保留从文件加载的逻辑，建议修改Compiler.generateByteCodeArrayFromFiles方法，返回Map<String, byte[]>
    // 键为类全名，值为对应字节码，避免类名和字节码不匹配的问题
}

3. 关键注意事项

类加载顺序：优先加载依赖类，或确保类加载器在解析目标类时能通过findClass找到依赖类
类名匹配：addClass传入的类名必须和字节码中的类全名完全一致（如包内类需传入com.example.MultipleClasses2）
类加载器隔离：同一个类加载器中，同一个类只能加载一次；若需重新测试编译后的类，需创建新的ByteClassLoader实例

内容的提问来源于stack exchange，提问作者user24538254

如何用Java反射测试存在依赖关系的多个编译类？

示例代码 #