当我将类注入到SystemClassLoader中时，如何确定类的加载顺序？

Question

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

我不想传递VM参数，所以我不能更改SystemClassLoader。但是，我可以通过使用反射将ClassLoader.defineClass(String, byte[], int, int)设置为公共的，用我的类强制填充它。

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;
}

到目前为止，它在我遇到的每一种情况下都很好用。

Answer 2

使用instance of检查对象是否属于类。

if (aAnimal instanceof Fish){
      Fish fish = (Fish)aAnimal;
      fish.swim();
    }
    else if (aAnimal instanceof Spider){
      Spider spider = (Spider)aAnimal;
      spider.crawl();
    }