Java实现动态代理的设计模式

前言

一、代理的三种实现方式

二、几种代理实现方式的区别

1.静态代理和动态代理的区别

2.JDK 动态代理和 Cglib 动态代理的区别

三、编写小案例来描述几种代理方式

1、静态代理

 2、基于 JDK 的动态代理

 3、基于 Cglib 的动态代理

总结

---

前言

代理(Proxy)是一种设计模式，提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。（百度抄的）。

通俗来讲，代理就是帮别人去做事，在源代码的基础上帮其完成一些额外的功能。以此来达到减少冗余代码、增强代码专一性的目的。有时候不方便改别人的代码，但是又想要在其代码上增加其他的功能，便可以通过代理来实现。

其实代理这个知识点在CSDN几乎写了N多篇了，我再来走这个路是对自己学习过程中一些知识点的总结，也是可以分享下自己的一些理解（有误的话欢迎指出~虚心指教）。

---

一、代理的三种实现方式

在Java中，代理可以通过静态代理、动态代理来实现；

而动态代理的又可以分为

1.基于 JDK 的动态代理实现

2基于 Cglib 的动态代理实现

二、几种代理实现方式的区别

下面分开两种情况来说明

1.静态代理和动态代理的区别

静态代理，是指用实现共同接口的方式，在重写方法时，调用被代理的方法，然后在调用前后添加额外功能的代码。其类图如下：

上图定义了一个IObject，里面有一个doSomething方法，然后具体的对象，和代理对象都去实现这个接口。代理对象持有具体对象的实例，然后在重写接口方法的时候，调用具体对象的方法来达到拓展被代理对象代码功能的目地。 

可以发现，静态代理每次需要增强（代理）一个方法，都必须重写这个具体类和代理类，新增对应的方法去实现。这样就造成了维护上的困难。而动态代理正是解决这样的问题，动态代理的代理对象是动态生成的，而且所有需要代理的方法都在统一的一个方法里去操作（InvocationHandle invoke），这样使类的职责更加单一，所以这是和静态代理最大的区别之处。

2.JDK 动态代理和 Cglib 动态代理的区别

动态代理，通过传过来的被代理对象，动态地为其生成一个代理类，然后在统一的代理方法里，在调用目标对象前后实现其他的业务逻辑。

动态代理分为 JDK 代理和 Cglib代理两种实现方式。

JDK动态代理要求：

1.被代理类必须要实现至少一个接口。此时代理类和被代理类实现相同的接口。

Cglib动态代理要求

1.被代理类不能用final修饰，方法也不能被final，static或private修饰

综上，JDK代理是针对接口来代理的，而Cglib则是生成对应的子类，去覆盖目标类的方法来实现。所以前者必须有接口，后者要注意类的访问权限和final修饰符的使用。

在spring的AOP中，动态代理的策略可以通过AopProxyFactory的AdvisedSupport来配置，默认策略为：如果目标对象有接口，则使用JDK动态代理，如果目标对象没有接口，则使用Cglib动态代理。 

三、编写小案例来描述几种代理方式

场景：

1.有家商店以前总是自己进货，自己销售商品。后来过了一段时间，商店越做越大，业务扩展得忙不过来了，就找了个代理商来帮商店销售某一些商品。然后商店不管这部分商品的销售，让代理来做，代理帮商店销售商品，从中抽取一部分利润。

各个代理方式的代码实现如下：

先定义通用的商店接口，和具体的商店类。它们都有销售的方法。

/**
 * 商店接口.
 * 模拟被代理
 * 方法：销售商品
 *
 * @author linzp
 * @version 1.0.0
 * CreateDate 2020/10/7 0:19
 */
public interface IShop {

    /**
     * 销售商品.
     *
     * @param money
     */
    void shellSomething(double money);
}

/**
 * 商店实现类，实现具体的销售方法.
 *
 * @author linzp
 * @version 1.0.0
 * CreateDate 2020/10/7 0:22
 */
public class ShopImpl implements IShop {

    /**
     * 销售商品，输出商品价格.
     * @param money
     */
    @Override
    public void shellSomething(double money) {
        System.out.println("出售了商品，商店获得利润为【 "+money+" 】元");
    }
}

---

 

 

1、静态代理

新增一个代理类，实现同样的接口，持有目标对象，实现代理方法

/**
 * 商店的代理销售人员，代理销售商店的商品.
 * （静态代理实现）
 *
 * @author linzp
 * @version 1.0.0
 * CreateDate 2020/10/7 0:26
 */
public class ShopSheller implements IShop {

    /**
     * 被代理的目标对象.
     */
    private IShop iShop;

    public ShopSheller(){
        iShop = new ShopImpl();
    }

    /**
     * 代理销售商品.
     * 从中抽取了部分利润.
     *
     * @param money
     */
    @Override
    public void shellSomething(double money) {
        System.out.println("代理销售了商品，价格为"+"【 "+money+" 】元");
        System.out.println("代理抽取了5%的利润...");
        money = money - money*0.05;
        iShop.shellSomething(money);
    }
}

测试类

/**
 * 测试静态代理的方式.
 *
 * @author linzp
 * @version 1.0.0
 * CreateDate 2020/10/7 0:36
 */
public class ProxyDemo {

    public static void main(String[] args) {
        //未被代理
        IShop shop = new ShopImpl();
        System.out.println("========未被代理==========");
        shop.shellSomething(1000);
        //被代理
        shop = new ShopSheller();
        System.out.println("========被静态代理==========");
        shop.shellSomething(1000);
    }
}

输出结果如下：

========未被代理==========
出售了商品，商店获得利润为【 1000.0 】元
========被静态代理==========
代理销售了商品，价格为【 1000.0 】元
代理抽取了5%的利润...
出售了商品，商店获得利润为【 950.0 】元

 2、基于 JDK 的动态代理

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

/**
 * 基于jdk的动态代理实现.
 *
 * @author linzp
 * @version 1.0.0
 * CreateDate 2020/10/7 0:44
 */
public class JdkProxy implements InvocationHandler {

    /**
     * 目标对象.
     */
    private Object target;

    /**
     * 构造方法.
     *
     * @param target
     */
    public JdkProxy(Object target) {
        this.target = target;
    }

    /**
     * 获取代理对象.
     *
     * @return
     */
    public Object getProxyInstance(){
        Object proxyInstance = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
        return  proxyInstance;
    }

    /**
     * 统一的代理方法.
     * 在此处代理内容，需要说明的是，该类所有的方法都会走这里，
     * 由于目标类只有一个测试方法，这里不作区分判断。
     *
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        double money = Double.parseDouble(args[0].toString());
        System.out.println("代理销售了商品，价格为"+"【 "+money+" 】元");
        System.out.println("代理抽取了5%的利润...");
        money = money - money*0.05;
        args[0] = money;
        return method.invoke(target, args);
    }
}

 JDK代理方式的测试类

/**
 * 测试jdk实现的动态代理.
 *
 * @author linzp
 * @version 1.0.0
 * CreateDate 2020/10/7 0:54
 */
public class TestJdkProxy {
    public static void main(String[] args) {
        IShop iShop = new ShopImpl();
        IShop proxyInstance = (IShop) new JdkProxy(iShop).getProxyInstance();
        proxyInstance.shellSomething(1000);
    }
}

 测试结果输出：

代理销售了商品，价格为【 1000.0 】元
代理抽取了5%的利润...
出售了商品，商店获得利润为【 950.0 】元

 3、基于 Cglib 的动态代理

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

import java.lang.reflect.Method;

/**
 * 基于cglib的动态代理.
 * 注意事项：
 * 1.被代理对象不能用final修饰
 * 2.被代理方法不能被static，final修饰
 * 3.被代理方法权限要高于private，可被继承才行
 *
 * @author linzp
 * @version 1.0.0
 * CreateDate 2020/10/7 22:38
 */
public class CglibProxy implements MethodInterceptor {

    /**
     * 被代理对象.
     */
    private Object target;

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

    /**
     * 获取代理对象.
     *
     * @return
     */
    public Object getProxyInstance(){

        //1.工具类
        Enhancer enhancer = new Enhancer();

        //2.设置父类
        enhancer.setSuperclass(ShopImpl.class);

        //3.设置回调函数
        enhancer.setCallback(this);

        //4.创建代理对象
        Object proxyObject = enhancer.create();

        return proxyObject;

    }

    /**
     * 回调函数.
     * 统一的代理方法，执行代理的内容..
     * 在此处代理内容，需要说明的是，该类所有的方法都会走这里，
     * 由于目标类只有一个测试方法，这里不作区分判断。
     *
     * @param o 代理对象
     * @param method 被代理方法
     * @param objects 执行的参数
     * @param methodProxy
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        double money = Double.parseDouble(objects[0].toString());
        System.out.println("代理销售了商品，价格为"+"【 "+money+" 】元");
        System.out.println("代理抽取了5%的利润...");
        money = money - money*0.05;
        objects[0] = money;

        //执行被代理方法.
        return methodProxy.invoke(target, objects);
    }
}

测试类  

/**
 * 测试基于cglib的动态代理.
 *
 * @author linzp
 * @version 1.0.0
 * CreateDate 2020/10/7 22:50
 */
public class TestCglib {

    public static void main(String[] args) {

        ShopImpl shop = new ShopImpl();

        ShopImpl shopProxy =(ShopImpl) new CglibProxy(shop).getProxyInstance();

        shopProxy.shellSomething(1000);
    }
}

 测试输出结果：

代理销售了商品，价格为【 1000.0 】元
代理抽取了5%的利润...
出售了商品，商店获得利润为【 950.0 】元

---

总结

代理模式其实和装饰模式差不多，在代码和类的层面上几乎一致，但是两者实现的是不同的目标。

装饰模式是以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，指增强自己的功能为主。

代理模式是对代理的对象施加控制，并不提供对象本身的增强功能，通俗说就是让别人帮忙做一些额外的不太重要的事情。