java - 当我将它们注入(inject) SystemClassLoader 时，如何确定类加载顺序？

Question

对于我的检测工具，我想提供一个包装类加载器，用于在特定类被检测后启动一个主要方法。我的 ClassLoader 应该加载某些类的检测版本。但对于 Jetty 和 JUnit，这种方法受到严重限制，因为它们构建了自己的类加载层次结构。

我不想传递 VM 参数，所以我无法更改 SystemClassLoader。但是我可以通过使用反射将 ClassLoader.defineClass(String, byte[], int, int) 设为 public 来强制为它提供我的类。

ClassLoader scl = ClassLoader.getSystemClassLoader();
Method defineClass = ClassLoader.class.getDeclaredMethod(
        "defineClass", String.class, byte[].class, int.class, int.class);
defineClass.setAccessible(true);
for (String binaryName : classNamesToLoad) {
    byte[] bytecode = this.declaredClasses.get(binaryName);
    defineClass.invoke(scl, binaryName, bytecode, 0, bytecode.length);
}
defineClass.setAccessible(false);

这太棒了——但还有一个问题:如果我的一些类继承自或包含其他类，它们必须以正确的顺序加载，因为 SystemClassLoader 加载当前类依赖的所有类——并且会加载未检测的版本。

这是一个示例，其中包含一些(命名不当的)类以及它们必须加载的顺序:

A
A.A extends B.A
B
B.A extends B.C
B.C

必须按顺序加载

B
B.C
B.A
A
A.A

如果我只想加载经过检测的版本。

有没有简单的出路 - 例如我还没有发现的“setSystemClassLoader”方法？

我不需要操纵 SystemClassLoader 的解决方法？

或者我真的必须从我想要加载的类开始进行完整的传递依赖分析以确定正确的顺序(在这种情况下:是否有任何我可以使用的“现有技术”)？

谢谢!

Answer 1

看起来没有办法绕过传递依赖分析。

我是这样解决的，我真的希望有人能从这个实现中获益:

import java.io.IOException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.objectweb.asm.ClassReader;
import org.objectweb.asm.tree.ClassNode;

public class DependencyDetector {

    private static class Node implements Comparable<Node> {
        private final String binaryName;
        private final Node[] imports;
        private final int score;

        private Node(String binaryName, Node...imports) {
            this.binaryName = binaryName;
            this.imports = imports;
            this.score = calculateScore(imports);
        }

        public int compareTo(Node o) {
            return score - o.score;
        }

        private int calculateScore(Node...imports) {
            int newScore = 0;
            for (Node n : imports) {
                if (n.score >= newScore) {
                    newScore = n.score + 1;
                }
            }
            return newScore;
        }
    }

    private Map<String, Node> nodes = new HashMap<String, Node>();

    public DependencyDetector add(ClassNode node) {
        Node n = nodes.get(node.name);
        if (n == null) {
            n = createNode(node);
        }
        return this;
    }

    private Node createNode(ClassNode node) {
        String binaryName = node.name;
        String[] importNames = extractImportedBinaryNames(node);
        Node[] imports = new Node[importNames.length];
        for (int i = 0; i < imports.length; i++) {
            String importName = importNames[i];
            Node imp = nodes.get(importName);
            if (imp == null) {
                ClassNode cn = new ClassNode();
                String path = importName.replace('.', '/') + ".class";
                try {
                    new ClassReader(
                            ClassLoader.getSystemResourceAsStream(path)
                        ).accept(cn, ClassReader.SKIP_CODE);
                } catch (IOException e) {
                    throw new RuntimeException(
                        "could not read class " + importName);
                }
                imp = createNode(cn);
                nodes.put(importName, imp);
            }
            imports[i] = imp;
        }
        Node result = new Node(binaryName, imports);
        nodes.put(binaryName, result);
        return result;
    }

    private String[] extractImportedBinaryNames(ClassNode node) {
        String binaryName = node.name;
        ArrayList<String> nodesToAdd = new ArrayList<String>();
        int endOfOuter = binaryName.lastIndexOf('$');
        if (endOfOuter >= 0) {
            nodesToAdd.add(binaryName.substring(0, endOfOuter));
        }
        if (node.superName != null) {
            nodesToAdd.add(node.superName);
        }
        if (node.interfaces != null) {
            for (String interf : (List<String>) node.interfaces) {
                if (interf != null) {
                    nodesToAdd.add(interf);
                }
            }
        }
        return nodesToAdd.toArray(new String[nodesToAdd.size()]);
    }

    public String[] getClassesToLoad(String...binaryNames) {
        String[] classNames = binaryNames != null && binaryNames.length > 0
                ? binaryNames.clone()
                : nodes.keySet().toArray(new String[nodes.size()]);
        ArrayDeque<Node> dependencyQueue = new ArrayDeque<Node>();
        for (String className : classNames) {
            Node node = nodes.get(className.replace('.', '/'));
            dependencyQueue.add(node);
            if (node == null) {
                throw new RuntimeException(
                    "Class " + className + " was not registered");
            }
        }
        HashMap<String, Node> dependencyMap = new HashMap<String, Node>();
        while (!dependencyQueue.isEmpty()) {
            Node node = dependencyQueue.removeFirst();
            dependencyMap.put(node.binaryName, node);
            for (Node i : node.imports) {
                dependencyQueue.addLast(i);
            }
        }
        ArrayList<Node> usedNodes =
            new ArrayList<Node>(dependencyMap.values());
        Collections.sort(usedNodes);
        String[] result = new String[usedNodes.size()];
        int i = 0;
        for (Node n : usedNodes) {
            result[i++] = n.binaryName.replace('/', '.');
        }
        return result;
    }

    public boolean contains(String binaryName) {
        return nodes.containsKey(binaryName.replace('.', '/'));
    }
}

它是这样使用的:在 DependencyDetector 上，您调用 add(ClassNode) 来添加一个 ClassNode 及其所有依赖项(所有类它扩展或实现或包含于)。当您完成依赖关系树的构建时，您调用 getClassesToLoad() 以将所有依赖关系检索为 String[]，其中包含按必要顺序排列的二进制名称。您也可以通过将二进制名称指定为 getClassesToLoad(...) 的参数来仅请求所有添加类及其依赖项的子集。

现在，当我检测类时，我还将 ClassNode 添加到 DependencyDetector 并且可以检索我需要的所有内容并将其传递到这样的方法中:

/**
 * load the specified classes (or all instrumented classes)
 * and all their dependencies with the specified ClassLoader.
 * @param loader
 * @param binaryNames binary names of all classes you want to load
 *        - none loads all instrumented classes
 */
public void loadIntoClassLoader(ClassLoader loader, String...binaryNames) {
    final String[] classNamesToLoad =
        dependencies.getClassesToLoad(binaryNames);
    Method defineClass = null;
    Method findLoadedClass = null;
    try {
        // crack ClassLoader wide open and force-feed it with our classes
        defineClass = ClassLoader.class.getDeclaredMethod(
                "defineClass", String.class, byte[].class,
                int.class, int.class);
        defineClass.setAccessible(true);
        findLoadedClass = ClassLoader.class.getDeclaredMethod(
                "findLoadedClass", String.class);
        findLoadedClass.setAccessible(true);
        for (String binaryName : classNamesToLoad) {
            if (!binaryName.startsWith("java.")) {
                if (findLoadedClass.invoke(loader, binaryName) == null) {
                    byte[] bytecode = getBytecode(binaryName);
                    defineClass.invoke(loader, binaryName, bytecode,
                        0, bytecode.length);
                } else if (declaredClasses.containsKey(binaryName)) {
                    throw new RuntimeException(
                        "Class " + binaryName + " was already loaded, " +
                        "it must not be redeclared");
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(
            "could not load classes into ClassLoader", e);
    } finally {
        rehideMethod(findLoadedClass);
        rehideMethod(defineClass);
    }
}

private void rehideMethod(Method m) {
    if (m != null) {
        try {
            m.setAccessible(false);
        } catch (Exception e) {
        }
    }
}

依赖于

private final DependencyDetector dependencies = new DependencyDetector();
private final Map<String, byte[]> declaredClasses = new HashMap<String, byte[]>();

private byte[] getBytecode(String binaryName) {
    byte[] bytecode = declaredClasses.get(binaryName);
    if (bytecode == null) {
        // asBytes loads the class as byte[]
        bytecode =
            asBytes(binaryName.replace('.', '/') + ".class");
    }
    return bytecode;
}

差不多就是这样，它在我目前遇到的每种情况下都非常有效。