Possiamo simulare l'implementazione dei metodi di estensione C # in Java utilizzando l'implementazione del metodo predefinito disponibile da Java 8. Iniziamo definendo un'interfaccia che ci permetterà di accedere all'oggetto di supporto tramite un metodo base (), in questo modo:
public interface Extension<T> {
default T base() {
return null;
}
}
Restituiamo null poiché le interfacce non possono avere stato, ma questo deve essere corretto in seguito tramite un proxy.
Lo sviluppatore di estensioni dovrebbe estendere questa interfaccia con una nuova interfaccia contenente metodi di estensione. Diciamo che vogliamo aggiungere un utente forEach sull'interfaccia List:
public interface ListExtension<T> extends Extension<List<T>> {
default void foreach(Consumer<T> consumer) {
for (T item : base()) {
consumer.accept(item);
}
}
}
Poiché estendiamo l'interfaccia di estensione, possiamo chiamare il metodo base () all'interno del nostro metodo di estensione per accedere all'oggetto di supporto a cui ci colleghiamo.
L'interfaccia Extension deve avere un metodo factory che creerà un'estensione di un determinato oggetto di supporto:
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;
}
}
}
Creiamo un proxy che implementa l'interfaccia di estensione e tutta l'interfaccia implementata dal tipo di oggetto di supporto. Il gestore di invocazione fornito al proxy invierebbe tutte le chiamate all'oggetto di supporto, ad eccezione del metodo "base", che deve restituire l'oggetto di supporto, altrimenti la sua implementazione predefinita restituisce 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);
}
}
Quindi, possiamo usare il metodo Extension.create () per collegare l'interfaccia contenente il metodo di estensione all'oggetto di supporto. Il risultato è un oggetto che può essere trasmesso all'interfaccia di estensione tramite la quale possiamo ancora accedere all'oggetto di supporto chiamando il metodo base (). Dopo aver eseguito il cast del riferimento all'interfaccia di estensione, ora possiamo tranquillamente chiamare i metodi di estensione che possono avere accesso all'oggetto di supporto, in modo che ora possiamo collegare nuovi metodi all'oggetto esistente, ma non al suo tipo di definizione:
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);
}
}
Quindi, questo è un modo in cui possiamo simulare la possibilità di estendere oggetti in Java aggiungendo nuovi contratti ad essi, che ci consentono di chiamare metodi aggiuntivi su oggetti dati.
Di seguito puoi trovare il codice dell'interfaccia Extension:
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;
}
}
}