08、SpringCloudAlibaba实战:OpenFeign中动态代理和方法句柄的结合使用

目录

  • 前言
  • 一、接口定义
  • 二、创建代理
  • 三、创建方法句柄
  • 四、测试

前言

在学习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( )方法。