Defining the same class twice using a ClassLoader

Question

I am working a project which involves reading all of the classes in a given JAR file, modifying some of these classes (at the bytecode level, using ASM ), and creating a ClassLoader of these modified classes. Currently, after modifying the classes, I create a custom instance of the ClassLoader class which makes defineMethod(String, byte[]) visible.

Here is the code for the custom ClassLoader (it is a nested class):

private static class ExposingClassLoader extends ClassLoader {

    private ExposingClassLoader(JarFile jar) throws MalformedURLException {
        super(new URLClassLoader(new URL[] { new URL("jar:" + new File(jar.getName()).toURI().toURL() + "!/") }));
    }

    private void defineClass(String name, byte[] data) {
        defineClass(name, data, 0, data.length);
    }
}

You may have noticed that I made the parent class loader a URLClassLoader . When I construct the custom class loader, I make the URLClassLoader refer to the JAR that contains the unmodified class files. After modification of some of the class files, I iterate through them and invoke defineMethod(String, byte[]) for each one. Some of the modified classes depend on each other, that is, class A may be the superclass of class B, or class C may implement class D, or class E may contain references to class F, et cetera .

For my tests, I am using two classes. The first is named fn and the second is named fi , and fi extends fn and contains multiple fields of type fi . Both of these classes are present in the JAR file that is used to construct the ClassLoader , the only difference is that they are unmodified. For some reason, if I define class fn it works fine (which it should not? The class fn already exists in the JAR file). However, if I try to define fi , which, again, refers to fn multiple times, I get this exception:

Exception in thread "main" java.lang.LinkageError: loader (instance of Injector$ExposingClassLoader): attempted  duplicate class definition for name: "fn"

On the line:

defineClass(name, data, 0, data.length);

And I am not sure how to deal with this. The easiest way to do this would be to "unload" the classes that are contained in the JAR, but only those that I have modified. That way, when I define my modified classes, they will not already be loaded in the ClassLoader . However, I have looked around and I have yet to find a clean way to do it. Some have said that I need separate (multiple) class loaders, and that would not work for my project unless there was a way to perhaps combine these multiple class loaders into one, like a wrapper.

How can I redefine a class in a ClassLoader ?

Answer 1

I found the solution to my problem. Basically, rather than overriding the behavior of defineClass I should have overriden findClass . Here is the code that works.

public class ModifiableClassLoader extends ClassLoader {

    private final Map<String, byte[]> definitions;

    public ModifiableClassLoader(JarFile jar, Map<String, byte[]> definitions) throws MalformedURLException {
        super(new URLClassLoader(new URL[] { new URL("jar:" + new File(jar.getName()).toURI().toURL() + "!/") }));
        this.definitions = definitions;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classBytes = definitions.remove(name);
        if (classBytes != null) {
            return defineClass(name, classBytes, 0, classBytes.length);
        }
        return super.findClass(name);
    }
}

It wrote it based on an answer to another Stack Overflow question which I cannot find right now. I must have overlooked it before.