34

由于 Java 8 接口可以有默认方法。我知道如何从实现方法中显式调用该方法，即（请参阅在 Java 中显式调用默认方法）

但是如何使用反射显式调用默认方法，例如在代理上？

例子：

interface ExampleMixin {

  String getText();

  default void printInfo(){
    System.out.println(getText());
  }
}

class Example {

  public static void main(String... args) throws Exception {

    Object target = new Object();

    Map<String, BiFunction<Object, Object[], Object>> behavior = new HashMap<>();

    ExampleMixin dynamic =
            (ExampleMixin) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),new Class[]{ExampleMixin.class}, (Object proxy, Method method, Object[] arguments) -> {

                //custom mixin behavior
                if(behavior.containsKey(method.getName())) {
                    return behavior.get(method.getName()).apply(target, arguments);
                //default mixin behavior
                } else if (method.isDefault()) {
                    //this block throws java.lang.IllegalAccessException: no private access for invokespecial
                    return MethodHandles.lookup()
                                        .in(method.getDeclaringClass())
                                        .unreflectSpecial(method, method.getDeclaringClass())
                                        .bindTo(target)
                                        .invokeWithArguments();
                //no mixin behavior
                } else if (ExampleMixin.class == method.getDeclaringClass()) {
                    throw new UnsupportedOperationException(method.getName() + " is not supported");
                //base class behavior
                } else{
                    return method.invoke(target, arguments);
                }
            });

    //define behavior for abstract method getText()
    behavior.put("getText", (o, a) -> o.toString() + " myText");

    System.out.println(dynamic.getClass());
    System.out.println(dynamic.toString());
    System.out.println(dynamic.getText());

    //print info should by default implementation
    dynamic.printInfo();
  }
}

编辑：我知道在How do I invoke Java 8 default methods reflectively中提出了一个类似的问题，但这并没有解决我的问题，原因有两个：

  • 该问题中描述的问题旨在总体上如何通过反射调用它-因此没有区分默认方法和覆盖方法-这很简单，您只需要一个实例。
  • 答案之一 - 使用方法句柄 - 只适用于讨厌的黑客（恕我直言），例如将访问修饰符更改为查找类的字段，这是同一类别的“解决方案”，如下所示：使用 Java 反射更改私有静态最终字段：很高兴知道这是可能的，但我不会在生产中使用它——我正在寻找一种“官方”的方式来做到这一点。

被IllegalAccessException扔进去unreflectSpecial

Caused by: java.lang.IllegalAccessException: no private access for invokespecial: interface example.ExampleMixin, from example.ExampleMixin/package
at java.lang.invoke.MemberName.makeAccessException(MemberName.java:852)
at java.lang.invoke.MethodHandles$Lookup.checkSpecialCaller(MethodHandles.java:1568)
at java.lang.invoke.MethodHandles$Lookup.unreflectSpecial(MethodHandles.java:1227)
at example.Example.lambda$main$0(Example.java:30)
at example.Example$$Lambda$1/1342443276.invoke(Unknown Source)
4

8 回答 8

15

MethodHandle.Lookup在 JDK 8-10 中使用时，我也被类似的问题困扰，它们的行为不同。我已经在博客中详细介绍了正确的解决方案。

这种方法适用于 Java 8

在 Java 8 中，理想的方法是使用从以下位置访问包私有构造函数的 hack Lookup：

import java.lang.invoke.MethodHandles.Lookup;
import java.lang.reflect.Constructor;
import java.lang.reflect.Proxy;

interface Duck {
    default void quack() {
        System.out.println("Quack");
    }
}

public class ProxyDemo {
    public static void main(String[] a) {
        Duck duck = (Duck) Proxy.newProxyInstance(
            Thread.currentThread().getContextClassLoader(),
            new Class[] { Duck.class },
            (proxy, method, args) -> {
                Constructor<Lookup> constructor = Lookup.class
                    .getDeclaredConstructor(Class.class);
                constructor.setAccessible(true);
                constructor.newInstance(Duck.class)
                    .in(Duck.class)
                    .unreflectSpecial(method, Duck.class)
                    .bindTo(proxy)
                    .invokeWithArguments(args);
                return null;
            }
        );

        duck.quack();
    }
}

这是唯一适用于私有可访问和私有不可访问接口的方法。但是，上述方法对 JDK 内部进行了非法反射访问，这在未来的 JDK 版本中将不再有效，或者如果--illegal-access=deny在 JVM 上指定。

这种方法适用于 Java 9 和 10，但不适用于 8

import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Proxy;

interface Duck {
    default void quack() {
        System.out.println("Quack");
    }
}

public class ProxyDemo {
    public static void main(String[] a) {
        Duck duck = (Duck) Proxy.newProxyInstance(
            Thread.currentThread().getContextClassLoader(),
            new Class[] { Duck.class },
            (proxy, method, args) -> {
                MethodHandles.lookup()
                    .findSpecial( 
                         Duck.class, 
                         "quack",  
                         MethodType.methodType(void.class, new Class[0]),  
                         Duck.class)
                    .bindTo(proxy)
                    .invokeWithArguments(args);
                return null;
            }
        );

        duck.quack();
    }
}

解决方案

只需实现上述两个解决方案，并检查您的代码是在 JDK 8 还是更高版本的 JDK 上运行，就可以了。直到你不是:)

于 2018-03-28T10:45:42.337 回答
10

如果您使用具体的 impl 类作为 lookupClass 和 invokeSpecial 的调用者，它应该正确调用接口的默认实现（不需要 hack 进行私有访问）：

Example target = new Example();
...

Class targetClass = target.getClass();
return MethodHandles.lookup()
                    .in(targetClass)
                    .unreflectSpecial(method, targetClass)
                    .bindTo(target)
                    .invokeWithArguments();

当然，这只有在您引用了实现接口的具体对象时才有效。

编辑：这个解决方案只有在有问题的类（上面代码中的示例）可以从调用者代码私有访问时才有效，例如匿名内部类。

MethodHandles/Lookup 类的当前实现不允许在任何不能从当前调用者类私有访问的类上调用 invokeSpecial。有各种可用的变通方法，但它们都需要使用反射来使构造函数/方法可访问，如果安装了 SecurityManager，这可能会失败。

于 2016-06-14T15:27:36.307 回答
8

在 Java 16 中（来自文档，其中也有更复杂的示例）：

Object proxy = Proxy.newProxyInstance(loader, new Class[] { A.class },
        (o, m, params) -> {
            if (m.isDefault()) {
                // if it's a default method, invoke it
                return InvocationHandler.invokeDefault(o, m, params);
            }
        });
}
于 2021-04-01T22:42:01.867 回答
2

如果您只有一个接口，并且您只能访问一个类对象，它是一个扩展您的基本接口的接口，并且您想在没有实现该接口的类的真实实例的情况下调用默认方法，您可以：

Object target = Proxy.newProxyInstance(classLoader,
      new Class[]{exampleInterface}, (Object p, Method m, Object[] a) -> null);

创建接口的实例，然后使用反射构造 MethodHandles.Lookup：

Constructor<MethodHandles.Lookup> lookupConstructor = 
    MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, Integer.TYPE);
if (!lookupConstructor.isAccessible()) {
    lookupConstructor.setAccessible(true);
}

然后使用它lookupConstructor创建一个新的接口实例，允许私有访问invokespecial. target然后在您之前创建的假代理上调用该方法。

lookupConstructor.newInstance(exampleInterface,
        MethodHandles.Lookup.PRIVATE)
        .unreflectSpecial(method, declaringClass)
        .bindTo(target)
        .invokeWithArguments(args);
于 2017-02-25T17:18:01.420 回答
1

采用：

Object result = MethodHandles.lookup()
    .in(method.getDeclaringClass())
    .unreflectSpecial(method, method.getDeclaringClass())
    .bindTo(target)
    .invokeWithArguments();
于 2016-06-14T12:48:34.450 回答
1

我们可以看到 spring 进程的默认方法是如何的。

  1. 尝试先调用公共方法MethodHandles.privateLookupIn(Class,Lookup)。这应该在 jdk9+ 上成功。
  2. 尝试使用包私有构造函数创建一个查找MethodHandles.Lookup(Class)。
  3. 回退到 MethodHandles.lookup().findSpecial(...)

https://github.com/spring-projects/spring-data-commons/blob/2.1.8.RELEASE/src/main/java/org/springframework/data/projection/DefaultMethodInvokingMethodInterceptor.java

于 2019-05-30T08:20:57.683 回答
1

T. Neidhart 的回答几乎奏效了，但我得到了java.lang.IllegalAccessException: no private access for invokespecial

更改为使用MethodHandles.privateLookup()解决了它 

return MethodHandles.privateLookupIn(clazz,MethodHandles.lookup())
                        .in(clazz)
                        .unreflectSpecial(method, clazz)
                        .bindTo(proxy)
                        .invokeWithArguments(args);

这是一个完整的示例，其想法是扩展提供的 IMap 的用户可以使用他的自定义界面访问嵌套的嵌套地图

interface IMap {
    Object get(String key);

    default <T> T getAsAny(String key){
        return (T)get(key);
    }


    default <T extends IMap> T getNestedAs(String key, Class<T> clazz) {
        Map<String,Object> nested = getAsAny(key);
        return (T)Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{clazz},  (proxy, method, args) -> {
                    if (method.getName().equals("get")){
                        return nested.get(args[0]);
                    }
                    return MethodHandles.privateLookupIn(clazz, MethodHandles.lookup())
                            .in(clazz)
                            .unreflectSpecial(method, clazz)
                            .bindTo(proxy)
                            .invokeWithArguments(args);
                }
        );
    }
}

interface IMyMap extends IMap{

    default Integer getAsInt(String key){
        return getAsAny(key);
    }
    default IMyMap getNested(String key){
        return getNestedAs(key,IMyMap.class);
    }
}

@Test
public void test(){
    var data =Map.of("strKey","strValue", "nstKey", Map.of("intKey",42));
    IMyMap base = data::get;

    IMyMap myMap = base.getNested("nstKey");
    System.out.println( myMap.getAsInt("intKey"));
}
于 2020-05-05T18:27:01.487 回答
0

Lukas 的答案适用于 Android 8+（早期版本没有默认方法），但依赖于在后来的 Android 版本中被阻止的私有 API。幸运的是，替代构造函数也可以工作，并且目前处于灰名单（不支持）中。示例（用 Kotlin 编写）可以在这里看到。

@get:RequiresApi(26)
private val newLookup by lazy @TargetApi(26) {
    MethodHandles.Lookup::class.java.getDeclaredConstructor(Class::class.java, Int::class.java).apply {
        isAccessible = true
    }
}

@RequiresApi(26)
fun InvocationHandler.invokeDefault(proxy: Any, method: Method, vararg args: Any?) =
    newLookup.newInstance(method.declaringClass, 0xf)   // ALL_MODES
        .unreflectSpecial(method, method.declaringClass)
        .bindTo(proxy)
        .invokeWithArguments(*args)
于 2021-08-17T22:27:11.693 回答