हम जावा 8 में उपलब्ध डिफ़ॉल्ट विधि कार्यान्वयन का उपयोग करके जावा में C # एक्सटेंशन विधियों के कार्यान्वयन का अनुकरण कर सकते हैं। हम एक इंटरफ़ेस को परिभाषित करके शुरू करते हैं जो हमें आधार () विधि के माध्यम से समर्थन ऑब्जेक्ट तक पहुंचने की अनुमति देगा, जैसे:
public interface Extension<T> {
default T base() {
return null;
}
}
हम शून्य वापस आते हैं क्योंकि इंटरफेस में स्थिति नहीं हो सकती है, लेकिन इसे बाद में प्रॉक्सी के माध्यम से तय किया जाना चाहिए।
एक्सटेंशन के डेवलपर को इस इंटरफ़ेस को एक्सटेंशन विधियों से युक्त एक नए इंटरफ़ेस द्वारा विस्तारित करना होगा। मान लें कि हम सूची इंटरफ़ेस पर एक पूर्व उपभोक्ता जोड़ना चाहते हैं:
public interface ListExtension<T> extends Extension<List<T>> {
default void foreach(Consumer<T> consumer) {
for (T item : base()) {
consumer.accept(item);
}
}
}
चूँकि हम एक्सटेंशन इंटरफ़ेस का विस्तार करते हैं, इसलिए हम अपने द्वारा अटैच किए गए समर्थन ऑब्जेक्ट तक पहुंचने के लिए बेस () विधि को अपनी एक्सटेंशन विधि के अंदर कॉल कर सकते हैं।
एक्सटेंशन इंटरफ़ेस में फ़ैक्टरी विधि होनी चाहिए जो किसी दिए गए समर्थन ऑब्जेक्ट का एक्सटेंशन बनाएगी:
public interface Extension<T> {
...
static <E extends Extension<T>, T> E create(Class<E> type, T instance) {
if (type.isInterface()) {
ExtensionHandler<T> handler = new ExtensionHandler<T>(instance);
List<Class<?>> interfaces = new ArrayList<Class<?>>();
interfaces.add(type);
Class<?> baseType = type.getSuperclass();
while (baseType != null && baseType.isInterface()) {
interfaces.add(baseType);
baseType = baseType.getSuperclass();
}
Object proxy = Proxy.newProxyInstance(
Extension.class.getClassLoader(),
interfaces.toArray(new Class<?>[interfaces.size()]),
handler);
return type.cast(proxy);
} else {
return null;
}
}
}
हम एक प्रॉक्सी बनाते हैं जो एक्सटेंशन इंटरफ़ेस और समर्थन ऑब्जेक्ट के प्रकार द्वारा लागू किए गए सभी इंटरफ़ेस को लागू करता है। प्रॉक्सी को दिया गया इनवोकेशन हैंडलर "बेस" विधि को छोड़कर सभी कॉल को सपोर्ट ऑब्जेक्ट में भेज देगा, जिसे सपोर्ट ऑब्जेक्ट को वापस करना होगा, अन्यथा इसका डिफॉल्ट इम्प्लीमेंट शून्य हो रहा है:
public class ExtensionHandler<T> implements InvocationHandler {
private T instance;
private ExtensionHandler(T instance) {
this.instance = instance;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if ("base".equals(method.getName())
&& method.getParameterCount() == 0) {
return instance;
} else {
Class<?> type = method.getDeclaringClass();
MethodHandles.Lookup lookup = MethodHandles.lookup()
.in(type);
Field allowedModesField = lookup.getClass().getDeclaredField("allowedModes");
makeFieldModifiable(allowedModesField);
allowedModesField.set(lookup, -1);
return lookup
.unreflectSpecial(method, type)
.bindTo(proxy)
.invokeWithArguments(args);
}
}
private static void makeFieldModifiable(Field field) throws Exception {
field.setAccessible(true);
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField
.setInt(field, field.getModifiers() & ~Modifier.FINAL);
}
}
फिर, हम एक्सटेंशन ऑब्जेक्ट को सपोर्ट ऑब्जेक्ट में इंटरफ़ेस को संलग्न करने के लिए Extension.create () विधि का उपयोग कर सकते हैं। परिणाम एक ऑब्जेक्ट है जिसे एक्सटेंशन इंटरफ़ेस में डाला जा सकता है जिसके द्वारा हम आधार () विधि को कॉल करके अभी भी समर्थन ऑब्जेक्ट तक पहुंच सकते हैं। एक्सटेंशन इंटरफ़ेस में डाले गए संदर्भ के बाद, अब हम उन एक्सटेंशन विधियों को सुरक्षित रूप से कॉल कर सकते हैं, जिनकी सहायता ऑब्जेक्ट तक पहुँच हो सकती है, ताकि अब हम मौजूदा ऑब्जेक्ट में नए तरीके संलग्न कर सकें, लेकिन इसके परिभाषित प्रकार के लिए नहीं:
public class Program {
public static void main(String[] args) {
List<String> list = Arrays.asList("a", "b", "c");
ListExtension<String> listExtension = Extension.create(ListExtension.class, list);
listExtension.foreach(System.out::println);
}
}
तो, यह एक ऐसा तरीका है जिससे हम जावा में वस्तुओं का विस्तार करने की क्षमता को नए अनुबंधों के साथ जोड़ सकते हैं, जो हमें दी गई वस्तुओं पर अतिरिक्त तरीकों को कॉल करने की अनुमति देता है।
नीचे आपको एक्सटेंशन इंटरफ़ेस का कोड मिल सकता है:
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
public interface Extension<T> {
public class ExtensionHandler<T> implements InvocationHandler {
private T instance;
private ExtensionHandler(T instance) {
this.instance = instance;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if ("base".equals(method.getName())
&& method.getParameterCount() == 0) {
return instance;
} else {
Class<?> type = method.getDeclaringClass();
MethodHandles.Lookup lookup = MethodHandles.lookup()
.in(type);
Field allowedModesField = lookup.getClass().getDeclaredField("allowedModes");
makeFieldModifiable(allowedModesField);
allowedModesField.set(lookup, -1);
return lookup
.unreflectSpecial(method, type)
.bindTo(proxy)
.invokeWithArguments(args);
}
}
private static void makeFieldModifiable(Field field) throws Exception {
field.setAccessible(true);
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
}
}
default T base() {
return null;
}
static <E extends Extension<T>, T> E create(Class<E> type, T instance) {
if (type.isInterface()) {
ExtensionHandler<T> handler = new ExtensionHandler<T>(instance);
List<Class<?>> interfaces = new ArrayList<Class<?>>();
interfaces.add(type);
Class<?> baseType = type.getSuperclass();
while (baseType != null && baseType.isInterface()) {
interfaces.add(baseType);
baseType = baseType.getSuperclass();
}
Object proxy = Proxy.newProxyInstance(
Extension.class.getClassLoader(),
interfaces.toArray(new Class<?>[interfaces.size()]),
handler);
return type.cast(proxy);
} else {
return null;
}
}
}