---

前言

在学习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;}@Overridepublic Class type() {return type;}@Overridepublic 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;}@Overridepublic 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( )方法。