¿Cómo invocar explícitamente el método predeterminado desde un proxy dinámico?

También he tenido problemas similares al usar MethodHandle.Lookup en JDK 8 - 10, que se comportan de manera diferente. He blogueado sobre la solución correcta aquí en detalle .

Este enfoque funciona en Java 8

En Java 8, el enfoque ideal utiliza un hack que accede a un constructor package-private desde 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();
                return null;
            }
        );

        duck.quack();
    }
}

Este es el único enfoque que funciona tanto con interfaces de acceso privado como con interfaces de acceso privado. Sin embargo, el enfoque anterior hace ilegal acceso reflectante a los internos de JDK, que ya no funcionarán en una futura versión de JDK, o si se especifica --illegal-access=deny en la JVM.

Este enfoque funciona en Java 9 y 10, pero no 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();
                return null;
            }
        );

        duck.quack();
    }
}

Solución

Simplemente implemente las dos soluciones anteriores y compruebe si su código se está ejecutando en JDK 8 o en un JDK posterior y estará bien. Hasta que no estés:)

Si todo lo que tiene es una interfaz, y todo lo que tiene acceso a un objeto de clase es una interfaz que extiende su interfaz base, y desea llamar al método predeterminado sin una instancia real de una clase que implemente la interfaz, puede:

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

Cree una instancia de la interfaz y luego construya los MethodHandles.Búsqueda usando reflexión:

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

Y luego use ese lookupConstructor para crear una nueva instancia de su interfaz que permitirá el acceso privado a invokespecial. Entonces invoca el método en el proxy falso target que hiciste anteriormente.

lookupConstructor.newInstance(exampleInterface,
        MethodHandles.Lookup.PRIVATE)
        .unreflectSpecial(method, declaringClass)
        .bindTo(target)
        .invokeWithArguments(args);

Uso:

Object result = MethodHandles.lookup()
    .in(method.getDeclaringClass())
    .unreflectSpecial(method, method.getDeclaringClass())
    .bindTo(target)
    .invokeWithArguments();