静态代理和动态代理

---

前言

本篇学习静态代理和动态代理，静态代理和动态代理是spring面向切面编程的底层原理

---

一、什么是代理模式？

代理模式是程序设计中的一种设计模式：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

举个生活中的简单例子：
租客--------中介----------房东
现在假设没有中介，那么租房的这行为将会变成如下的情景。房东想要把房子租出去，但是他没有客源，于是他需要自己去告知租客，自己需要出租房子。例如需要自己去发传单。贴告示等等。然后有租客了就需要带着租客看房子，签合同，以后房子出了任何问题，都需要找房东解决。比如，灯泡坏了，厕所堵了，房间漏水等等。所有的工作都是房东一个人来完成。
现在可以有中介了。那么中介可以把房东所有的工作代替。中介同时对租客和房东负责，负责帮房东找客源，负责收缴房租。负责日常的问题解决。把租房这个功能交给中介来干。可以更高效的完成这些工作，而且可以让房东少去了很多麻烦。
中介就相当于代理。
那么程序设计中的代理是可以做哪些工作？

代理的目的可以把目标方法增强，把非核心代码抽调出来，统一进行管理。就类似于中介手里总会有客源和房源，这样房东就减少了工作量，租客也很快就能找到自己合适的房子。所谓的目标方法增强就是可以在功能执行前，和执行以后做一些别的操作。比如，在方法执行前，先进性权限校验。方法执行以后，进行日志记录。

二、静态代理和动态代理

1.静态代理

以租房为例，实现静态代理：
创建房东接口：

public interface FangDong {
    void zufang();
}

实现接口：

public class FangdongImpl implements FangDong {
    @Override
    public void zufang() {
        System.out.println("房东租房..." );
    }
}

创建代理对象：

// 代理
public class FangdongProxy {

    // 目标对象
    private FangDong fangDong;

    public FangdongProxy(FangDong fangDong){
        this.fangDong = fangDong;
    }

    void zufang(){
        // 前置增强
        System.out.println("前:发传单,找客源" );

        // 房东租房
        fangDong.zufang();

        // 后置增强
        System.out.println("后:签合同" );
    }
}

实现租房功能的测试

    // 开始租房
    public static void main(String[] args) {
        // 找代理
        FangdongProxy proxy = new FangdongProxy(new FangdongImpl( ));
        // 真正租房
        proxy.zufang();
    }

执行成功

通过静态代理模式模拟实现了当房东租房的时候，先发了传单，租房完成后签了合同。然而静态代理有弊端。即只能创建一个代理，做一件事，一个代理不能做多件事。代码的重用性不高。无论是租房子，卖车子，还是别的功能。每次都需要新建一个新的代理，就像房产中介，不可以去卖车一样。

2.动态代理

如果可以实现。不管我要什么功能，我只需要创建一个代理，就可以完全的适用于所有的业务，那样就完美了。动态代理就可以实现这种功能。动态代理可以根据代理目标类，动态的产生代理对象。即实现动态代理之后，完全不需要再自己手动创建很多的代理类，而是根据我当前的需求，自动产生代理对象。这就是动态代理。

动态代理的实现有两种方案：

1. JDK动态代理 2) CGLIB动态代理.

JDK的动态代理

JDK代理,是Java自有技术,无需导入依赖包.
案例：使用动态代理实现房东租房
接着上边的基础代码实现，首先创建JDK动态代理类

public class JDKProxy implements InvocationHandler {

    // 目标类
    private Object target;

    // 指定目标对象
    public JDKProxy(Object target){
        this.target  = target;
    }


    /**
     * @param proxy 被代理对象
     * @param method 目标方法
     * @param args   目标方法的参数
     * @return       目标方法的返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 目标方法前:
        System.out.println("前置增强" );

        // 目标方法执行
        Object obj = method.invoke(target,args);
       //目标方法后
        System.out.println("后置增强" );
        return obj;
    }
}

测试：

    public static void main(String[] args) {
        // 目标类的类加载器
        ClassLoader classLoader = FangdongImpl.class.getClassLoader( );
        // 目标类的实现的所有接口
        Class<?>[] interfaces = FangdongImpl.class.getInterfaces( );
        // 目标方法执行处理器
        JDKProxy handler = new JDKProxy(new FangdongImpl( ));

        /**
         * 参数1: 目标类的类加载器
         * 参数2: 目标类的所实现的所有接口
         * 参数3:  自己实现的目标方法处理器
         */
        FangDong fangDong = (FangDong) Proxy.newProxyInstance(classLoader, interfaces, handler);

        fangDong.zufang();
    }

通过演示可以得出。动态代理可以动态的产生代理对象。

CJLIB动态代理技术

CGLIB动态代理技术,又叫字节码增强.动态产生代理对象,可以代理接口也可以代理实现类.CGLIB是第三方技术,spring框架中已经整合了cglib的技术,所以只需导入spring-aop的依赖即可.
案例: 使用动态代理技术,动态的产生汽车厂商的代理
创建代理对象

public class MyCglibInterceptor implements MethodInterceptor {

    // cglib的增强器
    private Enhancer enhancer = new Enhancer();

    // 创建拦截器时,指定目标类的字节码
    public MyCglibInterceptor(Class clazz){
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
    }

    // 提供一个获得代理对象的方法
    public Object createProxyBean(){
        return enhancer.create();
    }


    /**
     * @param target 目标对象
     * @param method
     * @param args   目标方法的参数
     * @param methodProxy 目标方法的代理对象
     * @return 目标方法的返回值
     * @throws Throwable
     */
    @Override
    public Object intercept(Object target, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        // 目标方法前:
        System.out.println("前置增强:权限校验,或者事务开启" );

        // 目标方法执行
        Object ret = methodProxy.invokeSuper(target,args);

        // 目标方法前:
        System.out.println("后置增强:日志记录,或者事务提交" );
        return ret;
    }
}

创建测试类

    public static void main(String[] args) {

        // 此处,只需要将其他类字节码文件传入此处
        // 即可得到其他类的代理对象
        MyCglibInterceptor interceptor = new MyCglibInterceptor(CarFactoryImpl.class);
        CarFactoryImpl carFactory = (CarFactoryImpl) interceptor.createProxyBean( );
        carFactory.saleCar();
    }

---

总结

无论是静态代理还是动态代理，其目的都是对目标方法功能的增强
代理技术一般在开发中使用的场景为

• 日志记录
• 事务开启与提交
• 性能检测
• 权限校验
• 等等

静态代理和动态代理的区别
静态代理只能代理一个目标类，动态代理可以自动生成不同的代理，应对不同的被代理对象。

两种动态代理实现方式的区别在于：
JDK实现的动态代理只能代理接口，即代理目标类必须要有接口才可以实现动态代理。
CJLIB实现的动态代理可以在没有接口的情况下实现动态代理。