假设我有一个抽象类：
abstract class Foo extends Bar {
public abstract int foo();
}
我想在运行时扩展以创建一个Class对象。希望是我可以拥有一个动态生成的类：
class FooImpl extends Foo {
@Override
public int foo() {
return 5;
}
}
将由Class对象表示，然后我可以使用反射来创建新的实例。关键是我想在运行时决定方法foo（）的返回值。我的想法是使用ASM为类创建字节码，然后在ClassLoader对象上使用反射来定义类。
使用ASM然后在生成的字节上反映方法ClassLoader＃defineClass是在运行时使用非硬编码值实现抽象方法的最佳方法吗？
如果是，我将如何做到这一点。我的直觉是利用ASMifierClassVisitor，但我不确定这样做的确切方法。我知道如果所有其他方法都失败了，我可以手动完成定义特定类所需的JVM指令，但我觉得必须有一个更简单的方法。
如果不是，最好的方法是什么，我将如何使用最佳方式？
编辑：我检查了所有的答案，我认为它们都不是我想要的。我最终创建了一个与ASM谈论的小实现。我想我应该在这里张贴：import org.objectweb.asm.*;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
/**
* Created by IntelliJ IDEA.
* User: Matt
* Date: 9/17/11
* Time: 12:42 PM
*/
public class OverrideClassAdapter extends ClassAdapter {
private final HashMap<String, Object> code;
private final String className;
private final ClassWriter writer;
private String superName;
public OverrideClassAdapter(ClassWriter writer, String className, Queue<int[]> constructorCode, HashMap<String, Object> code) {
super(writer);
this.writer = writer;
this.className = className;
this.code = code;
}
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
this.superName = name;
if((access & Opcodes.ACC_ABSTRACT) != 0)
access &= ~Opcodes.ACC_ABSTRACT;
if((access & Opcodes.ACC_INTERFACE) != 0)
access &= ~Opcodes.ACC_INTERFACE;
cv.visit(version, access, className, signature, name, null);
}
@Override
public void visitSource(String source, String debug) {
}
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
boolean isAbstract = (access & Opcodes.ACC_ABSTRACT) != 0;
if(isAbstract)
access &= ~Opcodes.ACC_ABSTRACT;
MethodWriter mw = (MethodWriter) cv.visitMethod(access, name, desc, signature, exceptions);
Object value = code.get(name);
if(isAbstract || value != null) {
if(value instanceof BytecodeValue) {
BytecodeValue returnableValue = (BytecodeValue) value;
int[] byteCode = new int[returnableValue.getValueCode().length + 1];
System.arraycopy(returnableValue.getValueCode(), 0, byteCode, 0, returnableValue.getValueCode().length);
if(returnableValue.getValueCode().length > 1 && returnableValue.getValueCode()[1] == 0) {
byteCode[1] = writer.newConst(returnableValue.getValue());
}
byteCode[byteCode.length - 1] = returnableValue.getReturnCode();
value = byteCode;
}
return new OverrideMethodAdapter(mw, (int[]) value);
}
return mw;
}
private class OverrideMethodAdapter extends MethodAdapter {
private final int[] code;
private final MethodWriter writer;
public OverrideMethodAdapter(MethodWriter writer, int[] code) {
super(writer);
this.writer = writer;
this.code = code;
}
@Override
public void visitEnd() {
try {
Field code = MethodWriter.class.getDeclaredField("code");
code.setAccessible(true);
ByteVector bytes = new ByteVector();
for(int b : this.code)
bytes.putByte(b);
code.set(writer, bytes);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static byte[] extendClassBytes(Class clazz, String className, HashMap<String, Object> methodImpls) throws IOException {
ClassReader cr = new ClassReader(clazz.getName());
ClassWriter cw = new ClassWriter(0);
cr.accept(new OverrideClassAdapter(cw, className, methodImpls), ClassReader.SKIP_DEBUG);
cr = new ClassReader(cw.toByteArray());
cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
cr.accept(cw, ClassReader.SKIP_DEBUG);
//CheckClassAdapter.verify(new org.objectweb.asm.ClassReader(cw.toByteArray()), true, new PrintWriter(System.out));
/*File file = new File(className + ".class");
new FileOutputStream(file).write(cw.toByteArray());*/
return cw.toByteArray();
}
public static Class extendClass(Class clazz, String className, HashMap<String, Object> methodImpls) throws IOException {
return defineClass(extendClassBytes(clazz, className, methodImpls), className);
}
public static Class defineClass(byte[] code, String name) {
try {
Method method = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);
method.setAccessible(true);
return (Class) method.invoke(Thread.currentThread().getContextClassLoader(), name, code, 0, code.length);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
答案 0 :(得分：5)
您可能希望查看使用CGLib。它可以做Java的动态代理可以做的事情，但是对于抽象类和接口，它也有类似于java.lang.reflect.Proxy的API，用于执行此操作。 CGLib无论如何都在幕后使用ASM，但是通过使用CGLib，你不必直接制作字节码。
以下是如何使用CGLib执行此操作的示例：
package cglibtest;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CGLibTest
{
public static void main(String... args)
{
MyAbstract instance = (MyAbstract)Enhancer.create(MyAbstract.class, new MyInterceptor(42));
System.out.println("Value from instance: " + instance.valueMethod());
}
public static class MyInterceptor implements MethodInterceptor
{
private final Object constantValue;
public MyInterceptor(Object constantValue)
{
this.constantValue = constantValue;
}
@Override
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable
{
if ("valueMethod".equals(method.getName()))
return(constantValue);
else
return(null);
}
}
public static abstract class MyAbstract
{
public abstract int valueMethod();
}
}
答案 1 :(得分：1)
什么阻止你从属性中读取值5并将其返回？这太简单了，我猜你必须要有一些比你想要在这里完成的int更复杂的东西。我同意上面的帖子，在运行时生成类会非常昂贵。如果事先了解业务逻辑，则可以应用Factory模式在运行时加载所需的已定义接口实现。这就是JDBC库的工作方式。
如果您事先并不了解业务逻辑并且有大量的业务逻辑，那么您可以使用现成的Rule Engine处理逻辑并将结果返回给Java程序。如果经常更改，则更容易在规则引擎中维护此逻辑。
答案 2 :(得分：0)
是的，这种方法应该有效。但如果你做了很多一代人的话会很贵。 （我们可能正在谈论成千上万的指令来生成字节码文件，然后加载它。然后在加载时需要代表类的内存。）
另一种方法（也很昂贵）是生成源代码并在运行时编译和加载它。
最后，您应该考虑使用表格驱动对象的逻辑或使用某种解释器实现它的方法。如果您实际上需要拥有不同的类，您可以使用Java的动态代理类机制将其包装起来;例如见java.lang.reflect.Proxy