Java設計模式之七 —– 享元模式和代理模式

zsq_fengchen發表於2019-01-23

前言

上一篇中我們學習了結構型模式的組合模式和過濾器模式。本篇則來學習下結構型模式最後的兩個模式, 享元模式和代理模式

享元模式

簡介

享元模式主要用於減少建立物件的數量,以減少記憶體佔用和提高效能。這種型別的設計模式屬於結構型模式,它提供了減少物件數量從而改善應用所需的物件結構的方式。

用通俗的話來說就是進行共用。生活中也有一些例子,比如之前很火的共享單車,更早之前的圖書館,程式設計中經常用的String類,資料庫連線池等等。當然,享元模式主要的目的是複用,如果該物件沒有的話,就會進行建立

享元模式的角色主要分為三大類,抽象享元類、具體享元類以及享元工廠類。

  • 抽象享元類:所有具體享元類的超類或者介面,通過這個介面,可以接受並作用於外部專題。
  • 具體享元類:實現抽象享元類介面的功能並增加儲存空間。
  • 享元工廠類:用來建立並管理抽象享元類物件,它主要用來確保合理地共享。每當接受到一個請求時,便會提供一個已經建立的抽象享元類物件或者新建一個。 享元模式的核心在於享元工廠類,享元工廠類的作用在於提供一個用於儲存享元物件的享元池,使用者需要物件時,首先從享元池中獲取,如果享元池中不存在 ,則建立一個新的享元物件返回給使用者,並在享元池中儲存該新增物件。

其它的就不再多說,這裡依舊使用一個簡單的示例來加以說明。
在我們以前讀書的時候,經常會用到筆,其中鉛筆又是最早接觸的,我們最開始使用鉛筆可能不是寫字,而是進行畫畫。這裡我們可以把筆當作一個抽象享元類,鉛筆當作一個具體享元類,然後再建立一個享元工廠類,用於建立和管理,最後再由呼叫者決定用鉛筆進行幹嘛。

首先,我們建立一個介面。

interface Pen {
   void write();
}

然後再建立一個享元工廠類,指定需要內部需要做的事情。

class Penil implements Pen {
   private String name;
   private String something; 
   private  int i;
   
   public Penil(String name) {
       this.name = name;
       i++;
       System.out.println(name+" 第:"+i+"次建立");
   }
   
   public String getName() {
       return name;
   }
   
   public void setName(String name) {
       this.name = name;
   }
   
   public String getSomething() {
       return something;
   }
   
   public void setSomething(String something) {
       this.something = something;
   }
   
   @Override
   public void write() {
       System.out.println(name+" 用鉛筆  "+something);
   }
}

繼而再建立一個工廠類,用於建立和管理。

class PenFactory {
   private static final Map<String, Penil> map = new HashMap<String, Penil>();

   public static Penil get(String name) {
       Penil penil = map.get(name);
       if (penil == null) {
           penil = new Penil(name);
           map.put(name, penil);
       }
       return penil;
   }
}

最後再來進行呼叫測試。

public class FlyweightTest {
    public static void main(String[] args) {
        String names[] = { "張三", "李四", "王五", "虛無境" };
        for (int i = 0; i < 8; i++) {
            Penil penil = PenFactory.get(names[i>3?i-4:i]);
            penil.setSomething("畫了一條魚");
            penil.write();
        }
    }
}

輸出結果:

            張三 第:1次建立
            張三 用鉛筆  畫了一條魚
            李四 第:1次建立
            李四 用鉛筆  畫了一條魚
            王五 第:1次建立
            王五 用鉛筆  畫了一條魚
            虛無境 第:1次建立
            虛無境 用鉛筆  畫了一條魚
            張三 用鉛筆  畫了一條魚
            李四 用鉛筆  畫了一條魚
            王五 用鉛筆  畫了一條魚
            虛無境 用鉛筆  畫了一條魚

上述示例中,每個物件都使用了兩次,但是每個物件都只是建立了一次而已,而享元模式核心的目的其實就是複用,只要我們理解了這一點,想必掌握該模式也就不在話下了。

享元模式優點:

極大的減少物件的建立,從而降低了系統的記憶體,提升了效率。

享元模式缺點:

提高了系統的複雜度,因為需要將狀態進行分離成內部和外部,並且也使外部狀態固有化,使得隨著內部狀態的變化而變化,會造成系統的混亂。

使用場景:

系統有大量相似物件。

注意事項:

需要注意劃分外部狀態和內部狀態,否則可能會引起執行緒安全問題。 這些類必須有一個工廠物件加以控制。

與單例模式比較

雖然它們在某些方面很像,但是實際上卻是不同的東西,單例模式的目的是限制建立多個物件,避免衝突,比如使用資料庫連線池。而享元模式享元模式的目的是共享,避免多次建立耗費資源,比如使用String類。

代理模式

簡介

代理模式於結構型模式,主要是通過一個類代表另一個類的功能。通常,我們建立具有現有物件的物件,以便向外界提供功能接口。

代理模式,如其名,也就是代理作用。 我們生活中也有不少示例,比如典型的代購,土豪專用的支票,Windows 裡面的快捷方式,以及spring中的aop 等等。

代理模式主要由這三個角色組成,抽象角色、代理角色和真實角色

  • 抽象角色:通過介面或抽象類宣告真實角色實現的業務方法。
  • 代理角色:實現抽象角色,是真實角色的代理,通過真實角色的業務邏輯方法來實現抽象方法,並可以附加自己的操作。
  • 真實角色:實現抽象角色,定義真實角色所要實現的業務邏輯,供代理角色呼叫。

代理模式又分為靜態代理、動態代理。

  • 靜態代理是由程式設計師建立或工具生成代理類的原始碼,再編譯代理類。所謂靜態也就是在程式執行前就已經存在代理類的位元組碼檔案,代理類和委託類的關係在執行前就確定了。
  • 動態代理是在實現階段不用關心代理類,而在執行階段才指定哪一個物件。

這裡我們依舊用一個簡單的示例來進行說明。
張三和李四是室友,某天,張三在寢室內玩遊戲正帶勁,感覺肚子餓了,本想下樓去吃飯的,但是想起李四可能快要回來,於是打電話給李四,讓李四幫自己帶份盒飯。這裡的李四就扮演著代理者的作用。

靜態代理

首先我們用靜態代理來實現該功能。

這裡實現相對而言較為簡單,依舊是定義一個介面,然後定義一個真實的角色,實現該介面的功能,繼而定義一個代理者,也實現該介面,但是新增該真實角色的物件進行相應的業務邏輯處理。
那麼該靜態代理程式碼實現如下:

interface Shopping {
    void buyFood();
}

class ExecutePerson implements Shopping {
    private String name;
    public ExecutePerson(String name) {
        this.name = name;
    }

    @Override
    public void buyFood() {
        System.out.println(name + " 買東西");
    }
}

class ProxyPerson implements Shopping {
    private ExecutePerson ep;
    public ProxyPerson(ExecutePerson ep) {
        this.ep = ep;
    }
    @Override
    public void buyFood() {
        ep.buyFood();
    }
}


public class ProxyTest {
    public static void main(String[] args) {    
        String name = "李四";
        Shopping shopping = new ProxyPerson(new ExecutePerson(name));
        shopping.buyFood();
    }
}

輸入結果:

 李四 買東西

在使用靜態代理實現該功能之後,我們發現實現起來很簡單,通過一個代理類就可以在不影響目標物件的前提進行擴充套件使用。但是我們也發現一個問題,如果我們不確定需要代理某個真實類的時候會比較麻煩,而且在類過多的時候,目標物件與代理物件都要維護,會使系統複雜度提升,維護起來也更加麻煩。
不過這時我們就可以使用動態代理來進行解決

動態代理

所謂動態代理可以不必強行指定某個真實的角色,只需要在執行時決定就可以了。這裡我們可以使用JDK中java.lang.reflect來進行開發。

JDK對動態代理提供了以下支援:

  • java.lang.reflect.Proxy 動態生成代理類和物件
  • java.lang.reflect.InvocationHandler
    • 可以通過invoke方法實現對真實角色的代理訪問;
    • 每次通過Proxy生成代理類物件時都要指定物件的處理器物件.

那麼廢話不在多說,開始進行程式碼改造,之前的介面和真實者不需要更改,我們只需要更改代理者就可以了。
更改之後的程式碼如下:

class ProxyPerson2 implements InvocationHandler {
 private Shopping shopping;
 private final String methodName = "buyFood";
 public ProxyPerson2(Shopping shopping) {
     this.shopping = shopping;
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     Object result = null;
     if (methodName.equals(method.getName())) {
         result = method.invoke(shopping, args);
     }
     return result;
 }
}

測試程式碼,注意這裡呼叫和之前不同!
這裡通過Proxy類中的newProxyInstance方法會動態生成一個代理類,然後進行呼叫。其中這三個引數的說明如下:

  • ClassLoader: 生成一個類, 這個類也需要載入到方法區中, 因此需要指定ClassLoader來載入該類
  • Class[] interfaces: 要實現的介面
  • InvocationHandler: 呼叫處理器
public class ProxyTest {
    public static void main(String[] args) {    
        Shopping shopping2 = (Shopping)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Shopping.class}, new ProxyPerson2(new ExecutePerson(name)));
        shopping2.buyFood();
    }
}

代理模式優點:

1、職責清晰。 2、高擴充套件性。 3、智慧化。

代理模式缺點:

1、由於在客戶端和真實主題之間增加了代理物件,因此有些型別的代理模式可能會造成請求的處理速度變慢。
2、實現代理模式需要額外的工作,有些代理模式的實現非常複雜。

注意事項:

和介面卡模式的區別:介面卡模式主要改變所考慮物件的介面,而代理模式不能改變所代理類的介面。
和裝飾器模式的區別:裝飾器模式為了增強功能,而代理模式是為了加以控制。

代理模式參考:  JDK和Cglib的動態代理

相關文章