Java 8'den beri kullanılabilen varsayılan yöntem uygulamasını kullanarak Java'da C # uzantısı yöntemlerinin uygulanmasını simüle edebiliriz. Bu şekilde, destek nesnesine bir base () yöntemiyle erişmemizi sağlayacak bir arabirim tanımlayarak başlayalım:
public interface Extension<T> {
default T base() {
return null;
}
}
Arabirimlerin durumu olamaz çünkü null döndürüyoruz, ancak bu daha sonra bir proxy aracılığıyla düzeltilmelidir.
Uzantı geliştiricisinin, bu arayüzü, uzantı yöntemlerini içeren yeni bir arayüzle genişletmesi gerekir. Diyelim ki Liste arayüzüne bir forEach tüketici eklemek istiyoruz:
public interface ListExtension<T> extends Extension<List<T>> {
default void foreach(Consumer<T> consumer) {
for (T item : base()) {
consumer.accept(item);
}
}
}
Uzantı arayüzünü genişlettiğimizden, eklediğimiz destek nesnesine erişmek için uzantı yöntemimizin içindeki base () yöntemini çağırabiliriz.
Uzantı arabirimi, belirli bir destek nesnesinin uzantısını oluşturacak bir fabrika yöntemine sahip olmalıdır:
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;
}
}
}
Uzantı arabirimini ve destek nesnesinin türü tarafından uygulanan tüm arabirimi uygulayan bir proxy oluştururuz. Proxy'ye verilen çağırma işleyicisi, destek nesnesini döndürmesi gereken "base" yöntemi dışında, destek nesnesine yapılan tüm çağrıları gönderir, aksi takdirde varsayılan uygulaması null döndürür:
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);
}
}
Ardından, uzantı yöntemini içeren arabirimi destek nesnesine eklemek için Extension.create () yöntemini kullanabiliriz. Sonuç, base () yöntemini çağıran destek nesnesine erişebileceğimiz uzantı arabirimine dökülebilen bir nesnedir. Referansın uzantı arayüzüne dökülmesiyle, artık destek nesnesine erişebilecek uzantı yöntemlerini güvenli bir şekilde çağırabiliriz, böylece şimdi mevcut nesneye yeni yöntemler ekleyebiliriz, ancak tanımlayıcı türüne ekleyemeyiz:
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);
}
}
Yani, bu, Java'da nesneleri, onlara yeni sözleşmeler ekleyerek genişletme yeteneğini simüle etmenin bir yoludur, bu da verilen nesneler üzerinde ek yöntemler çağırmamıza izin verir.
Uzantı arayüzünün kodunu aşağıda bulabilirsiniz:
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;
}
}
}