是否可以直接从java类文件的Constant_Method_REF获取java.lang.reflection.method？

我正在使用BCEL转换方法字节码以实现具有匿名内部类样式的方法拦截器，在拦截方法的同时，我需要处理截获方法上的一些注释。我使用 BCEL 来拦截除 java 反射以外的方法访问。

现在，我的代码可以很好地与没有基元类型的方法一起使用。由于我不知道如何将 Class.getDeclaredMethod 与原始参数类型列表一起使用，因此 getDeclaredMethod 接受 methodName 和 Class[] 数组作为参数。

所以第一个问题是如何做到这一点。

然后我在JDK7中发现，我可以通过java类文件中的ldc_w字节代码通过CONSTANT_MethodHandle直接获取MethodHandle引用。就像使用 ldc 引用 Java 类一样，如果我可以直接用 ldc_w 引用 java.lang.reflection.Method ，那么我将节省我进行反射的时间，并且不会被上面提到的第一个问题中的原始类型所困扰。我试过了，但我没有这样做。

所以第二个问题是我可以使用ldc_w来引用java.lang.reflection.Method吗？

第三个问题是我可以将 MethodHandle 隐藏到 java.lang.reflection.Method 或相应方法上的注释吗？

谢谢霍尔格，你的回答我几乎完全清楚，但以下问题。我可能误解了你的答案，现在我在运行时出现异常：

Exception in thread "main" java.lang.NoClassDefFoundError: long
at net.madz.lifecycle.demo.standalone.ServiceOrder.allocateResources(ServiceOrder.java)
at net.madz.lifecycle.demo.standalone.Main2.main(Main2.java:18)
Caused by: java.lang.ClassNotFoundException: long
at java.net.URLClassLoader$1.run(URLClassLoader.java:366)
at java.net.URLClassLoader$1.run(URLClassLoader.java:355)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:354)
at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:308)
at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
... 2 more

代码如下//2.5 为数组中的每个元素赋值

    // Step 2. final InterceptContext<Void> context = new
    // InterceptContext<Void>(getClass(), this, "allocateResources",
    // new Class[] { Long.class, Long.class, Long.class });
    // 2.1 getClass()
    ilist.append(ifact.createNew(InterceptContext.class.getName()));
    ilist.append(InstructionFactory.DUP);
    ilist.append(new LDC(cgen.getConstantPool().lookupClass(interceptingClass)));
    // 2.2 load this
    ilist.append(InstructionFactory.createLoad(new ObjectType(interceptingClass), 0));// this
    // 2.3 load intercepting method
    int methodNameIndex = cgen.getConstantPool().lookupString(interceptingMethod);
    if ( -1 >= methodNameIndex ) {
        methodNameIndex = cgen.getConstantPool().addString(interceptingMethod);
    }
    ilist.append(new LDC(methodNameIndex));// methodName
    // 2.4 calculate argument size and allocate an array with same size
    ilist.append(new ICONST(types.length));
    ilist.append(ifact.createNewArray(new ObjectType("java.lang.Class"), (short) 1));
    // 2.5 assign value for each element in array
    for ( int i = 0; i < types.length; i++ ) {
        ilist.append(InstructionFactory.DUP);
        ilist.append(new ICONST(i));
        String className = convertType2ClassName(types[i]);
        int argumentClassIndex = cgen.getConstantPool().lookupClass(className); // ?
        if ( -1 >= argumentClassIndex ) {
            argumentClassIndex = cgen.getConstantPool().addClass(className);
        }
        if ( types[i].getSize() > 4 ) {
            ilist.append(new LDC_W(argumentClassIndex));
        } else {
            ilist.append(new LDC(argumentClassIndex));
        }
        ilist.append(InstructionConstants.AASTORE);
    }
    // 2.6 new InterceptContext<Void>(...
    final Type[] interceptor_method_arg_types = new Type[4];
    interceptor_method_arg_types[0] = new ObjectType("java.lang.Class");
    interceptor_method_arg_types[1] = new ObjectType("java.lang.Object");
    interceptor_method_arg_types[2] = new ObjectType("java.lang.String");
    interceptor_method_arg_types[3] = new ArrayType("java.lang.Class", 1);
    ilist.append(ifact.createInvoke(InterceptContext.class.getName(), "<init>", Type.VOID,
            interceptor_method_arg_types, Constants.INVOKESPECIAL));

转换类型2类名称如下：

    private static String convertType2ClassName(Type type) {
    if ( Type.BOOLEAN.equals(type) ) {
        return boolean.class.getName();
    } else if ( Type.BYTE.equals(type) ) {
        return byte.class.getName();
    } else if ( Type.CHAR.equals(type) ) {
        return char.class.getName();
    } else if ( Type.DOUBLE.equals(type) ) {
        return double.class.getName();
    } else if ( Type.FLOAT.equals(type) ) {
        return float.class.getName();
    } else if ( Type.INT.equals(type) ) {
        return int.class.getName();
    } else if ( Type.LONG.equals(type) ) {
        return long.class.getName();
    } else if ( Type.SHORT.equals(type) ) {
        return short.class.getName();
    } else if ( type instanceof ObjectType ) {
        String signature = type.getSignature();
        if ( signature.startsWith("L") ) {
            signature = signature.substring(1);
        }
        int leftArrow = signature.indexOf("<");
        if ( -1 < leftArrow ) {
            signature = signature.substring(0, leftArrow);
        }
        if ( signature.endsWith(";") ) {
            signature = signature.substring(0, signature.length() - 1);
        }
        return signature;
    } else if ( type instanceof ArrayType ) {
        //unsupport for now
    }
    //wrong return
    return type.getSignature();
}

Holger的回答涵盖了你的第一个问题（getDeclaredMethod with primitive arguments）。你的第二个问题的答案（使用ldc获取java.lang.reflect.Method）仍然是否定的。但是你的第三个问题的答案（将方法句柄转换为java.lang.reflect.Method）随着Java 8的发布而改变 - 答案现在是，包括你关心的情况（转换你刚刚ldc'd'd）。

从Java 8开始，可以"破解"直接方法句柄以获取Method，Constructor或Field对象。直接方法句柄定义为由ldc CONSTANT_MethodHandle常量或 MethodHandles.Lookup 中的find*和unreflect*方法生成的句柄，没有进一步的转换（没有绑定参数等）。有两种途径可以破解直接方法句柄：

调用 MethodHandles.reflectAs，传递预期的类（方法、构造函数或字段）和要破解的句柄。此方法需要 ReflectPermission("suppressAccessChecks") ，因此如果您需要在安全管理器下运行，则可能不合适。
或者具有足够的访问权限来重新创建等效方法句柄"（根据 MethodHandleInfo 文档），然后调用 Lookup.revealDirect 将句柄传递给 crack 以获取 MethodHandleInfo，然后调用 MethodHandleInfo.reflectAs 传递预期的类（方法、构造函数或字段）和查找。为了维护安全性，此途径通过检查查找类来专门处理调用方敏感方法。

第一种途径更方便，但是如果您需要在安全管理器下运行，则需要在每个类中创建一个查找，以破解方法句柄（存储在<clinit>中初始化的新静态字段中）并使用该查找来获取句柄。

您无法获得ldc的java.lang.reflection.Method。对CONSTANT_MethodHandle进行ldc会产生MethodHandle。

这些方法句柄可用于执行关联的代码（尽管其名称不限于方法），并且可以查询其参数类型。但是您不能将其转换为反射Method。虽然您可以执行相反的操作，但请将java.lang.reflection.Method转换为java.lang.invoke.MethodHandle。

由于java.lang.invoke.MethodHandle可以更快地调用方法，并且没有自动装箱的开销，也无需将所有参数放入数组中，因此您可能无论如何都不想使用它。

顺便说一下，使用基元类型的反射非常容易，例如

obj.getClass()
   .getDeclareMethodMethod("foo", int.class, String.class)
   .invoke(obj, 42, "blah");

它将int包装到Integer中，并创建一个临时Object[]数组，其中包含两个参数Object s。但是对于该方法的查找，您必须指定正确的基元类型。

从Java 8开始，有一种方法可以将直接MethodHandle转换为Method，因此您可以使用ldc指令，然后进行转换，但是您需要获取一个MethodHandles.Lookup实例并使用它两次，因此字节码如下所示：

ldc             class java/lang/reflect/Method
ldc             method handle <your desired method>
invokestatic    java/lang/invoke/MethodHandles.reflectAs:(Ljava/lang/Class;Ljava/lang/invoke/MethodHandle;)Ljava/lang/reflect/Member;
checkcast       java/lang/reflect/Method

略短于，例如

ldc             class <declaring class of your desired method>
ldc             string <name of your desired method>
ldc             method type <type signature of your desired method>
invokevirtual   java/lang/invoke/MethodType.parameterArray:()[Ljava/lang/Class;
invokevirtual   java/lang/Class.getDeclaredMethod:(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;

^{请记住，在字节码级别，没有强制执行异常处理}

相关内容

最新更新

热门标签：