[英]Implementing abstract methods at runtime?
假设我有一个抽象类:
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;
}
}
}
您可能想看看使用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();
}
}
是什么让您无法从属性中读取值5并将其返回? 太简单了,我想您必须比返回要在此处完成的int更为复杂。 我同意上面的文章,在运行时生成类非常昂贵。 如果您事先了解业务逻辑,则可以应用Factory模式在运行时加载定义的接口的所需实现。 JDBC库就是这样工作的。
如果您事先不了解业务逻辑并且有很多业务逻辑,则可能会受益于使用现成的规则引擎来处理逻辑并将结果返回给Java程序。 特别是如果它经常更改,则在规则引擎中维护此逻辑要容易得多。
是的,这种方法应该可行。 但是,如果您要进行大量的类生成,这将是昂贵的。 (我们可能正在谈论成千上万的指令,用于生成字节码文件然后将其加载。然后,在加载该类时需要内存来表示该类。)
另一种方法(也很昂贵)是生成源代码,并在运行时对其进行编译和加载。
最后,您应该考虑使对象的逻辑成为表驱动或使用某种解释器实现的方法。 如果您实际上需要使用不同的类,则可以使用Java的动态代理类机制对此进行总结; 例如,参见java.lang.reflect.Proxy
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.