Wie bekomme ich die MethodInfo einer Java 8 Methodenreferenz?

Sieht aus wie es möglich sein könnte, nachdem alle, durch die Verwendung eines proxy aufzeichnen, welche Methode aufgerufen wird.

https://stackoverflow.com/a/22745127/3478229

InformationsquelleAutor der Antwort ddan

In meinem Fall war ich auf der Suche nach einem Weg, um loszuwerden, diese in unit-tests:

Point p = getAPoint();
assertEquals(p.getX(), 4, "x");
assertEquals(p.getY(), 6, "x");

Wie Sie sehen können jemand testen der Methode getAPoint und prüft, ob die Koordinaten sind wie erwartet, aber in der Beschreibung der einzelnen geltend machen, die kopiert wurde und nicht in sync mit dem, was geprüft wird. Besser wäre zu schreiben, dies nur einmal.

Aus den Ideen von @ddan baute ich eine proxy-Lösung mit Mockito:

private<T> void assertPropertyEqual(final T object, final Function<T, ?> getter, final Object expected) {
    final String methodName = getMethodName(object.getClass(), getter);
    assertEquals(getter.apply(object), expected, methodName);
}

@SuppressWarnings("unchecked")
private<T> String getMethodName(final Class<?> clazz, final Function<T, ?> getter) {
    final Method[] method = new Method[1];
    getter.apply((T)Mockito.mock(clazz, Mockito.withSettings().invocationListeners(methodInvocationReport -> {
        method[0] = ((InvocationOnMock) methodInvocationReport.getInvocation()).getMethod();
    })));
    return method[0].getName();
}

Nein, ich kann einfach verwenden

assertPropertyEqual(p, Point::getX, 4);
assertPropertyEqual(p, Point::getY, 6);

sowie die Beschreibung der Geltendmachung ist garantiert synchron mit dem code.

Nachteil:

• Wird etwas langsamer sein, als die oben
• Muss Mockito arbeiten
• Kaum zu gebrauchen, alles andere als einen Anwendungsfall vor.

Aber es zeigt einen Weg, wie es getan werden könnte.

InformationsquelleAutor der Antwort yankee

Verlag haben wir die kleine Bibliothek de.cronn:Reflexion-utildie verwendet werden können, um zu erfassen eine Methode Namen.

Beispiel:

class MyClass {

    public void myMethod() {
    }

}

String methodName = ClassUtils.getVoidMethodName(MyClass.class, MyClass::myMethod);
System.out.println(methodName); //prints "myMethod"

Umsetzung details: Ein Proxy-Unterklasse MyClass erstellt mit ByteBuddy und ein Aufruf der Methode erfasst wird, ruft dessen Namen.
ClassUtils speichert die Informationen, so dass wir nicht brauchen, um erstellen Sie einen neuen proxy auf jede Anrufung.

Bitte beachten Sie, dass dieser Ansatz funktioniert nicht mit statische Methoden.

InformationsquelleAutor der Antwort Benedikt Waldvogel

Kann es nicht sein, einen zuverlässigen Weg, aber unter gewissen Umständen:

1. Ihre MyClass ist nicht endgültig, und verfügt über eine Behindertengerechte Konstruktor (Beschränkung der cglib)
2. Ihre myMethod ist nicht überladen, und nicht statisch

Den können Sie versuchen, mithilfe von cglib zum erstellen einer proxy MyClassdann mit einem MethodInterceptor zu berichten, die Method während die Methode Referenz aufgerufen wird, wird in einem folgenden Versuch laufen.

Beispiel-code:

public static void main(String[] args) {
    Method m = MethodReferenceUtils.getReferencedMethod(ArrayList.class, ArrayList::contains);
    System.out.println(m);
}

Sehen Sie die folgende Ausgabe:

public boolean java.util.ArrayList.contains(java.lang.Object)

Während:

public class MethodReferenceUtils {

    @FunctionalInterface
    public static interface MethodRefWith1Arg<T, A1> {
        void call(T t, A1 a1);
    }

    public static <T, A1> Method getReferencedMethod(Class<T> clazz, MethodRefWith1Arg<T, A1> methodRef) {
        return findReferencedMethod(clazz, t -> methodRef.call(t, null));
    }

    @SuppressWarnings("unchecked")
    private static <T> Method findReferencedMethod(Class<T> clazz, Consumer<T> invoker) {
        AtomicReference<Method> ref = new AtomicReference<>();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                ref.set(method);
                return null;
            }
        });
        try {
            invoker.accept((T) enhancer.create());
        } catch (ClassCastException e) {
            throw new IllegalArgumentException(String.format("Invalid method reference on class [%s]", clazz));
        }

        Method method = ref.get();
        if (method == null) {
            throw new IllegalArgumentException(String.format("Invalid method reference on class [%s]", clazz));
        }

        return method;
    }
}

Im obigen code MethodRefWith1Arg ist nur ein syntax-Zucker für, einen Verweis auf eine nicht statische Methode mit einem Argumente. Sie können beliebig viele zu erstellen MethodRefWithXArgs für die Referenzierung von Ihren anderen Methoden.

InformationsquelleAutor der Antwort vivimice

Können Sie "meine Bibliothek" Reflektieren, Ohne String

Method myMethod = ReflectWithoutString.methodGetter(MyClass.class).getMethod(MyClass::myMethod);

InformationsquelleAutor der Antwort Dean Xu