জাভা ৮-এর পরে উপলব্ধ ডিফল্ট পদ্ধতি প্রয়োগের মাধ্যমে আমরা জাভাতে সি # এক্সটেনশন পদ্ধতির প্রয়োগের অনুকরণ করতে পারি We আমরা একটি ইন্টারফেসটি সংজ্ঞায়িত করে শুরু করি যা আমাদের বেস () পদ্ধতির মাধ্যমে সাপোর্ট অবজেক্টে অ্যাক্সেসের অনুমতি দেবে:
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);
}
}
তারপরে, আমরা সমর্থন অবজেক্টটিতে এক্সটেনশন পদ্ধতিযুক্ত ইন্টারফেস সংযুক্ত করতে এক্সটেনশন.ক্রেট () পদ্ধতিটি ব্যবহার করতে পারি। ফলাফলটি এমন একটি অবজেক্ট যা এক্সটেনশন ইন্টারফেসে কাস্ট করা যায় যার দ্বারা আমরা এখনও বেস () পদ্ধতিতে কল করে সমর্থন অবজেক্টটি অ্যাক্সেস করতে পারি। এক্সটেনশন ইন্টারফেসে রেফারেন্সটি কাস্ট করা পরে, আমরা এখন নিরাপদে সেই এক্সটেনশন পদ্ধতিগুলিতে কল করতে পারি যা সহায়তা অবজেক্টে অ্যাক্সেস রাখতে পারে, যাতে এখন আমরা বিদ্যমান অবজেক্টের সাথে নতুন পদ্ধতি সংযুক্ত করতে পারি, তবে তার সংজ্ঞায়িত ধরণের সাথে নয়:
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;
}
}
}