java基础--3动态代理

前言

动态代理可以在接口的前后加入逻辑操作，这个逻辑操作可以和业务相关也可以和业务无关，在一定程度上可以实现代码解耦的目的，因为它不需要知道它代理的类中的接口干了什么。Spring的aop就是采用了动态代理的技术。
目前，java可以使用两种方式进行动态代理，如JDK自带的动态代理技术，和CGLIB动态代理技术。

一、CGLIB动态代理

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author wangcanfeng
 * @description cglib代理自测类
 * @Date Created in 11:19-2019/4/8
 */
public class TestCglib {
    public static void main(String[] args) {
        // 新建一个增强器对象
        Enhancer enhancer = new Enhancer();
        // 设置需要代理的类
        enhancer.setSuperclass(Test.class);
        // 设置已经实现的方法拦截器到回调函数中
        enhancer.setCallback(new MethodInterceptor());
        // 创建代理后的类对象
        Test test = (Test) enhancer.create();
        test.print("我是cglib");
    }


    static class Test {
        public String print(String info) {
            System.out.println(info);
            return "我正在输出信息";
        }
    }

    static class MethodInterceptor implements org.springframework.cglib.proxy.MethodInterceptor {

        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("输出信息之前····");
            //注意这个地方是invokeSuper，而不是invoke，调用invoke会出现递归自调用，然后一直被拦截在方法调用前。最后栈溢出
            //其中super可以理解为未被代理的原始类吧
            Object obj = methodProxy.invokeSuper(o, objects);
            System.out.println("输出信息之后.......");
            return obj;
        }
    }
}
// 输出结果
输出信息之前····
我是cglib
输出信息之后.......

二、JDK动态代理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author wangcanfeng
 * @description jdk动态代理测试
 * @Date Created in 13:44-2019/4/8
 */
public class TestJdkProxy {
    public static void main(String[] args) {
        //创建一个需要代理的对象
        Test test = new Test();
        //将对象装入InvocationHandler的实现类中
        MyInvocation invocation = new MyInvocation(test);
        //实例化一个代理类，并将类做强转，这样就可以使用代理生成的类进行接口调用了
        TestInterface testInterface = (TestInterface) Proxy.newProxyInstance(invocation.getClass()
                .getClassLoader(), test.getClass().getInterfaces(), invocation);
        testInterface.printInfo("sssss");
    }

    static class MyInvocation implements InvocationHandler {

        private Object needProxy;

        public MyInvocation(Object needProxy) {
            this.needProxy = needProxy;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("调用方法之前。。。。。。");
            Object obj = method.invoke(needProxy, args);
            System.out.println("方法调用完毕。。。。。。");
            return obj;
        }
    }

    interface TestInterface {
        String printInfo(String str);
    }

    static class Test implements TestInterface {

        @Override
        public String printInfo(String str) {
            System.out.println("我再输出中.......");
            return str;
        }
    }
}

// 输出结果
调用方法之前。。。。。。
我再输出中.......
方法调用完毕。。。。。。

三、JDK动态代理和Cglib动态代理的区别

jdk–代理接口
是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

glib-代理类
利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

四. 动态代理的应用

说完了动态代理的概念和实现机制，该看看使用动态代理有哪些应用。

4.1. 应用一：代理模式/装饰器模式的动态实现

传统代理模式的实现方式比较暴力直接，需要将所有被代理类的所有方法都写一遍(静态代理)
动态代理优势:
代理转发的过程自动化了，实现自动化搬砖。
代理类的代码逻辑和具体业务逻辑解耦，与业务无关。

4.2. 应用二：实现AOP

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP
3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

4.3. 应用三：实现RPC

RPC调用其实是对远程另外一台机器进程上的对象的代理。

思路：
1)调用方调用本地的RPC代理方法，将参数提供给该方法。
2)不同的RPC代理方法被转发到一个统一的处理中心，该处理中心知道调用的是那个函数，参数是什么。
3)该处理中心将调用的信息封装打包，通过网络发送给另外一个进程。
4)另外一个进程接受到调用进程发送过来的数据包。
5)该进程根据数据包中记录的RPC调用信息，将调用分发给对应的被代理对象的对应方法去执行。
6)返回的话思路类似。
显而易见，第二步，需要使用动态代理将分散的函数调用转发到一个统一的处理中心；第五步，将统一收集来的调用信息分发给具体的函数执行，显然使用反射做到这一点。
有了这个思路，通过利用动态代理，反射，和网络编程技术，实现一个简易版的RPC框架也就不难了。