Java設計模式之代理模式的筆記

這篇文章主要為大家詳細介紹了java設計模式之代理模式筆記，具有一定的參考價值，有興趣的小夥伴們可以參考一下

代理程式（Proxy）模式：

代理模式是物件的結構模式。代理模式提供某一個物件一個代理對象，並由代理對象控制原對象的參考。

核心作用：

透過代理，控制對物件的存取。

可以詳細控制存取某個（某一類別）物件的方法，在呼叫這個方法之前做前置處理，在呼叫這個方法之後做後置處理。即AOP的微觀實現。

AOP（Aspect Oriented Programming面向切面程式設計）的核心實作機制。

生活中的場景：

　　所謂代理，就是一個人或機構代表另一個人或機構採取行動。在某些情況下，一個客戶不想或無法直接引用一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。
　　例如，客戶要找某個明星唱歌，首先需要找到他的經紀人，然後由他的經紀人來安排某明星唱歌。
　　經紀人在演唱會舉辦前需要處理一些前置處理（面談，合約起草，簽字，收預付款，安排機票和車輛等）在演唱會舉辦後需要處理一些後置處理（收尾款等） 。此時某位明星（真實角色）只需要關心如何唱歌就可以了，其他事情全部交給經紀人（代理）來辦。

核心角色：

這裡寫圖片描述

抽象物件角色：宣告了代理物件和真實物件的共同接口，定義代理物件和真實物件的公共對外方法。這樣一來在任何可以使用真實物件的地方都可以使用代理物件。

真實物件角色：定義了代理物件所代表的真實物件。實作抽象對象，定義真實對象所需實現的業務邏輯，供代理對象呼叫。專注於真正的業務邏輯。

代理對象角色：實作抽象對象，是真實對象的代理，透過真實對象的業務邏輯方法來實作抽象方法，並附加自己的操作。將統一的流程控制放到代理對像中處理。

　　代理物件內部含有真實物件的引用，從而可以在任何時候操作真實物件；代理物件提供一個與真實物件相同的接口，以便在任何時候都可以取代真實物件。代理物件通常在客戶端呼叫傳遞給真實物件之前或之後，執行某個操作，而不是單純地將呼叫傳遞給真實物件。

應用程式場景：

安全代理程式：屏蔽對真實角色的直接存取。
遠端代理：透過代理類別處理遠端方法呼叫。
延遲載入：先載入輕量級的代理對象，真正需要再去載入真實對象。 （圖片的延遲載入）

分類：

靜態代理程式：（靜態定義代理類別）

上面範例的程式碼：

1、宣告了代理物件和真實物件的共同接口，定義代理物件和真實物件的公共對外方法。

public interface Star {
  /**
   * 面谈
   */
  void confer();
  /**
   * 签合同
   */
  void signContract();
  /**
   * 订票
   */
  void bookTicket();
  /**
   * 唱歌
   */
  void sing();
  /**
   * 收钱
   */
  void collectMoney();
}

2、定義一個真實物件的類，實作抽象介面所提供的方法。

public class RealStar implements Star {

  @Override
  public void bookTicket() {
    System.out.println("RealStar.bookTicket()");
  }

  @Override
  public void collectMoney() {
    System.out.println("RealStar.collectMoney()");
  }

  @Override
  public void confer() {
    System.out.println("RealStar.confer()");
  }

  @Override
  public void signContract() {
    System.out.println("RealStar.signContract()");
  }

  @Override
  public void sing() {
    System.out.println("RealStar.sing()");
  }
}

3、定義一個代理物件的類，實作抽象介面所提供的方法，並持有真實物件的參考。

public class ProxyStar implements Star{

private Star star;

  public ProxyStar(Star star) {
    super();
    this.star = star;
  }

  @Override
  public void bookTicket() {
    System.out.println("ProxyStar.bookTicket()");
  }

  @Override
  public void collectMoney() {
    System.out.println("ProxyStar.collectMoney()");
  }

  @Override
  public void confer() {
    System.out.println("ProxyStar.confer()");
  }

  @Override
  public void signContract() {
    System.out.println("ProxyStar.signContract()");
  }

  @Override
  public void sing() {
    star.sing();
  }

}

4.測試類別

public class Client {
  public static void main(String[] args) {
    //定义真实对象角色
    Star realStar = new RealStar();
    //定义代理对象角色，内部含有真实对象的引用
    Star proxyStar = new ProxyStar(realStar);

    proxyStar.confer();
    proxyStar.signContract();
    proxyStar.bookTicket();
    proxyStar.sing();
    proxyStar.collectMoney();

  }
}

執行結果如下：

ProxyStar.confer()
ProxyStar.signContract()
ProxyStar.bookTicket()
RealStar.sing()
ProxyStar.collectMoney()

　　從上面的例子可以看出代理對象將客戶端的呼叫委派給真實對象，在呼叫目標對象的方法之前跟之後都可以執行特定的操作。

動態代理程式：（動態產生代理類別）：

#動態代理程式比起靜態代理程式的優點：

　　抽象角色中（介面）聲明的所有方法都被轉移到呼叫伺服器的一個集中的方法中處理，這樣我們可以更加靈活和統一的處理眾多的方法。

JDK自帶的動態代理

#java.lang.reflect.Proxy
動態產生代理類別和物件

java.lang.reflect.InvocationHandler（處理器介面）
可以透過invoke方法實作對真實角色的代理存取

#每次透過Proxy產生代理類物件時都要指定對應的處理器物件

測試程式碼如下：

1、宣告了代理物件和真實物件的共同接口，定義代理物件和真實物件的公共對外方法。

public interface Star {
  /**
   * 面谈
   */
  void confer();
  /**
   * 签合同
   */
  void signContract();
  /**
   * 订票
   */
  void bookTicket();
  /**
   * 唱歌
   */
  void sing();
  /**
   * 收钱
   */
  void collectMoney();
}

2、定義一個真實物件的類，實作抽象介面所提供的方法。

public class RealStar implements Star {

  @Override
  public void bookTicket() {
    System.out.println("RealStar.bookTicket()");
  }

  @Override
  public void collectMoney() {
    System.out.println("RealStar.collectMoney()");
  }

  @Override
  public void confer() {
    System.out.println("RealStar.confer()");
  }

  @Override
  public void signContract() {
    System.out.println("RealStar.signContract()");
  }

  @Override
  public void sing() {
    System.out.println("RealStar.sing()");
  }
}

3.定義一個StarHandler類別實作InvocationHandler處理器接口，可以透過invoke方法實現對真實角色的代理訪問，也可在invoke方法中對眾多操作做統一的處理。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class StarHandler implements InvocationHandler{

  private Star realStar;

  public StarHandler(Star realStar) {
    super();
    this.realStar = realStar;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args)
      throws Throwable {
    //返回值
    Object object = null;

    System.out.println("真正的方法执行前！");
    System.out.println("面谈，签合同，预付款，订机票");

    if(method.getName().equals("sing")){
      object = method.invoke(realStar, args);
    }

    System.out.println("真正的方法执行后！");
    System.out.println("收尾款");
    return object;

  }

}

4.客户端测试类

import java.lang.reflect.Proxy;

public class Client {

public static void main(String[] args) {

    Star realStar = new RealStar();
    StarHandler handler = new StarHandler(realStar);

    //通过Proxy生成代理类对象并指定对应的处理器对象
    Star proxyStar = (Star)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), 
        new Class[]{Star.class}, handler);

    proxyStar.sing();

  }

运行结果如下：

真正的方法执行前！
面谈，签合同，预付款，订机票
RealStar.sing()
真正的方法执行后！
收尾款

开发框架中的应用场景

代理模式在开发框架中的应用场景是非常多的，实际上随便选择一个开发框架都有用到代理模式。例如：

mybatis中实现拦截器插件
AspectJ的实现
spring中AOP的实现

以上是Java設計模式之代理模式的筆記的詳細內容。更多資訊請關注PHP中文網其他相關文章！