मैं Java8 विधि संदर्भ का लक्ष्य कैसे ढूंढ सकता हूं?

Question

मैं allowing अंदर

public interface Service { 
    public String stringify(Object o); 
} 
service = mockery.mock(Service.class); 
mockery.allowing(service::stringify).with(42).will(() -> "42"); 

तो एक नकली वस्तु के लिए कॉल कैप्चर करना चाहते हैं मैं एक Function<Object, String>

है वहाँ किसी भी reflecto-जादू मुझे विधि संदर्भ से बनाए गए समारोह से सेवा मिल जाएँगे जो है ?

public WithClause allowing(Function<T,R> f) { 
    Object myServiceBackAgain = findTargetOf(function); 
    .... 
} 

मुझे पता है कि फ़ंक्शन हमेशा इन विधि संदर्भों से आ जाएगा, इसलिए मुझे जितना आवश्यक हो उतना नीचे डालना अच्छा लगता है।

यह संबंधित Is it possible to convert method reference to MethodHandle? जैसा ही प्रश्न नहीं है, क्योंकि शुरुआत के लिए यह एक ही प्रश्न नहीं है, केवल संबंधित क्षेत्र में। और यहां तक ​​कि अगर मैं एक विधि हैडल प्राप्त कर सकता हूं, तो मुझे इसका लक्ष्य नहीं मिल सकता है।

Answer 1

this SO post से चाल का उपयोग करके आप लक्ष्य पा सकते हैं। नीचे दी गई महत्वपूर्ण विधि findTarget है। जैसा कि यह पता चला है, लैम्बडा वास्तव में अपने लक्ष्यों को पकड़ते हैं, और आप उन्हें SerializedLambda से एक्सेस कर सकते हैं।

हालांकि, यह एक बहुत ही बुरा प्रतिबिंब हैक है और यह भविष्य के संस्करणों में तोड़ने की संभावना है। मैं इसका उपयोग नहीं करता हूं।

import java.io.Serializable; 
import java.lang.invoke.SerializedLambda; 
import java.lang.reflect.InvocationTargetException; 
import java.lang.reflect.Method; 
import java.util.Optional; 
import java.util.function.Function; 

public class FindMethodReferenceTarget { 
    public static void main(String[] args) { 
    String s = "123"; 
    Optional<Object> target = findTarget(s::charAt); 
    System.out.println(target.get().equals(s)); 

    Object o = new FindMethodReferenceTarget(); 
    target = findTarget(o::equals); 
    System.out.println(target.get().equals(o)); 
    } 

    private static <T, R> Optional<Object> findTarget(
     DebuggableFunction<T, R> methodReference) { 
    return getLambda(methodReference).map(l -> l.getCapturedArg(0)); 
    } 

    private static Optional<SerializedLambda> getLambda(Serializable lambda) { 
    for (Class<?> cl = lambda.getClass(); cl != null; cl = cl.getSuperclass()) { 
     try { 
     Method m = cl.getDeclaredMethod("writeReplace"); 
     m.setAccessible(true); 
     Object replacement = m.invoke(lambda); 
     if (!(replacement instanceof SerializedLambda)) { 
      break; // custom interface implementation 
     } 
     SerializedLambda l = (SerializedLambda) replacement; 
     return Optional.of(l); 
     } catch (NoSuchMethodException e) { 
     // do nothing 
     } catch (IllegalAccessException | InvocationTargetException e) { 
     break; 
     } 
    } 

    return Optional.empty(); 
    } 

    @FunctionalInterface 
    private static interface DebuggableFunction<T, R> extends 
     Serializable, 
     Function<T, R> {} 
} 

Answer 2

लक्ष्य को खोजने का कोई सीधा तरीका नहीं है, क्योंकि विधि संदर्भों को कवर के तहत लैम्बडास (जो परिभाषा, अज्ञात द्वारा) में अनुवादित किया जाता है। तो आपको एक वर्कअराउंड का उपयोग करने की आवश्यकता होगी।

संभवतः आप जावा 7 के प्रॉक्सी से परिचित हैं, क्योंकि आपने अपनी mock फैक्ट्री विधि को कार्यान्वित करने में कामयाब रहे हैं।

तब कामकाज यह है कि जब कोई आपके allowing विधि को आमंत्रित करता है, तो आप अपने सभी मैक्स को सतर्क करने के लिए कुछ प्रकार का वैश्विक ध्वज सेट करते हैं, जिसे आप अगली कॉल रिकॉर्ड करना चाहते हैं, और फिर आप दिए गए लैम्ब्डा को आमंत्रित करते हैं। यह देखते हुए कि किस मॉक ने कॉल रिकॉर्ड किया है, अब आपको विधि संदर्भ का लक्ष्य मिला है, और आप वैश्विक ध्वज को अनसेट कर सकते हैं और अपने बाकी मॉकिंग फ्रेमवर्क के साथ आगे बढ़ सकते हैं।

यह बदसूरत है, मुझे पता है।