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

静态代理

  1. interface ClothFactory {
  2.     void produceCloth();
  3. }
  5. // 被代理类
  6. class NikeClothFactory implements ClothFactory {
  7.     @Override
  8.     public void produceCloth() {
  9.         System.out.println("Nike工厂生产一批运动服");
  10.     }
  11. }
  13. // 代理类
  14. class ProxyClothFactory implements ClothFactory {
  15.     private ClothFactory factory;    // 用被代理类对象进行实例化
  17.     public ProxyClothFactory(ClothFactory factory) {
  18.         this.factory = factory;
  19.     }
  21.     @Override
  22.     public void produceCloth() {
  23.         System.out.println("代理工厂做一些准备工作");
  24.         factory.produceCloth();
  25.         System.out.println("代理工厂做一些后续的收尾工作");
  26.     }
  27. }
  29. public class StaticProxyTest {
  30.     public static void main(String[] args) {
  31.         // 创建被代理类的对象
  32.         ClothFactory nike = new NikeClothFactory();
  33.         // 创建代理类的对象
  34.         ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
  36.         proxyClothFactory.produceCloth();
  37.     }
  38. }
  • 静态代理的缺点
    • 代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。
    • 每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理

      动态代理

      之前为大家讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能

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

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

动态代理的实现
需要解决的两个主要问题

  1. 如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象

通过 Proxy.newProxyInstance() 实现

  1. 当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a

通过 InvocationHandler 接口的实现类及其方法invoke()
动态代理相关的API

  • Proxy：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。
  • 提供用于创建动态代理类和动态代理对象的静态方法

**static Class<?> getProxyClass(ClassLoader loader, Class<?>... interface)**
创建一个动态代理类所对应的Class对象
**static Object newProxyInstance(ClassLoader loader, Class<?>... interface, InvocationHandler h)**
直接创建一个动态代理对象

动态代理实现步骤

  1. 创建一个实现接口 InvocationHandler 的类，它必须实现invoke方法，以完成代理的具体操作
  2. 创建被代理类以及接口
  3. 通过Proxy的静态方法newProxyInstance(ClassLoader loader, Class<?>…interface, InvocationHandler h)创建一个接口代理

  4. 通过代理类的实例调用被代理类的方法 ```java /*

    • 动态代理的举例 */ interface Human { String getBelief();

      void eat(String food); }

// 被代理类 class SuperMan implements Human { @Override public String getBelief() { return “I believe I can fly!”; }

  1. @Override
  2. public void eat(String food) {
  3.     System.out.println("我喜欢吃" + food);
  4. }

}

class HumanUtil { public void method1() { System.out.println(“===============通用方法一===============”); }

  1. public void method2() {
  2.     System.out.println("===============通用方法二===============");
  3. }

}

/ 要想实现动态代理，需要解决的问题？ 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。 / class ProxyFactory { // 调用此方法，返回一个代理类的对象。解决问题一 public static Object getProxyInstance(Object obj) { // obj:被代理类的对象 MyInvocationHandler handler = new MyInvocationHandler(); handler.bind(obj); return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler); } }

class MyInvocationHandler implements InvocationHandler { private Object obj; // 需要使用被代理类的对象进行赋值

  1. public void bind(Object obj) {
  2.     this.obj = obj;
  3. }
  5. // 当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
  6. // 将被代理类要执行的方法a的功能就声明在invoke()中
  7. @Override
  8. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  9.     HumanUtil util = new HumanUtil();
  10.     util.method1();
  12.     // method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
  13.     // obj:被代理类的对象
  14.     Object returnValue = method.invoke(obj, args);
  16.     util.method2();
  17.     //method方法的返回值就作为当前类中的invoke()的返回值。
  18.     return returnValue;
  19. }

}

public class ProxyTest { public static void main(String[] args) { SuperMan superMan = new SuperMan();

  1.     // proxyInstance:代理类的对象
  2.     Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
  4.     // 当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
  5.     String belief = proxyInstance.getBelief();
  6.     System.out.println(belief);
  7.     proxyInstance.eat("四川麻辣烫");
  9.     System.out.println("*****************************");
  11.     NikeClothFactory nikeClothFactory = new NikeClothFactory();
  12.     ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory
  13.         .getProxyInstance(nikeClothFactory);
  14.     proxyClothFactory.produceCloth();
  15. }

}

  1. **动态代理与AOP**
  3. - 使用 Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理。
  4. - 这种动态代理在 AOP 中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异：
  5. - AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理
  7. ![](https://cdn.nlark.com/yuque/0/2020/png/1379492/1590769779635-a4b882fc-ab11-490f-9850-1c7b0e22dfe0.png#height=235&id=BypSD&originHeight=449&originWidth=573&originalType=binary&ratio=1&size=0&status=done&style=none&width=300)
  8. ```java
  9. // 公共接口
  10. interface Dog {
  11.     void info();
  12.     void run();
  13. }
  15. // 被代理类
  16. class HuntingDog implements Dog {
  17.     @Override
  18.     public void info() {
  19.         System.out.println("我是一只猎狗");
  20.     }
  21.     @Override
  22.     public void run() {
  23.         System.out.println("我跑的很快");
  24.     }
  25. }
  27. // 通用方法
  28. class DogUtils {
  29.     public void method1() {
  30.         System.out.println("=======通用方法一=======");
  31.     }
  32.     public void method2() {
  33.         System.out.println("=======通用方法二=======");
  34.     }
  35. }
  37. // 动态代理实现
  38. class MyInvocationHandler1 implements InvocationHandler {
  39.     // 需要被代理的对象
  40.     private Object target;
  42.     public void SetTarget(Object target) {
  43.         this.target = target;
  44.     }
  46.     // 当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
  47.     // 将被代理类要执行的方法a的功能就声明在invoke()中
  48.     @Override
  49.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  50.         DogUtils dogUtils = new DogUtils();
  51.         // 执行DogUtils对象中的method1
  52.         dogUtils.method1();
  54.         // 通过obj对象来调用执行method方法
  55.         Object result = method.invoke(target, args);
  57.         // 执行DogUtils对象中的method2
  58.         dogUtils.method2();
  59.         return result;
  60.     }
  61. }
  63. // 动态代理类
  64. class MyProxyFactory1 {
  65.     //为target生成动态代理对象
  66.     public static Object getProxy(Object target) {
  67.         // 创建一个MyInvocationHandler对象
  68.         MyInvocationHandler1 handler = new MyInvocationHandler1();
  69.         // 为MyInvocationHandler设置target对象
  70.         handler.SetTarget(target);
  72.         //创建返回一个动态代理对象
  73.         return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
  74.                                       target.getClass().getInterfaces(), handler);
  75.     }
  76. }
  77. public class AOPTest {
  78.     public static void main(String[] args) {
  79.         Dog target = new HuntingDog();
  80.         Dog dog = (Dog) MyProxyFactory1.getProxy(target);
  81.         dog.info();
  82.         dog.run();
  83.     }
  84. }