Wir können die Implementierung von C # -Erweiterungsmethoden in Java mithilfe der seit Java 8 verfügbaren Standardmethodenimplementierung simulieren. Zunächst definieren wir eine Schnittstelle, über die wir über eine base () -Methode auf das Support-Objekt zugreifen können:
public interface Extension<T> {
default T base() {
return null;
}
}
Wir geben null zurück, da Schnittstellen keinen Status haben können, dies muss jedoch später über einen Proxy behoben werden.
Der Entwickler von Erweiterungen müsste diese Schnittstelle um eine neue Schnittstelle erweitern, die Erweiterungsmethoden enthält. Angenommen, wir möchten einen forEach-Consumer auf der List-Oberfläche hinzufügen:
public interface ListExtension<T> extends Extension<List<T>> {
default void foreach(Consumer<T> consumer) {
for (T item : base()) {
consumer.accept(item);
}
}
}
Da wir die Erweiterungsschnittstelle erweitern, können wir die base () -Methode innerhalb unserer Erweiterungsmethode aufrufen, um auf das Support-Objekt zuzugreifen, an das wir uns anhängen.
Die Erweiterungsschnittstelle muss über eine Factory-Methode verfügen, mit der eine Erweiterung eines bestimmten Unterstützungsobjekts erstellt wird:
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;
}
}
}
Wir erstellen einen Proxy, der die Erweiterungsschnittstelle und die gesamte vom Typ des Unterstützungsobjekts implementierte Schnittstelle implementiert. Der dem Proxy übergebene Aufrufhandler würde alle Aufrufe an das Support-Objekt senden, mit Ausnahme der "base" -Methode, die das Support-Objekt zurückgeben muss, andernfalls gibt die Standardimplementierung null zurück:
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);
}
}
Anschließend können wir die Extension.create () -Methode verwenden, um die Schnittstelle mit der Erweiterungsmethode an das Support-Objekt anzuhängen. Das Ergebnis ist ein Objekt, das in die Erweiterungsschnittstelle umgewandelt werden kann, über die wir weiterhin auf das Unterstützungsobjekt zugreifen können, das die base () -Methode aufruft. Nachdem die Referenz in die Erweiterungsschnittstelle umgewandelt wurde, können wir jetzt sicher die Erweiterungsmethoden aufrufen, die Zugriff auf das Unterstützungsobjekt haben können, sodass wir jetzt neue Methoden an das vorhandene Objekt anhängen können, jedoch nicht an den definierenden Typ:
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);
}
}
Auf diese Weise können wir die Möglichkeit simulieren, Objekte in Java zu erweitern, indem wir ihnen neue Verträge hinzufügen, mit denen wir zusätzliche Methoden für die angegebenen Objekte aufrufen können.
Unten finden Sie den Code der Erweiterungsschnittstelle:
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;
}
}
}