How to dynamically generate a Java subclass with generics

Question

I have a class that I want to dynamically generate a subclass from and add the proper generic on-the-fly. For example, here is a base class I'd want to extend.

public class Foo<A> {

     private A attribute;

     // constructor
     public Foo(A value) {
         this.attribute = value;
     }

     public A getAttribute() {
          return attribute;
     }
}

I want to dynamically generate a subclass like this, which fills in the "generic" A value with a specified type, lets say 'Dog' for this example.

public class SubClassOfFoo extends Foo<Dog> {

         public SubClassOfFoo(Dog dog) {
              super(dog);
         }
}

I have looked at CGLib but I don't see how to extend and add a "Generic" type to it. Am I missing something in CGLib or is there another library capable of this feature?

Answer 1

cglib is a very old library and was created before generics were even discussed. Therefore, there is no support for adding generic signatures using the library unless you register an ASM visitor and add the signature manually. Doing so does however not add the appropriate bridge methods if you require those.

If you want to create generic classes, you can have a look at Byte Buddy (which I created, I also casually maintain cglib), which adopts Java's generic type system for all of its operations and transparently adds all bridges just as javac would do. You can create the example class with Byte Buddy as follows:

Class<?> subclass = new ByteBuddy()
  .subclass(TypeDescription.Generic.Builder.parameterizedType(Foo.class, Dog.class)
                                           .build())
  .make()
  .load(Foo.class.getClassLoader())
  .getLoaded();

You can now check the generic type of the generated subclass:

Type type = subclass.getGenericSuperclass();
assert type instanceof ParameterizedType;
assert ((ParameterizedType) type)).getRawType() == Foo.class;
assert ((ParameterizedType) type).getActualTypeArguments()[0] == Dog.class;

Answer 2

I want to dynamically generate a subclass like this which fills in the "generic" A value with a specified type

If for dynamically generate you mean at runtime. You can't do it.

Generics in Java do not exist at runtime. They are simply compile-time syntactic sugar.

Answer 3

All things possible with Java code are possible with bytecode generation.

I'm not that familiar with cglib, but here is some asm code that will do what you asked for.

The only special part related to generics it the genericSig() method that defines "a second signature" for the superclass besides the rawform Type.getInternalName(Foo.class).

This is not an general solution, it creates the bytecode for the example in the question. For the general solution many other things need to be considered, especially bridge methods.

import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.signature.SignatureVisitor;
import org.objectweb.asm.signature.SignatureWriter;



public class GenExtendFoo {
    public static void main(String[] args) throws Exception {
        ClassWriter cw = new ClassWriter(0);
        /** Extend Foo with normal raw superclass "com/Foo"
            And generic superclass genericSig() Lcom/Foo<Ljava/lang/Integer;>;
        **/
        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "SubClass", genericSig(Foo.class, Integer.class),
            Type.getInternalName(Foo.class), new String[] {});
        createConstructor(cw);
        cw.visitEnd();

        byte[] b = cw.toByteArray();
        Class<?> cls = (Class<?>) new MyClassLoader().defineClass("SubClass", b);

        Foo<Integer> instance = (Foo<Integer>) cls.getConstructor(Integer.class).newInstance(1);
        System.out.println(instance.getValue());

        /* The generic type is available with GenericSuperclass just like in the plain java version */
        ParameterizedType para = (ParameterizedType) instance.getClass().getGenericSuperclass();
        System.out.println(para.getActualTypeArguments()[0]);
    }

    private static void createConstructor(ClassWriter cw) {
        // Create constructor with one parameter that calls superclass
        // constructor with one parameter
        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>",
            "(L" + Type.getInternalName(Integer.class) + ";)V", null, null);
        mv.visitMaxs(2, 2);
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitVarInsn(Opcodes.ALOAD, 1);
        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(Foo.class), "<init>",
            "(L" + Type.getInternalName(Object.class) + ";)V", false); // call
        mv.visitInsn(Opcodes.RETURN);

        mv.visitEnd();
    }

    public static String genericSig(Class<?> mainType, Class<?> typeParameter) {
        SignatureVisitor sv = new SignatureWriter();
        SignatureVisitor psv = sv.visitSuperclass();
        psv.visitClassType(Type.getInternalName(mainType));
        SignatureVisitor ppsv = psv.visitTypeArgument('=');
        ppsv.visitClassType(Type.getInternalName(typeParameter));
        ppsv.visitEnd();
        psv.visitEnd();
        return sv.toString();
    }
}
static class MyClassLoader extends ClassLoader {
    public Class<?> defineClass(String name, byte[] b) {
        return defineClass(name, b, 0, b.length);
    }
}