Spring從入門到入土——代理模式

相關文章

跟着官網學spring—快速入門指南

跟着官網學Spring—構建RESTful Web服務

Spring從入門到入土——概述以及IOC理論推導

Spring從入門到入土——快速上手Spring

Spring從入門到入土——依賴注入（DI）

Spring從入門到入土——Bean的作用域

Spring從入門到入土——自動裝配

Spring從入門到入土——使用註解

Spring從入門到入土——AOP就這麼簡單

Spring從入門到入土——代理模式

代理模式

​ AOP的底層機制就是動態代理

• 代理模式：
  • 靜態代理
  • 動態代理

靜態代理

靜態代理角色分析

• 抽象角色：一般使用接口或者抽象類來實現
• 真實角色：被代理的角色
• 代理角色：代理真實角色，代理真實角色後，一般會做一些附屬的操作
• 客戶：使用代理角色來進行一些操作

代碼實現

Rent.java 即抽象角色

//抽象角色
public interface Rent{
    public void rent();
}

Host.java 即真實角色

// 真實角色：房東、房東要出租的房子
public class Host implements Rent{
    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;
  }

   //租房
   public void rent(){
       seeHouse();
       host.rent();
       fare();
  }
   //看房
   public void seeHouse(){
       System.out.println("帶房客看房");
  }
   //收中介費
   public void fare(){
       System.out.println("收中介費");
  }
}

Clinet.java 即客戶

//客戶類，一般客戶都會去找代理！
public class Client {
   public static void main(String[] args) {
       //房東要租房
       Host host = new Host();
       //中介幫助房東
       Proxy proxy = new Proxy(host);

       //你去找中介！
       proxy.rent();
  }
}

分析

​ 在整個過程中客戶直接接觸的就是中介，如同現實生活中，不需要接觸房東，依舊租到了房東的房子通過代理，這就是代理模式。

靜態代理的好處

• 可以是我們的真實角色更加純粹，不再去關注一些公共的事情
• 公共的業務由代理完成，實現了業務的分工
• 公共業務發生擴展時變得更加集中和方便

但是類多了，多了代理類，工作量變大了，開發效率降低

靜態類再理解

抽象類

​ 增刪改查

//抽象角色：增刪改查業務
public interface UserService {
   void add();
   void delete();
   void update();
   void query();
}

真實對象

完成這些這些增刪改查操作。

//真實對象，完成增刪改查操作的人
public class UserServiceImpl implements UserService {

   public void add() {
       System.out.println("增加了一個用戶");
  }

   public void delete() {
       System.out.println("刪除了一個用戶");
  }

   public void update() {
       System.out.println("更新了一個用戶");
  }

   public void query() {
       System.out.println("查詢了一個用戶");
  }
}

需求

​ 增加一個狀態日誌

• 思路一：在實現類上增加【繁瑣】
• 思路二：用代理來實現，能夠在不改變原來的業務情況下，實現此功能。

設置一個代理角色

//代理角色，在這裏面增加日誌的實現
public class UserServiceProxy implements UserService {
   private UserServiceImpl userService;

   public void setUserService(UserServiceImpl userService) {
       this.userService = userService;
  }

   public void add() {
       log("add");
       userService.add();
  }

   public void delete() {
       log("delete");
       userService.delete();
  }

   public void update() {
       log("update");
       userService.update();
  }

   public void query() {
       log("query");
       userService.query();
  }

   public void log(String msg){
       System.out.println("執行了"+msg+"方法");
  }

}

測試訪問類

public class Client {
   public static void main(String[] args) {
       //真實業務
       UserServiceImpl userService = new UserServiceImpl();
       //代理類
       UserServiceProxy proxy = new UserServiceProxy();
       //使用代理類實現日誌功能！
       proxy.setUserService(userService);

       proxy.add();
  }
}

在不改變原來的代碼的情況下，實現類對原有代碼的增強，這就是AOP中最核心的思想。

動態代理

• 動態代理的角色和靜態代理的角色是一樣的
• 動態代理的代理類是自動生成的，靜態代理的代理類是我們提前寫好的
• 動態代理分爲兩類：
  • 基於接口動態代理——JDK動態代理
  • 基於類的動態代理——cglib

• InvocationHandler：調用處理程序

  • InvocationHandler是由代理實例的調用處理程序實現的接口
  • 每一個代理實例都有一個關聯的調用處理程序。當再代理實例上調用方法時，方法調用將被編碼並分派到其調用處理程序的invoke方法

  Object invoke(Object proxy,方法 method,Object[] args)

  • 參數：
    • proxy-調用該方法的代理實例
    • method-所述方法對應與調用代理實例上的接口方法的實例。方法對象的聲明類將是該方法聲明的接口，它可以是代理類繼承該方法的代理接口的超級接口
    • args：包含的方法調用傳遞代理實例的參數值的對象的陣列，或null如果接口方法沒有參數，原始類型的參數包含在適當的原始包裝器類的實例中，例如：java.lang.Integer或java.lang.Boolean

• Proxy：代理

  • 提供了創建動態代理類和實例的靜態方法，它也是由這些方法創建的所有動態代理的超類

  // 生成代理類
  public Object getProxy(){
      return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
  }
  

代碼實現

Rent.java 抽象角色

// 抽象角色 租房
public interface Rent(){
    public void rent();
}

Host.java 真實角色

// 真實角色：房東、房東要出租的房子
public class HostImplements Rent{
    public void rent(){
        System.out.println("房屋出租")
    }
}

ProxyInvacationHandler.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);
  }

   // proxy : 代理類 method : 代理類的調用處理程序的方法對象.
   // 處理代理實例上的方法調用並返回結果
   @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("收中介費");
  }

}

Clinet.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();
  }

}

核心

​ 一個動態代理，一般代理某一類業務，一個動態戴麗麗可以代理多個類，代理的是接口！

深化理解

​ 我們來使用動態代理實現代理我們後面寫的UserService！

​ 我們也可以編寫一個通用的動態代理實現的類！所有的代理對象設置爲Object即可！

public class ProxyInvocationHandler implements InvocationHandler {
   private Object target;

   public void setTarget(Object target) {
       this.target = target;
  }

   //生成代理類
   public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),
               target.getClass().getInterfaces(),this);
  }

   // proxy : 代理類
   // method : 代理類的調用處理程序的方法對象.
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       log(method.getName());
       Object result = method.invoke(target, args);
       return result;
  }

   public void log(String methodName){
       System.out.println("執行了"+methodName+"方法");
  }

}

測試

public class Test {
   public static void main(String[] args) {
       //真實對象
       UserServiceImpl userService = new UserServiceImpl();
       //代理對象的調用處理程序
       ProxyInvocationHandler pih = new ProxyInvocationHandler();
       pih.setTarget(userService); //設置要代理的對象
       UserService proxy = (UserService)pih.getProxy(); //動態生成代理類！
       proxy.delete();
  }
}

動態代理的好處

靜態代理有的它都有，靜態代理沒有的，它也有！

• 可以使得我們的真實角色更加純粹 . 不再去關注一些公共的事情 .
• 公共的業務由代理來完成 . 實現了業務的分工 ,
• 公共業務發生擴展時變得更加集中和方便 .
• 一個動態代理 , 一般代理某一類業務
• 一個動態代理可以代理多個類，代理的是接口！