前言

一、代理的三种实现方式

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

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

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

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

1、静态代理

 2、基于 JDK 的动态代理

 3、基于 Cglib 的动态代理

总结

---

前言

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

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

其实代理这个知识点在几乎写了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 】元

---

总结

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

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

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