目录
- 前言
- 一、接口定义
- 二、创建代理
- 三、创建方法句柄
- 四、测试
前言
在学习OpenFeign的过程中，发现了一个好玩的地方，就是动态代理和方法句柄的结合使用，分别用来处理接口远程方法调用和本地接口默认方法调用。本篇文章对此做一些测试。
一、接口定义
1、 实际接口；
定义了两个方法，work( )方法需要被代理处理实际的业务，eat( )方法是默认方法，不需要被代理。
public interface People {
String work();
default String eat() {
return "吃饭";
}
}
2、 目标接口；
定义了一个类型方法，和一个具体的业务方法
public interface Target<T> {
Class<T> type();
String concreteWork();
}
3、 目标实现类；
public class ConcreteTarget<T> implements Target<T>{
private final Class<T> type;
public ConcreteTarget(Class<T> type) {
this.type = type;
}
@Override
public Class type() {
return type;
}
@Override
public String concreteWork() {
System.out.println("程序员写代码...");
return "编程";
}
}
二、创建代理
（1）定义两个全局变量
//代理对象
public static People proxy;
//方法句柄
public static MethodHandle handle;
（2）InvocationHandler
public class CustomInvocationHandler implements InvocationHandler {
//目标对象
private Object target;
public CustomInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
Object invoke = null;
//在真实的对象执行之前增强方法
System.out.println(methodName + ": before invoke。。。");
if (methodName.equals("work")) {
//这里访问实际的业务逻辑，在feign中是访问远程服务端接口
Method concreteWork = target.getClass().getMethod("concreteWork", null);
invoke = concreteWork.invoke(target, args);
} else {
invoke = "进入了代理方法";
}
//在真实的对象执行之后增强方法
System.out.println(methodName + ": after invoke。。。");
return methodName + ": " + invoke;
}
}
（3）创建代理：
private static void createProxy() {
//真实对象
Target target = new ConcreteTarget(People.class);
//代理对象调用真实对象的方法
InvocationHandler handler = new InvocationHandlerTest(target);
/**
* 创建代理对象
* 第一个参数：handler.getClass().getClassLoader()，使用handler对象的classloader对象来加载代理对象
* 第二个参数： new Class<?>[] {target.type()}，代理接口
* 第三个参数：handler，将代理对象关联到InvocationHandler对象上
*/
proxy = (People) Proxy.newProxyInstance(handler.getClass().getClassLoader(), new Class<?>[]{
target.type()}, handler);
}
三、创建方法句柄
对eat( )方法创建方法句柄
private static void createMethodHandle() {
String methodName = "eat";
try {
Method defaultMethod = People.class.getMethod(methodName, null);
Class<?> declaringClass = defaultMethod.getDeclaringClass();
Field field = MethodHandles.Lookup.class.getDeclaredField("IMPL_LOOKUP");
field.setAccessible(true);
MethodHandles.Lookup lookup = (MethodHandles.Lookup) field.get(null);
MethodHandle unboundHandle = lookup.unreflectSpecial(defaultMethod, declaringClass);
//绑定代理对象
handle = unboundHandle.bindTo(proxy);
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
}
四、测试
1、 调用代理对象的work()方法；
String result = proxy.work();
System.out.println(result);
结果：
work: before invoke。。。
程序员写代码...
work: after invoke。。。
work: 编程
可以看出，调用 work( ) 方法进入了代理invoke( )方法。
2、 调用代理对象的eat()方法；
String result = proxy.eat();
System.out.println(result);
结果：
eat: before invoke。。。
eat: after invoke。。。
eat: 进入了代理方法
可以看出，调用 eat( ) 方法同样进入了代理invoke( )方法。
3、 调用方法句柄；
Object result = handle.invokeWithArguments();
System.out.println(result);
结果：
吃饭
可以看出，通过方法句柄方式调用，这样就能动态的访问到接口的默认方法，而不会进入到代理的invoke( )方法。