动态代理

本片文章原名（出自我的博客）：实例理解JDK动态代理和Cglib动态代理及其区别 (opens new window)

代理模式我的博客：https://blog.csdn.net/qq_42937522/article/details/105067563 (opens new window)

可结合参看：JavaGuide-代理模式详解：静态代理+JDK/CGLIB 动态代理实战 (opens new window)

代理模式原理

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

作用

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

应用场景

1）远程代理（Remote Proxy）

为一个位于不同的地址空间的对象提供一个本地的代理对象。这个不同的地址空间可以是在同一台主机中，也可是在另一台主机中。也即为不同地址空间提供局部的代表。

2）虚拟代理（Virtual Proxy）

根据需要创建开销很大的对象。如果需要创建一个资源消耗较大的对象，先创建一个消耗相对较小的对象来表示，真实对象只在需要时才会被真正创建。

3）保护代理（Protection Proxy）

控制对原始对象的访问。保护代理用于对象应该有不同的访问权限的时候。

4）智能指引（Smart Reference）

取代了简单的指针，它在访问对象时执行一些附加操作。

5）Copy-on-Write代理

它是虚拟代理的一种，把复制（克隆）操作延迟到只有在客户端真正需要时才执行。一般来说，对象的深克隆是一个开销较大的操作，Copy-on-Write代理可以让这个操作延迟，只有对象被用到的时候才被克隆。

动态代理

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

动态代理相比于静态代理的优点：

抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

动态代理的一般用法

JDK动态代理

使用Proxy和InvocationHandler创建动态代理

Proxy提供用于创建动态代理类和代理对象的静态方法，它也是所有动态代理类的父类。如果我们在程序中为一个或多个接口动态地生成实现类，就可以使用Proxy来创建动态代理类:如果需要为一个或多个接口动态地创建实例，也可以使用Proxy来创建动态代理实例。 Proxy提供了如下两个方法来创建动态代理类和动态代理实例:

• static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces):创建一- 个动态 代理类所对应的Class对象，该代理类将实现interfaces 所指定的多个接口。第一个ClassLoader指定生成动态代理类的类加载器。
• static Object newProxyInstance(ClassLoader loader,Class<?>I] interfaces, InvocationHandler h):直接创建一个动态代理对象， 该代理对象的实现类实现了interfaces 指定的一系列接口，执行代理对象的每个方法时都会被替换执行InvocationHandler对象的invoke方法。

实际上，即使采用第一-种方式获取了 一个动态代理类之后，当程序需要通过该代理类来创建对象时一样需要传入一个InvocationHandler对象。也就是说，系统生成的每个代理对象都有一个与之关联的InvocationHandler对象。

示例

以代理商代理生产商的产品为例（JDK代理实现）

代码实现

需要实现的接口

/**
 * 抽象接口——生产者
 */
public interface Producer {
    String produce(String product);
}

/**
 * 功能描述：化妆品生产者（被代理对象）
 **/
public class CosmeticProducer implements Producer {

    /**
     * 生产化妆品
     */
    @Override
    public String produce ( String product ) {
        System.out.println("正在生产化妆品" + product);
        return product;
    }

}

/**
 * 功能描述：提供产品的工具类
 **/
public class ProductUtil {

    public static void prepareMaterial(){
        System.out.println("代理商为生产商准备材料");
    }

    public static void sellProduct(){
        System.out.println("代理商为生产商卖产品");
    }
    
}

/**
 * 功能描述：代理对象调用被代理对象方法，所必须实现的接口
 **/
public class MyInvocationHandler implements InvocationHandler {

    /** 需要被代理的对象 */
    private Object target;

    public void setTarget ( Object target ) {
        this.target = target;
    }

    @Override
    public Object invoke ( Object proxy, Method method, Object[] args ) throws Throwable {
        //调用被代理对象方法前，执行的方法
        ProductUtil.prepareMaterial();

        //调用被代理对象的方法
        Object obj = method.invoke(target, args);

        //调用被代理对象方法后，执行的方法
        ProductUtil.sellProduct();

        //返回被代理对象方法的返回值
        return obj;
    }
}

/**
 * 功能描述：产品代理商（代理对象）
 *
 * 采用自定义的外部类MyInvocationHandler来处理
 *
 * @author RenShiWei
 * Date: 2020/6/19 16:46
 **/
public class ProductProxy {

    //***方式一：使用自定义的外部类MyInvocationHandler实现InvocationHandler接口处理***

    public ProductProxy(){}

    //通过代理对象，调用被代理对象的方法
    public static Object getProductProxy ( Object target ) {
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.setTarget(target);
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
    }

    //***方式二：使用匿名实现类来处理（可以减少类的数量）

    private Object target;

    public ProductProxy ( Object target ) {
        this.target = target;
    }

    //通过代理对象，调用被代理对象的方法
    public Object getProductProxy2 () {
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.setTarget(target);
        //这里的InvocationHandler的实现类，也可以采用接口的匿名实现类来处理，减少类的数量
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke ( Object proxy, Method method, Object[] args ) throws Throwable {
                //调用被代理对象方法前，执行的方法
                ProductUtil.prepareMaterial();

                //调用被代理对象的方法
                Object obj = method.invoke(target, args);

                //调用被代理对象方法后，执行的方法
                ProductUtil.sellProduct();

                //返回被代理对象方法的返回值
                return obj;
            }
        });
    }
}

客户端调用

/**
 * 功能描述：客户端调用
 **/
public class client {

    public static void main ( String[] args ) {
        System.out.println("**方式一：使用MyInvocationHandler**");
        Producer cosmeticProducer = new CosmeticProducer();
        Producer productProxy = (Producer) ProductProxy.getProductProxy(cosmeticProducer);
        String s = productProxy.produce("欧莱雅男士洗面奶");
        System.out.println("被代理的产品：" + s);

        System.out.println("**方式二：使用匿名InvocationHandler接口实现类的方式**");
        ProductProxy proxy = new ProductProxy(new CosmeticProducer());
        Producer productProxy2 = (Producer) proxy.getProductProxy2();
        String s1 = productProxy2.produce("兰蔻洁面乳");
        System.out.println("被代理的产品：" + s1);
    }

}

结果：

**方式一：使用MyInvocationHandler**
代理商为生产商准备材料
正在生产化妆品欧莱雅男士洗面奶
代理商为生产商卖产品
被代理的产品：欧莱雅男士洗面奶
**方式二：使用匿名InvocationHandler接口实现类的方式**
代理商为生产商准备材料
正在生产化妆品兰蔻洁面乳
代理商为生产商卖产品
被代理的产品：兰蔻洁面乳

JDK动态代理原理

为什么要叫JDK动态代理？

是因为代理对象是由JDK动态生成的，而不像静态代理方式写死代理对象和被代理类，不灵活。

JDK动态代理基于拦截器和反射来实现。

使用条件

1）必须实现InvocationHandler接口；

2）使用Proxy.newProxyInstance产生代理对象；

3）被代理的对象必须要实现接口；

源码分析

参考博客：https://blog.csdn.net/yhl_jxy/article/details/80586785 (opens new window)

Cglib动态代理

1. 引入相关依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

2. 代理类实现MethodInterceptor接口，实现intercept方法

3. 创建代理对象

//返回一个代理对象:  是 target 对象的代理对象
public Object getProxyInstance() {
    //1. 创建一个工具类
    Enhancer enhancer = new Enhancer();
    //2. 设置父类
    enhancer.setSuperclass(target.getClass());
    //3. 设置回调函数
    enhancer.setCallback(this);
    //4. 创建子类对象，即代理对象
    return enhancer.create();
}

4.客户端调用

注意事项

• 在内存中动态构建子类，注意代理的类不能为 final，否则报错java.lang.IllegalArgumentException:
• 目标对象的方法如果为 final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

示例

汽车制造厂制造汽车，代理商代理准备材料和售卖汽车

/**
 * 功能描述：被代理者 汽车制造工厂
 **/
public class CarFactory {

    public void productCar(){
        System.out.println("制造汽车");
    }

}

/**
 * 功能描述：代理类
 **/
public class ProxyFactory implements MethodInterceptor {

    //维护一个目标对象
    private Object target;

    //构造器，传入一个被代理的对象
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //返回一个代理对象:  是 target 对象的代理对象
    public Object getProxyInstance() {
        //1. 创建一个工具类
        Enhancer enhancer = new Enhancer();
        //2. 设置父类
        enhancer.setSuperclass(target.getClass());
        //3. 设置回调函数
        enhancer.setCallback(this);
        //4. 创建子类对象，即代理对象
        return enhancer.create();
    }

    //重写  intercept 方法，会调用目标对象的方法
    @Override
    public Object intercept ( Object o, Method method, Object[] objects, MethodProxy methodProxy ) throws Throwable {
        System.out.println("---代理商准备材料");
        Object returnVal = method.invoke(target,objects);
        System.out.println("---代理商售卖汽车");
        return returnVal;
    }

}

/**
 * 功能描述：客户端调用
 *
 **/
public class Client {

    public static void main ( String[] args ) {
        //获取代理对象，并强转成被代理对象的数据类型
        CarFactory proxyInstance = (CarFactory) new ProxyFactory(new CarFactory()).getProxyInstance();
        //执行代理对象的方法，触发intecept 方法，从而实现 对目标对象的调用
        proxyInstance.productCar();
    }

}

结果

---代理商准备材料
制造汽车
---代理商售卖汽车

Cglib动态代理实现原理

可以在运行期扩展Java类与实现Java接口。

现CGLIB动态代理必须实现MethodInterceptor(方法拦截器)接口

参考博客：Cglib动态代理实现原理 (opens new window)

MethodInterceptor接口源码

package net.sf.cglib.proxy;

import java.lang.reflect.Method;

public interface MethodInterceptor extends Callback {
    Object intercept(Object var1, Method var2, Object[] var3, MethodProxy var4) throws Throwable;
}

MethodInterceptor接口只有一个intercept()方法，这个方法有4个参数：

1）Object表示增强的对象，即实现这个接口类的一个对象；

2）Method表示要被拦截的方法；

3）Object[]表示要被拦截方法的参数；

4）MethodProxy表示要触发父类的方法对象；

JDK动态代理VSCglib动态代理

1.从实现方式上说

JDK动态代理利用拦截器(拦截器必须实现InvocationHanlder)加上反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

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

2.何时使用JDK或者CGLIB？

1）如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP。

2）如果目标对象实现了接口，可以强制使用CGLIB实现AOP。

3）如果目标对象没有实现了接口，必须采用CGLIB库，Spring会自动在JDK动态代理和CGLIB之间转换。

JDK代理是不需要第三方库支持，只需要JDK环境就可以进行代理CGLib必须依赖于CGLib的类库，但是它需要类来实现任何接口代理的是指定的类生成一个子类，覆盖其中的方法，是一种继承。

但是针对接口编程的环境下推荐使用JDK的代理；

3. JDK动态代理和CGLIB字节码生成的区别？

1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类。

2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，并覆盖其中方法实现增强，但是因为采用的是继承，所以该类或方法最好不要声明成final，对于final类或方法，是无法继承的。

4.CGlib比JDK快？

1）使用CGLib实现动态代理，CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，在jdk6之前比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类。

2）在jdk6、jdk7、jdk8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLIB代理效率，只有当进行大量调用的时候，jdk6和jdk7比CGLIB代理效率低一点，但是到jdk8的时候，jdk代理效率高于CGLIB代理，

总之，每一次jdk版本升级，jdk代理效率都得到提升，而CGLIB代理消息确有点跟不上步伐。

5.Spring如何选择用JDK还是CGLIB？

1）当Bean实现接口时，Spring就会用JDK的动态代理。

2）当Bean没有实现接口时，Spring使用CGlib是实现。

3）可以强制使用CGlib（在spring配置中加入<aop:aspectj-autoproxy proxy-target-class="true"/>）。

动态代理与AOP

图解