代理模式：Proxy Pattern，也叫委托模式，为其他对象提供一种代理来控制这个对象的访问，在某些情况下一个对象不适合或不能直接引用另一个对象，而代理对象可以在客户类和目标对象直接起到中介的对象

Provide a surrogate or placerholder for another object to control access to it：为其他对象提供一种代理以控制对这个对象的访问

代理模式的作用：

  • 功能增强：其中目标对象实现真正的功能，但是代理对象可以对目标对象的功能做进一步的扩充
  • 控制访问：在开发中存在 a 类需要调用 c 类的方法，完成某一个功能，但是 c 禁止 a 调用。这时，可以在 a 和 c 之间创建一个 b 类代理，a 类访问 b 类，b 类访问 c 类。例如：登录的时候需要进行短信验证，这个时候代理就是中国移动的子公司来完成短信的发送功能

代理模式的核心要素：代理类 = 目标类 + 额外功能 + 目标类实现相同的接口

静态代理

静态代理：是在程序运行前就已经存在代理类的字节码文件，静态代理通常是对原有业务逻辑的扩充，通过让代理类持有真实对象，在代理类的源代码中调用被代理类方法来添加我们需要的业务逻辑

缺点：

  • 如果有多个类需要代理，那么就需要创建多个代理类分别代理目标对象，工作量较大，不利于维护
  • 当接口的方法增加或修改的时候，很多类都需要修改。因为，目标类和代理类都实现了相同的接口

静态代理的使用步骤：

  1. 创建接口
  2. 创建目标类
  3. 创建代理类
  4. 测试 ```java // 创建接口 public interface Animal{ void eat(); }

// 创建目标类 class Cat implements Animal{ @Override public void eat() { System.out.println(“Cat eat fish!”); } }

// 创建代理类 class CatProxy implements Animal{ private Animal animal;

  1. public CatProxy(Animal animal) {
  2.     this.animal = animal;
  3. }
  5. @Override
  6. public void eat() {
  7.     // 对目标类进行增强
  8.     System.out.println("eat start!");
  9.     // 调用目标方法
  10.     animal.eat();
  11. }

}

// 测试 public static void main(String[] args) { // 被增强的类 Cat cat = new Cat(); // 创建代理类 Animal catProxy = new CatProxy(cat); // 调用被增强的方法 catProxy.eat(); }

  2. <a name="XxHsV"></a>
  3. #### jdk 动态代理
  5. jdk 动态代理的本质：在运行时动态生成接口的实现类（底层使用了反射）<br />1、Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)：生成代理类的实例
  7. - loader：提供一个类加载器，用于加载代理对象
  8. - interfaces：代理对象需要实现的接口
  9. - h：代理类中的方法执行时，会调用 h.invoke() 方法执行
  11. 2、InvocationHandler.invoke(Object proxy, Method method, Object[] args)：每一个代理类的调用程序都必须实现 InvocationHandler 接口，并且每个代理类的实例都关联到了实现该接口的动态代理类调用处理程序中，当我们通过动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现 InvocationHandler 接口类的 invoke 方法来调用
  13. - proxy：代理类的实例
  14. - method：需要调用的某个对象真实的方法的 Method 对象
  15. - args：传递的方法参数
  16. ```java
  17. public class DynamicProxyDemo1 {
  18.     interface Inter1 {
  19.         void play();
  20.     }
  22.     interface Inter2 {
  23.         String talk(int i, String str);
  24.     }
  26.     public static void main(String[] args) {
  27.         // 当前线程的应用类加载器
  28.         ClassLoader loader = Thread.currentThread().getContextClassLoader();
  29.         // 接口数组
  30.         Class<?>[] inters = new Class[]{Inter1.class, Inter2.class};
  32.         // 动态创建一个实现了inter1接口和inter2接口的实例
  33.         Object o = Proxy.newProxyInstance(loader, inters, (proxy, method, values) -> {
  34.             String name = method.getName();
  35.             System.out.println("当前执行的方法：" + name);
  36.             System.out.println("传入的参数：" + Arrays.toString(values));
  37.             System.out.println(method.getGenericReturnType().getTypeName());
  39.             if ("java.lang.String".equalsIgnoreCase(method.getGenericReturnType().getTypeName())){
  40.                 return "世界";
  41.             }
  42.             return null;
  43.         });
  45.         ((Inter1) o).play();
  46.         String talk = ((Inter2) o).talk(12, "世界");
  47.         System.out.println(talk);
  49.         // 打印jdk动态代理生成的对象
  50.         // org.example.structure.proxy.$Proxy0
  51.         System.out.println(o.getClass().getName());
  52.     }
  53. }

上述程序的执行结果为：
image.png
很明显，Java 的 Proxy.newProxyInstance 可以根据指定的接口直接在运行时动态生成实例，但单纯的这一特性并没有什么大用，但是结合上面的静态代理模式，就可以在运行时自动生成静态代理类，然后使用静态代理类进行对目标类进行增强。

  1. public class DynamicProxyDemo {
  3.     public static void main(String[] args) {
  4.         // 1.创建目标对象
  5.         Traffic car = new Car();
  6.         // 2.获取动态代理对象
  7.         Traffic proxy = (Traffic) new JdkProxy(car).getProxy();
  8.         // 3.使用代理对象执行相关方法
  9.         proxy.run();
  10.     }
  12.     interface Traffic {
  13.         void run();
  14.     }
  16.     static class Car implements Traffic {
  17.         @Override
  18.         public void run() {
  19.             System.out.println("汽车在公路上行驶！");
  20.         }
  21.     }
  23.     static class JdkProxy implements InvocationHandler {
  24.         // 目标对象
  25.         private Object target;
  27.         public JdkProxy(Object target) {
  28.             this.target = target;
  29.         }
  31.         /**
  32.          * 用于书写额外功能
  33.          *
  34.          * @param proxy  代表代理对象
  35.          * @param method 接口方法
  36.          * @param args   原始方法的参数
  37.          * @return
  38.          * @throws Throwable
  39.          */
  40.         @Override
  41.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  42.             before();
  43.             Object result = method.invoke(target, args);
  44.             after();
  45.             return result;
  46.         }
  48.         private void after() {
  49.             System.out.println("前置业务操作...");
  50.         }
  52.         private void before() {
  53.             System.out.println("前置业务操作...");
  54.         }
  56.         public Object getProxy() {
  57.             return Proxy.newProxyInstance(target.getClass().getClassLoader(),
  58.                     target.getClass().getInterfaces(), this);
  59.         }
  60.     }
  61. }

cglib 动态代理

cglib 动态代理，基于继承，即在运行时动态生成当前类的子类，然后对当前类进行增强（采用asm字节码技术实现）

导入 cglib 的依赖：

  1. <dependency>
  2.     <groupId>cglib</groupId>
  3.     <artifactId>cglib</artifactId>
  4.     <version>3.3.0</version>
  5. </dependency>

简单使用：

  1. public class CglibProxyDemo {
  2.     public static void main(String[] args) {
  3.         // 先创建目标对象
  4.         User user = new User();
  6.         // 创建增强类对象
  7.         Enhancer enhancer = new Enhancer();
  8.         // 设置需要增强的类型
  9.         enhancer.setSuperclass(User.class);
  10.         // 设置回调函数
  11.         enhancer.setCallback(new MethodInterceptor() {
  12.             /**
  13.              * 支持两种方式访问原对象的方法：
  14.              *   1.反射方式：method.invoke()
  15.              *   2.快速访问原始类的代理类：methodProxy.invoke()【推荐】
  16.              * @param o 代表Cglib生成的动态代理类
  17.              * @param method 代理类中被拦截的方法
  18.              * @param objects 拦截方法的参数
  19.              * @param methodProxy 快速访问目标类的原始方法，即代理类父类的方法
  20.              * @return
  21.              * @throws Throwable
  22.              */
  23.             @Override
  24.             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  25.                 System.out.println("前置方法");
  26. //                Object invoke = methodProxy.invoke(user, objects);
  27.                 Object invoke = method.invoke(user, objects);
  28.                 System.out.println("后置方法");
  30.                 System.out.println(o.getClass().getName());
  31.                 System.out.println(methodProxy.getClass().getName());
  32.                 return invoke;
  33.             }
  34.         });
  36.         // 创建增强类
  37.         User o = (User) enhancer.create();
  40.         String s = o.get("世界", 2);
  41.         System.out.println(s);
  42.     }
  44.     static class User {
  45.         public String get(String s, Integer integer) {
  46.             System.out.println("目标方法执行!");
  47.             return s + integer;
  48.         }
  49.     }
  50. }

输出：
image.png

使用Cglib实现动态代理：

  1. public class CglibProxyDemo1 {
  2.     public static void main(String[] args) {
  3.         // 1.创建目标对象
  4.         User user = new User();
  5.         // 2.创建增强器
  6.         CglibProxy<User> cglibProxy = new CglibProxy<>(user);
  7.         // 3.获取代理对象
  8.         User proxy = cglibProxy.getProxy();
  10.         String say = proxy.say(10, "世界");
  11.         System.out.println(say);
  12.     }
  14.     static class CglibProxy<T> implements MethodInterceptor {
  16.         private final T t;
  18.         public CglibProxy(T t) {
  19.             this.t = t;
  20.         }
  22.         @Override
  23.         public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  24.             // 前置增强
  25.             before(method, objects);
  27.             // 目标方法执行
  28.             Object ret = methodProxy.invoke(t, objects);
  30.             // 后置增强
  31.             after(ret, method, objects);
  32.             return ret;
  33.         }
  35.         // 获得代理对象
  36.         @SuppressWarnings("unchecked")
  37.         public T getProxy() {
  38.             // 1.创建Enhancer
  39.             Enhancer enhancer = new Enhancer();
  40.             // 2.设置目标类的类型
  41.             enhancer.setSuperclass(t.getClass());
  42.             // 3.设置增强回调
  43.             enhancer.setCallback(this);
  45.             return (T) enhancer.create();
  46.         }
  48.         private void after(Object ret, Method method, Object[] objects) {
  49.             System.out.println("方法的返回值：" + ret);
  50.         }
  52.         private void before(Method method, Object[] objects) {
  53.             System.out.println("执行的方法：" + method.getName());
  54.             System.out.println("传入的参数：" + Arrays.toString(objects));
  55.         }
  56.     }
  58.     static class User {
  59.         public String say(Integer a, String b) {
  60.             System.out.println("执行目标方法！");
  61.             return "返回值";
  62.         }
  63.     }
  64. }

输出：
image.png

Spring 动态代理

image.png
Spring 中代理的选择原则：

  • 当 Bean 有实现接口时，选用 JDK 动态代理
  • 当 Bean 没有实现接口时，Spring 会选用 CGLIB 动态代理
  • 强制设置使用 CGLIB 动态代理：

mybatis 动态代理

https://weread.qq.com/web/reader/8aa3282071f94a868aa8f52kd8232f00235d82c8d161fb2