Dynamically creating a subclass at runtime

Question

I'm currently developing a custom ORM framework and utilising ASM to dynamically generate sub classes at runtime. The generation process seems to complete OK, however when I try to instantiate the resulting class I'm getting a "NoClassDefFoundError".

The error seems to pertain to the Super class rather then the actual subclass. Here is an excerpt from the subclass generation method:

private Class generateProxyClass(Class anEntitySuperClass,
                                 List<Field> fieldsToIntercept) throws ClassNotFoundException{
  String entitySuperClassName = this.convertToInternalName(anEntitySuperClass.getName());
  //String entityProxySubClassName = "com/flux/dynamic/".concat(anEntitySuperClass.getSimpleName()).concat("Proxy");
  String entityProxySubClassName = anEntitySuperClass.getSimpleName().concat("Proxy");

  ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
  cw.visit(V1_6,ACC_PUBLIC+ACC_SUPER,entityProxySubClassName,null,entitySuperClassName,null);
  cw.visitSource(entityProxySubClassName.concat(".java"),null);

  //create constructor
  MethodVisitor mv = cw.visitMethod(ACC_PUBLIC,"<init>","()V",null,null);
  mv.visitCode();
  //have our consturctor initailise its super class.
  mv.visitVarInsn(ALOAD,0);
  mv.visitMethodInsn(INVOKESPECIAL,entitySuperClassName,"<init>","()V");
  mv.visitInsn(RETURN);
  mv.visitMaxs(0,0);
  mv.visitEnd();

  this.generateAndAppendProxyAccessorMethods(anEntitySuperClass,fieldsToIntercept, cw);
  cw.visitEnd();
  //at this point our class should be fully generated an include all required fields. next we
  //convert the class to a byte array and pass it in to our helper method to load an
  //actual class from the byte array.
  return this.loadProxyClass(cw.toByteArray(),entityProxySubClassName);
}

The "loadProxyClass" method called above is a helper method that basically instantiates and calls a custom ClassLoader in order to load the dynamically created class:

/**loads the generated proxy class from the provided bytes. */
private Class loadProxyClass(byte[] aGeneratedProxyClass,String proxyClassName) throws ClassNotFoundException{
  return new ProxyClassLoader(Thread.currentThread().getContextClassLoader(),aGeneratedProxyClass)
               .loadClass(this.convertToExternalName(proxyClassName));
}

The ProxyClassLoader simply extends ClassLoader and overrides the "findClass" method in order to load the Dynamically Generated class bytes:

public class ProxyClassLoader extends ClassLoader {

  private byte[] rawClassBytes;

  public ProxyClassLoader(ClassLoader parentClassLoader,byte[] classBytes){
    super(parentClassLoader);
    this.rawClassBytes = classBytes;
  }

  @Override
  public Class findClass(String name) {
    return defineClass(name,this.rawClassBytes, 0,this.rawClassBytes.length);
  }
}

The error I get is: Exception in thread "main" java.lang.NoClassDefFoundError: DummyEntity (wrong name: DummyEntityProxy)

Where the DummyEntity is the super class I pass into the generateProxyClass method and the DummyEntityProxy is the class I'm attempting to generate. I'm stumped, any help would be greatly appreciated.

Answer 1

Thank you all very much for your suggestions. After many hours of tinkering I managed to resolve the error. It appears that the error was attributed to the method:

this.generateAndAppendProxyAccessorMethods(anEntitySuperClass,fieldsToIntercept, cw);

More specifically, some of the code generated by this method incorrectly referenced the super class by its simple name rather than its internal fully qualified class name. I omitted the implementation of this method from my question for brevity and also because I genuinely didn't expect that the problem was associated with this method. Generally, when errors occur in dynamically generated byte code logic it can be immensely difficult to pinpoint the cause, simply because JVM error messages are so ambiguous.

Answer 2

The problem is revealed by your exception's message:

Exception in thread "main" java.lang.NoClassDefFoundError: DummyEntity (wrong name: DummyEntityProxy)

Your class loader expected to load a class DummyEntity but the linked resource contained a class named DummyEntityProxy. How could that happen? It is your class loader's findClass method's implementation:

@Override
public Class findClass(String name) {
  return defineClass(name, this.rawClassBytes, 0, this.rawClassBytes.length);
}

You do not distinguish what class is attempted to be loaded but you define any class of name with the only class it knows, the DummyEntityProxy's byte representation. Rather implement:

@Override
public Class findClass(String name) {
  if (!name.equals(entityProxySubClassName)) {
    throw new ClassNotFoundException(name);
  }
  return defineClass(name, this.rawClassBytes, 0, this.rawClassBytes.length);
}

This way, you are making sure that you are not defining a class of another name. It seems however as if the ProxyClassLoader should not be queried for the class in the first place but that one of its parents should have successfully resolved it.

It seems like ASM is quite a low-level API for your needs. Have you considered a more high-level API like for example my library Byte Buddy? Other ORMs like Hibernate or Eclipse link also use an API on that level, simply because the things you are struggling with are difficult to get right.

Answer 3

Generally, it isn’t a good idea to implement a ClassLoader that tries to return the same class regardless of what it has been asked for. This is perfectly illustrated by the error you get: NoClassDefFoundError: DummyEntity (wrong name: DummyEntityProxy). The system asked your ClassLoader for a class named DummyEntity and you returned a class named DummyEntityProxy.

The remaining question is why your loader has been asked for that class as usually the parent loader is asked first. It seems that the parent loader has not found the super class which indicates that the parent class loader you have used (Thread.currentThread().getContextClassLoader()) has no access to your super class. It would have been easier if you used anEntitySuperClass.getClassLoader() as parent loader.

Of course, you have to ensure that all other classes used by your generated proxy are accessible by anEntitySuperClass’s class loader. If not, you might need a very complex loader delegation structure to make both group of classes available. It might even be impossible (that depends on what your proxy actually ought to do).