什么是代理模式？

代理模式来自于现实中的中介或代理，一个事情你不去做，找别人代你去做，就叫代理模式。

适用场景

  1. 屏蔽调用者和提供者之间的联系，操作都由中间者代理实现。
  2. 使用代理模式主要有两个目的：一是保护目标对象，二是增强目标对象。
  • 比如为了安全，内网和外网之间加网络代理
  • spring的AOP实现全部使用代理模式

    代码实现

  1. 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
  2. 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
  3. 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而使调用者无感知。

根据代理的创建时期，代理模式分为静态代理和动态代理。

  • 静态：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。
  • 动态：在程序运行时，运用反射机制动态创建而成

    静态代理

    静态代理是指在程序运行前就已经存在的编译好的代理类是为静态代理。实现静态代理有四个步骤：
  1. 定义业务接口；
  2. 被代理类实现业务接口；
  3. 定义代理类并实现业务接口；
  4. 最后便可通过客户端进行调用。（这里可以理解成程序的main方法里的内容）

我们按照这个步骤去实现静态代理。需求：在向数据库添加一个用户时前后打印日志。

  2. //抽象主题
  3. interface Service {
  4.     void add(String name);
  5. }
  7. //真实主题 实现抽象主题
  8. class ServiceImpl implements Service {
  10.     @Override
  11.     public void add(String name) {
  12.         System.out.println("添加用户:" + name);
  13.     }
  14. }
  16. /**
  17.  * 代理类 增强主题能力
  18.  * 在添加用户前后打印日志
  19.  */
  20. class Proxy implements Service {
  21.     // 被代理对象
  22.     private final Service target;
  24.     // 通过构造方法传入被代理对象
  25.     public Proxy(Service target) {
  26.         this.target = target;
  27.     }
  29.     @Override
  30.     public void add(String name) {
  31.         System.out.println("添加用户前置操作……");
  32.         target.add(name);
  33.         System.out.println("添加用户后预操作……");
  35.     }
  36. }
  39. //静态代理模式测试
  40. public class ProxyPattern {
  41.     public static void main(String[] args) {
  42.         Service service = new ServiceImpl();
  43.         Proxy proxy = new Proxy(service);
  44.         proxy.add("张三");
  45.         //输出：
  46.         //添加用户前置操作……
  47.         //添加用户:张三
  48.         //添加用户后预操作……
  49.     }
  50. }

动态代理

静态代理的一些缺点吧：

  1. 代理类和被代理类实现了相同的接口，导致代码的重复，如果接口增加一个方法，那么除了被代理类需要实现这个方法外，代理类也要实现这个方法，增加了代码维护的难度。
  2. 代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。

动态代理是指：在程序运行期间根据需要动态创建代理类及其实例来完成具体的功能，动态代理的优势：

  1. 代理类数量可以很少，
  2. 当你修改了接口中的方法时，不会影响代理类。

动态代理的实现：JDK动态代理 和 CGLIB动态代理
jdk动态代理（理解）： 使用java反射包中的类和接口实现动态代理的功能。
反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy.

cglib动态代理（了解）: cglib是第三方的工具库， 创建代理对象。
cglib的原理是继承，cglib通过继承目标类，创建它的子类，在子类中重写父类中同名的方法， 实现功能的修改。
要求目标类不能是final的， 方法也不能是final的。
cglib的要求目标类比较宽松， 只要能继承就可以了。cglib在很多的框架中使用，
比如 mybatis ，spring框架中都有使用。

JDK动态代理

JDK反射前置知识

  1. Meathod类：封装Java的方法，方法对象

    1. //获取Service的add(String name) 方法
    2. Method method = Service.class.getMethod("add", String.class);
    3. //执行ServiceImpl的add(String name) 方法，传参"张三"
    4. method.invoke(new ServiceImpl(), "张三");

    2.java.lang.reflect包下的InvocationHandler类，封装调用处理操作，就一个invoke()方法，表示代理对象要执行的功能代码，你的代理类要完成的功能就写在invoke()方法中。

    1. //Object proxy: jdk创建的代理对象，无需赋值。
    2. //Method method: 目标类中的方法，jdk提供method对象的
    3. //Object[] args： 目标类中方法的参数， jdk提供的。
    4. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;

    Java动态代理实现

  2. 创建被代理的接口和类；

  3. 创建InvocationHandler接口的实现类，在invoke方法中实现代理逻辑；
  4. 通过Proxy的静态方法newProxyInstance( ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理对象
  5. 使用代理对象。 ```java

//抽象主题 interface Service { void add(String name); }

//真实主题 实现抽象主题 class ServiceImpl implements Service { @Override public void add(String name) { System.out.println(“添加用户:” + name); } }

/**

  • 动态代理类
  • 实现java.lang.reflect.InvocationHandler接口
  • 方法：public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; *

  • @see InvocationHandler */ class ServiceInvocationHandler implements InvocationHandler { //被代理对象，Object类型 private Object target;

    public ServiceInvocationHandler(Object target) {

    1.  this.target = target;

    }

    @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

    1.  System.out.println("添加用户前置操作……");
    2.  Object ret = method.invoke(target, args);
    3.  System.out.println("添加用户后预操作……");
    4.  return ret;

    }

}

//静态代理模式测试 public class ProxyPattern { public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { //获取Service的add(String name) 方法 Method method = Service.class.getMethod(“add”, String.class); //执行ServiceImpl的add(String name) 方法，传参”张三” method.invoke(new ServiceImpl(), “张三”);

  1.     Service target = new ServiceImpl();
  2.     ServiceInvocationHandler handler = new ServiceInvocationHandler(target);
  3.     //第一个参数是指定代理类的类加载器（我们传入当前测试类的类加载器）
  4.     //第二个参数是代理类需要实现的接口（我们传入被代理类实现的接口，这样生成的代理类和被代理类就实现了相同的接口）
  5.     //第三个参数是invocation handler，用来处理方法的调用。这里传入我们自己实现的handler
  6.     Service proxyObject = (Service) Proxy.newProxyInstance(
  7.             ProxyPattern.class.getClassLoader(),
  8.             target.getClass().getInterfaces(),
  9.             handler
  10.     );
  11.     proxyObject.add("张三");
  15.     //输出：
  16.     //添加用户前置操作……
  17.     //添加用户:张三
  18.     //添加用户后预操作……
  19. }

}

  1. <a name="QEuIP"></a>
  2. ## CGLIB动态代理
  3. cglib是一个java字节码的生成工具，它动态生成一个被代理类的子类，子类重写被代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。
  5. JDK代理要求被代理的类必须实现接口，有很强的局限性。而CGLIB动态代理则没有此类强制性要求。简单的说，CGLIB会让生成的代理类继承被代理类，并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。但是如果被代理类被final修饰，那么它不可被继承，即不可被代理；同样，如果被代理类中存在final修饰的方法，那么该方法也不可被代理。
  7. **CGLIB实现：**
  9. 1. 创建Enhancer实例
  10. 1. 通过setSuperclass方法来设置目标类
  11. 1. 通过setCallback 方法来设置拦截对象
  12. 1. create方法生成Target的代理类，并返回代理类的实例
  13. ```java
  14. //抽象主题
  15. interface Service {
  16.     void add(String name);
  17. }
  19. //真实主题 实现抽象主题
  20. class ServiceImpl implements Service {
  21.     @Override
  22.     public void add(String name) {
  23.         System.out.println("添加用户:" + name);
  24.     }
  25. }
  27. /**
  28.  * 动态代理类
  29.  * 实现java.lang.reflect.InvocationHandler接口
  30.  * 方法：public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
  31.  *
  32.  * @see InvocationHandler
  33.  */
  34. class ServiceInterceptor implements MethodInterceptor {
  36.     /**
  37.      * @param obj         表示要进行增强的对象
  38.      * @param method      表示拦截的方法
  39.      * @param objects     数组表示参数列表，基本数据类型需要传入其包装类型，如int-->Integer、long-Long、double-->Double
  40.      * @param methodProxy 表示对方法的代理，invokeSuper方法表示对被代理对象方法的调用
  41.      * @return 执行结果
  42.      * @throws Throwable 异常
  43.      */
  44.     @Override
  45.     public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  46.         System.out.println("添加用户前置操作……");
  48.         // 注意这里是调用invokeSuper而不是invoke，否则死循环;
  49.         // methodProxy.invokeSuper执行的是原始类的方法;
  50.         // method.invoke执行的是子类的方法;
  51.         Object result = methodProxy.invokeSuper(obj, objects);
  53.         System.out.println("添加用户后置操作……");
  54.         return result;
  55.     }
  57. }
  59. //静态代理模式测试
  60. public class ProxyPattern {
  61.     public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
  62.         // 通过CGLIB动态代理获取代理对象的过程
  63.         // 创建Enhancer对象，类似于JDK动态代理的Proxy类
  64.         Enhancer enhancer = new Enhancer();
  65.         // 设置目标类的字节码文件
  66.         enhancer.setSuperclass(ServiceImpl.class);
  67.         // 设置回调函数
  68.         enhancer.setCallback(new ServiceInterceptor());
  69.         // create方法正式创建代理类
  70.         Service userDao = (Service) enhancer.create();
  71.         // 调用代理类的具体业务方法
  72.         userDao.add("张三");
  75.         //输出：
  76.         //添加用户前置操作……
  77.         //添加用户:张三
  78.         //添加用户后预操作……
  79.     }
  81. }