Ми можемо імітувати реалізацію методів розширення C # у Java, використовуючи реалізацію методу за замовчуванням, доступну з Java 8. Почнемо з визначення інтерфейсу, який дозволить нам отримати доступ до об’єкта підтримки за допомогою методу base (), наприклад:
public interface Extension<T> {
default T base() {
return null;
}
}
Ми повертаємо null, оскільки інтерфейси не можуть мати стан, але це потрібно виправити пізніше через проксі.
Розробник розширень повинен був би розширити цей інтерфейс новим інтерфейсом, що містить методи розширення. Скажімо, ми хочемо додати ForEach споживача до інтерфейсу List:
public interface ListExtension<T> extends Extension<List<T>> {
default void foreach(Consumer<T> consumer) {
for (T item : base()) {
consumer.accept(item);
}
}
}
Оскільки ми розширюємо інтерфейс розширення, ми можемо викликати метод base () всередині нашого методу розширення для доступу до об'єкта підтримки, до якого ми приєднуємося.
Інтерфейс розширення повинен мати заводський метод, який створить розширення заданого об’єкта підтримки:
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;
}
}
}
Ми створюємо проксі-сервер, який реалізує інтерфейс розширення та весь інтерфейс, реалізований за типом об'єкта підтримки. Обробник виклику, наданий проксі, відправив би всі виклики до об'єкта підтримки, за винятком методу "base", який повинен повернути об'єкт підтримки, інакше його реалізація за замовчуванням повертає нуль:
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 () для приєднання інтерфейсу, що містить метод розширення, до об'єкта підтримки. Результатом є об'єкт, який можна подати до інтерфейсу розширення, за допомогою якого ми все ще можемо отримати доступ до об'єкта підтримки, що викликає метод base (). Маючи посилання на інтерфейс розширення, ми тепер можемо сміливо викликати методи розширення, які можуть мати доступ до об'єкта підтримки, так що тепер ми можемо приєднати нові методи до існуючого об'єкта, але не до його визначеного типу:
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);
}
}
Отже, це спосіб ми змоделюємо можливість розширення об’єктів на Java, додаючи до них нові контракти, що дозволяють викликати додаткові методи на заданих об’єктах.
Нижче ви знайдете код інтерфейсу розширення:
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;
}
}
}