Wie man eine Java-Unterklasse mit Generics dynamisch erzeugt

Question

Ich habe eine Klasse, die ich eine Unterklasse dynamisch generieren und die richtige generische on-the-fly hinzufügen möchte. Zum Beispiel, hier ist eine Basisklasse, die ich erweitern möchte.

public class Foo<A> { 

    private A attribute; 

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

    public A getAttribute() { 
      return attribute; 
    } 
} 

Ich möchte dynamisch eine Unterklasse wie diese erzeugen, die mit einer bestimmten Art in der „generic“ A-Wert füllt, sagen wir mal ‚Dog‘ für dieses Beispiel.

public class SubClassOfFoo extends Foo<Dog> { 

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

Ich habe CGLib angeschaut, aber ich sehe nicht, wie man einen "generischen" Typ erweitert und hinzufügt. Fehle ich etwas in CGLib oder gibt es eine andere Bibliothek mit dieser Funktion?

Answer 1

Ich mag eine Unterklasse wie diese dynamisch erzeugen, die dynamisch Sie zur Laufzeit bedeuten erzeugen

Wenn für mit einer bestimmten Art in dem „generic“ A-Wert erfüllt. Du kannst es nicht tun.

Generics in Java sind zur Laufzeit nicht vorhanden. Sie sind einfach kompilierbarer syntaktischer Zucker.

Answer 2

Mit der Bytecode-Generierung ist alles möglich, was mit Java-Code möglich ist.

Ich bin nicht so vertraut mit Cglib, aber hier ist ein Asm-Code, der tun wird, was Sie gefragt haben.

Der einzige spezielle Teil bezogen auf Generics es die genericSig() Methode, die "eine zweite Signatur" für die Oberklasse neben der Rohform Type.getInternalName(Foo.class) definiert.

Dies ist keine allgemeine Lösung, es erstellt den Bytecode für das Beispiel in der Frage. Für die allgemeine Lösung müssen viele andere Dinge berücksichtigt werden, insbesondere Brückenmethoden.

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

Answer 3

cglib ist eine sehr alte Bibliothek und erstellt wurde, bevor Generika noch diskutiert. Daher wird das Hinzufügen generischer Signaturen mit der Bibliothek nicht unterstützt, es sei denn, Sie registrieren einen ASM-Besucher und fügen die Signatur manuell hinzu. Dies fügt jedoch nicht die geeigneten Bridge-Methoden hinzu, wenn Sie diese benötigen.

Wenn Sie generische Klassen erstellen möchten, können Sie einen Blick auf Byte Buddy haben (was ich geschaffen, habe ich auch nebenbei halten cglib), die für alle ihre Operationen Java generische Typ System nimmt und fügt transparent alle Brücken ebenso wie Javac würde tun. Sie können die Beispielklasse mit Byte Buddy wie folgt erstellen:

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

können Sie nun den generischen Typ der erzeugten Unterklasse überprüfen:

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