代理模式

靜態代理

動態代理

靜態代理

抽象角色：一般使用介面或者抽象類來實現

真實角色：被代理的角色

代理角色：代理真實角色，代理真實角色之後，額外可以做一些附屬的操作

客戶：使用代理角色來進行一些操作

測試

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("收中介費");
  }
}

Client.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中最核心的思想。即，傳統的開發都是縱向開發，AOP是橫向開發，將新的功能實現橫切進去。

動態代理

動態代理的幾個角色和靜態代理一樣。不同之處在於，動態代理的代理類是動態生成的，靜態代理的代理類是我們提前寫好的，利用了反射原理。

動態代理分為兩類：一類是基於介面動態代理，一類是基於類的動態代理。

基於介面的動態代理-JDK動態代理（本章學習）

基於類的動態代理-cglib

JDK動態代理需要了解兩個類

核心：InvocationHandler 和 Proxy

InvocationHandler:呼叫處理程式

裡面有兩個核心的方法

處理代理例項上的方法呼叫並返回結果
Object invoke(Object proxy, 方法 method, Object[] args)；
//引數
//proxy - 呼叫該方法的代理例項
//method -所述方法對應於呼叫代理例項上的介面方法的例項。方法物件的宣告類將是該方法宣告的介面，它可以是代理類繼承該方法的代理介面的超級介面。
//args -包含的方法呼叫傳遞代理例項的引數值的物件的陣列，或null如果介面方法沒有引數。原始型別的引數包含在適當的原始包裝器類的例項中，例如java.lang.Integer或java.lang.Boolean 。

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

測試

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

//真實角色: 房東，房東要出租房子
public class Host implements Rent{
   public void rent() {
       System.out.println("房屋出租");
  }
}

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) throwsThrowable {
       seeHouse();
       //核心：本質利用反射實現！
       Object result = method.invoke(rent, args);
       fare();
       return result;
  }

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

}

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) throwsThrowable {
       seeHouse();
       //核心：本質利用反射實現！
       Object result = method.invoke(rent, args);
       fare();
       return result;
  }

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

}

//租客
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();
  }

}

總結：一個動態代理，一般代理某一類業務，一個動態代理可以代理多個類，代理的是介面。

例項改編、深化理解

編寫一個通用的動態代理實現的類！所有的代理物件設定為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) throwsThrowable {
       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();
  }
}

動態代理的好處

靜態代理有的它也有，靜態代理沒有的，它也有。

可以使我們的真實角色更加純粹，不再去關注一些公共的事務。

公共的業務由代理來完成，實現了業務的分工。

公共業務發生擴充套件時變得更加集中和方便。

一個動態代理，一般代理某一類業務。

一個動態代理可以代理多個類，代理的是介面。