Spring代理模式

为什么要学习代理模式？

因为AOP的底层机制就是动态代理！

 

代理模式分为：

1. 静态代理

   1. 静态代理角色分析

   1. 1. 抽象角色：一般使用接口或者抽象类来实现
      2. 真实角色：被代理的角色
      3. 代理角色：代理真实角色，代理真实角色后，一般会做一些附属操作
      4. 客户：使用代理角色来进行一些操作

   2. 代码实现

      /**
       * Rent.java    抽象角色：租房
       */
      public interface Rent {
          public void rent();
      }
       
       
      /**
       *Host.java 真实角色：房东，房东要出租房子
       */
      public class Host implements Rent{
       
          @Override
          public void rent() {
              System.out.println("房屋出租");
          }
      }
       
       
      /**
       * Proxy.java   代理角色：中介
       *  代理真实角色后，一般会做一些附属操作
       */
      public class Proxy implements Rent{
          private Host host;
       
          public Proxy() {
          }
       
          public Proxy(Host host) {
              this.host = host;
          }
       
          /**
           * 租房
           */
          @Override
          public void rent() {
              seeHouse();
              host.rent();
              fare();
          }
       
          public void seeHouse(){
              System.out.println("带房客看房");
          }
          public void fare(){
              System.out.println("收中介费");
          }
      }
       
       
      /**
       * Client.java  客户,一般客户回去找代理，即使用代理角色来进行一些操作
       */
      public class Client {
          public static void main(String[] args) {
              //房东要出租房子
              Host host = new Host();
              //中介帮助房东
              Proxy proxy = new Proxy(host);
              //你去找中介
              proxy.rent();
          }
      }

      分析：在这个过程中，你直接接触到中介这个代理租到了房东的房子，即便你看不到房东，这就是所谓的代理模式。
      程序来源于生活，所以学编程的人，一般能够更加抽象地看待生活中发生的事情。

   3. 静态代理的好处

      1. 可以使得我们的真实角色更加纯粹，不再关注一些公共的事情
      2. 公共的业务由代理完成，实现了业务的分工
      3. 公共业务发生扩展时变得更加集中和方便                   

                           缺点：类多了，多了代理类，工作量变大了，开发效率降低

2. 动态代理

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

      1. 动态代理的角色和静态代理一样
      2. 动态代理的代理类是自动生成的，而静态代理的代理类是我们提前写好的

   2. 动态代理的两种方式

      1. 基于接口动态代理——JDK动态代理
      2. 基于类的动态代理——cglib

   3. 代码实现

      以JDK的原生代码来实现

      /**
       * Rent.java  抽象角色：租房
       */
      public interface Rent {
          public void rent();
      }
       
       
      /**
       *Host.java   真实角色：房东，房东要出租房子
       */
      public class Host implements Rent{
       
          @Override
          public void rent() {
              System.out.println("房屋出租");
          }
      }
       
       
      import java.lang.reflect.InvocationHandler;
      import java.lang.reflect.Method;
      import java.lang.reflect.Proxy;
       
      /**
       * ProxyInvocationHandler.java   代理角色
       */
      public class ProxyInvocationHandler implements InvocationHandler {
          //声明目标类接口
          private Rent rent;
       
          public void setRent(Rent rent) {
              this.rent = rent;
          }
       
          //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
          public Object getProxy(){
              return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this);
          }
       
          /**
           *所有动态代理类的方法调用，都会交由invoke()方法去处理
           * @param proxy 被代理后的对象
           * @param method    将要被执行的方法信息（反射）
           * @param args  执行方法时需要的参数
           * @return
           * @throws Throwable
           */
          @Override
          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
              seeHouse();
              //在目标类上调用方法，并传入参数
              Object result = method.invoke(rent,args);
              fare();
              return result;
          }
       
          public void seeHouse(){
              System.out.println("带房客看房");
          }
          public void fare(){
              System.out.println("收中介费");
          }
      }
       
       
      /**
       * Client.java   客户,一般客户回去找代理，即使用代理角色来进行一些操作
       */
      public class Client {
          public static void main(String[] args) {
              //房东要出租房子
              Host host = new Host();
       
              //动态代理
              //代理实例的调用处理程序
              ProxyInvocationHandler pih = new ProxyInvocationHandler();
              pih.setRent(host);  //将真实角色放进去
              Rent proxy = (Rent) pih.getProxy();     //动态生成对应的代理类
              proxy.rent();
          }
      }

   4. 核心

      一个动态代理，一般代理某一类业务，一个动态代理可以代理多个类，代理的是接口！

   5. 动态代理的好处

      静态代理有的它都有，静态代理没有的，它也有！
      1. 可以使得我们的真实角色更加纯粹，不再关注一些公共的事情
      2. 公共的业务由代理来完成，实现了业务的分工
      3. 公共业务发生扩展时变得更加集中和方便
      4. 一个动态代理，一般代理某一类业务
      5. 一个动态代理可以代理多个类，代理的是接口