Интерфейс InvocationHandler

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

Обрабатывает вызов метода на экземпляре прокси и возвращает результат. Этот метод будет вызван обработчиком вызова, когда метод вызывается на экземпляре прокси, с которым он связан.

static Object invokeDefault(Object proxy, Method method, Object... args) throws Throwable

Вызывает указанный метод по умолчанию на заданном экземпляре proxy с заданными параметрами. Заданный method должен быть методом по умолчанию, объявленным в интерфейсе прокси класса proxy или унаследованным от его суперинтерфейсов напрямую или косвенно.

Вызов этого метода выполняется так, как если бы инструкция invokespecial выполнялась из класса прокси, нацеливаясь на метод по умолчанию в интерфейсе прокси. Это эквивалентно вызову: X.super.m(A* a) , где X — интерфейс прокси, а вызов X.super::m(A*) решен для данного method.

Примеры: интерфейс A и B оба объявляют реализацию по умолчанию метода m. Интерфейс C расширяет A и наследует метод по умолчанию m от своего суперинтерфейса A.

 interface A {
     default T m(A a) { return t1; }
 }
 interface B {
     default T m(A a) { return t2; }
 }
 interface C extends A {}
 

Следующий пример создаёт экземпляр прокси, который реализует A и вызывает метод по умолчанию A::m.

 Object proxy = Proxy.newProxyInstance(loader, new Class<?>[] { A.class },
         (o, m, params) -> {
             if (m.isDefault()) {
                 // if it's a default method, invoke it
                 return InvocationHandler.invokeDefault(o, m, params);
             }
         });
 

Если экземпляр прокси реализует как A, так и B, оба из которых обеспечивают реализацию по умолчанию метода m, обработчик вызова может передать вызов метода A::m или B::m через метод invokeDefault. Например, следующий код делегирует вызов метода B::m.

 Object proxy = Proxy.newProxyInstance(loader, new Class<?>[] { A.class, B.class },
         (o, m, params) -> {
             if (m.getName().equals("m")) {
                 // invoke B::m instead of A::m
                 Method bMethod = B.class.getMethod(m.getName(), m.getParameterTypes());
                 return InvocationHandler.invokeDefault(o, bMethod, params);
             }
         });
 

Если экземпляр прокси реализует C, который наследует метод по умолчанию m от своего суперинтерфейса A, тогда вызов метода интерфейса на "m" передаётся обработчику вызова в метод invoke с аргументом объекта Method, представляющим метод по умолчанию A::m.

 Object proxy = Proxy.newProxyInstance(loader, new Class<?>[] { C.class },
        (o, m, params) -> {
             if (m.isDefault()) {
                 // behaves as if calling C.super.m(params)
                 return InvocationHandler.invokeDefault(o, m, params);
             }
        });
 

Вызов метода "m" в этом proxy будет работать так, как если бы вызывался C.super::m и был решен в вызов A::m.

Добавление метода по умолчанию или изменение метода с абстрактного на метод по умолчанию может вызвать исключение, если существующий код пытается вызвать invokeDefault для вызова метода по умолчанию. Например, если C изменяется для реализации метода по умолчанию m:

 interface C extends A {
     default T m(A a) { return t3; }
 }
 

Приведённый выше код, создающий экземпляр прокси proxy с изменённым C, выполняется без исключений, и он приведёт к вызову C::m вместо A::m.

Вот ещё один пример, который создаёт экземпляр прокси C и обработчик вызовов вызывает метод invokeDefault для вызова A::m:

 C c = (C) Proxy.newProxyInstance(loader, new Class<?>[] { C.class },
         (o, m, params) -> {
             if (m.getName().equals("m")) {
                 // IllegalArgumentException thrown as {@code A::m} is not a method
                 // inherited from its proxy interface C
                 Method aMethod = A.class.getMethod(m.getName(), m.getParameterTypes());
                 return InvocationHandler.invokeDefault(o, aMethod params);
             }
         });
 c.m(...);
 

Приведенный выше код успешно выполняется со старой версией C и вызывается A::m. При выполнении с новой версией C вышеприведённый код завершится с IllegalArgumentException, потому что C переопределяет реализацию того же метода и A::m недоступно для экземпляра прокси.