設計模式-享元設計模式

時間 2019-12-04

標籤設計模式简体版

原文原文鏈接

說到享元模式，第一個想到的應該就是池技術了，String常量池、數據庫鏈接池、緩衝池等等都是享元模式的應用，因此說享元模式是池技術的重要實現方式。數據庫

　　好比咱們每次建立字符串對象時，都須要建立一個新的字符串對象的話，內存開銷會很大，因此若是第一次建立了字符串對象「adam「，下次再建立相同的字符串」adam「時，只是把它的引用指向」adam「，這樣就實現了」adam「字符串再內存中的共享。安全

　　舉個最簡單的例子，網絡聯機下棋的時候，一臺服務器鏈接了多個客戶端（玩家），若是咱們每一個棋子都要建立對象，那一盤棋可能就有上百個對象產生，玩家多點的話，由於內存空間有限，一臺服務器就難以支持了，因此這裏要使用享元模式，將棋子對象減小到幾個實例。下面給出享元模式的定義。bash

享元模式（Flyweight），運用共享技術有效地支持大量細粒度的對象。UML結構圖以下：服務器

　　其中，Flyweight是抽象享元角色。它是產品的抽象類，同時定義出對象的外部狀態和內部狀態（外部狀態及內部狀態相關內容見後方）的接口或實現；ConcreteFlyweight是具體享元角色，是具體的產品類，實現抽象角色定義的業務；UnsharedConcreteFlyweight是不可共享的享元角色，通常不會出如今享元工廠中；FlyweightFactory是享元工廠，它用於構造一個池容器，同時提供從池中得到對象的方法。網絡

1. Flyweight抽象類

　　全部具體享元類的超類或接口，經過這個接口，Flyweight能夠接受並做用於外部狀態。ide

1 public abstract class Flyweight {
 2 
 3     //內部狀態
 4     public String intrinsic;
 5     //外部狀態
 6     protected final String extrinsic;
 7     
 8     //要求享元角色必須接受外部狀態
 9     public Flyweight(String extrinsic) {
10         this.extrinsic = extrinsic;
11     }
12     
13     //定義業務操做
14     public abstract void operate(int extrinsic);
15 
16     public String getIntrinsic() {
17         return intrinsic;
18     }
19 
20     public void setIntrinsic(String intrinsic) {
21         this.intrinsic = intrinsic;
22     }
23 
24 }複製代碼

　　2. ConcreteFlyweight類

　　繼承Flyweight超類或實現Flyweight接口，併爲其內部狀態增長存儲空間。性能

1 public class ConcreteFlyweight extends Flyweight {
 2 
 3     //接受外部狀態
 4     public ConcreteFlyweight(String extrinsic) {
 5         super(extrinsic);
 6     }
 7 
 8     //根據外部狀態進行邏輯處理
 9     @Override
10     public void operate(int extrinsic) {
11         System.out.println("具體Flyweight:" + extrinsic);
12     }
13 
14 }複製代碼

　　3. UnsharedConcreteFlyweight類

　　指那些不須要共享的Flyweight子類。測試

1 public class UnsharedConcreteFlyweight extends Flyweight {
 2 
 3     public UnsharedConcreteFlyweight(String extrinsic) {
 4         super(extrinsic);
 5     }
 6 
 7     @Override
 8     public void operate(int extrinsic) {
 9         System.out.println("不共享的具體Flyweight:" + extrinsic);
10     }
11 
12 }複製代碼

　　4. FlyweightFactory類

　　一個享元工廠，用來建立並管理Flyweight對象，主要是用來確保合理地共享Flyweight，當用戶請求一個Flyweight時，FlyweightFactory對象提供一個已建立的實例或建立一個實例。網站

1 public class FlyweightFactory {
 2 
 3     //定義一個池容器
 4     private static HashMap<String, Flyweight> pool = new HashMap<>();
 5     
 6     //享元工廠
 7     public static Flyweight getFlyweight(String extrinsic) {
 8         Flyweight flyweight = null;
 9         
10         if(pool.containsKey(extrinsic)) {    //池中有該對象
11             flyweight = pool.get(extrinsic);
12             System.out.print("已有 " + extrinsic + " 直接從池中取---->");
13         } else {
14             //根據外部狀態建立享元對象
15             flyweight = new ConcreteFlyweight(extrinsic);
16             //放入池中
17             pool.put(extrinsic, flyweight);
18             System.out.print("建立 " + extrinsic + " 並從池中取出---->");
19         }
20         
21         return flyweight;
22     }
23 }複製代碼

　　5. Client客戶端

1 public class Client {
 2 
 3     public static void main(String[] args) {
 4         int extrinsic = 22;
 5         
 6         Flyweight flyweightX = FlyweightFactory.getFlyweight("X");
 7         flyweightX.operate(++ extrinsic);
 8         
 9         Flyweight flyweightY = FlyweightFactory.getFlyweight("Y");
10         flyweightY.operate(++ extrinsic);
11         
12         Flyweight flyweightZ = FlyweightFactory.getFlyweight("Z");
13         flyweightZ.operate(++ extrinsic);
14         
15         Flyweight flyweightReX = FlyweightFactory.getFlyweight("X");
16         flyweightReX.operate(++ extrinsic);
17         
18         Flyweight unsharedFlyweight = new UnsharedConcreteFlyweight("X");
19         unsharedFlyweight.operate(++ extrinsic);
20     }
21     
22 }複製代碼

　　運行結果以下：ui

　　從這個結果咱們能夠看出來，第一次建立X、Y、Z時，都是先建立再從池中取出，而第二次建立X時，由於池中已經存在了，因此直接從池中取出，這就是享元模式。

2、內部狀態和外部狀態

　　上面享元模式的定義爲咱們提出了兩個要求：細粒度和共享對象。咱們知道分配太多的對象到應用程序中將有損程序的性能，同時還容易形成內存溢出，要避免這種狀況，用到的就是共享技術，這裏就須要提到內部狀態和外部狀態了。

　　由於要求細粒度對象，因此不可避免地會使對象數量多且性質相近，此時咱們就將這些對象的信息分爲兩個部分：內部狀態和外部狀態。

　　內部狀態指對象共享出來的信息，存儲在享元對象內部而且不會隨環境的改變而改變；外部狀態指對象得以依賴的一個標記，是隨環境改變而改變的、不可共享的狀態。

　　咱們舉一個最簡單的例子，棋牌類遊戲你們都有玩過吧，好比說說圍棋和跳棋，它們都有大量的棋子對象，圍棋和五子棋只有黑白兩色，跳棋顏色略多一點，但也是不太變化的，因此棋子顏色就是棋子的內部狀態；而各個棋子之間的差異就是位置的不一樣，咱們落子嘛，落子顏色是定的，但位置是變化的，因此方位座標就是棋子的外部狀態。

　　那麼爲何這裏要用享元模式呢？能夠想象一下，上面提到的棋類遊戲的例子，好比圍棋，理論上有361個空位能夠放棋子，常規狀況下每盤棋都有可能有兩三百個棋子對象產生，由於內存空間有限，一臺服務器很難支持更多的玩家玩圍棋遊戲，若是用享元模式來處理棋子，那麼棋子對象就能夠減小到只有兩個實例，這樣就很好的解決了對象的開銷問題。

3、享元模式的應用

　　1. 什麼時候使用

系統中有大量對象時
這些對象消耗大量內存時
這些對象的狀態大部分能夠外部化時

　　2. 方法

用惟一標識碼判斷，若是在內存中有，則返回這個惟一標識碼所標識的對象，用HashMap/HashTable存儲

　　3. 優勢

大大減小了對象的建立，下降了程序內存的佔用，提升效率

　　4. 缺點

提升了系統的複雜度。須要分離出內部狀態和外部狀態，而外部狀態具備固化特性，不該該隨着內部狀態的改變而改變

　　5. 使用場景

系統中存在大量類似對象
須要緩衝池的場景

　　6. 應用實例

String常量池
數據庫鏈接池

　　7. 注意事項

注意劃份內部狀態和外部狀態，不然可能會引發線程安全問題
這些類必須有一個工廠類加以控制

4、享元模式的實現

　　應用實例的話，其實上面的模板就已是一個很好的例子了，相似於String常量池，沒有的對象建立後存在池中，若池中存在該對象則直接從池中取出。

　　爲了更好的理解享元模式，這裏再舉一個實例，好比接了我一個小型的外包項目，是作一個產品展現網站，後來他的朋友們也但願作這樣的網站，但要求都有些不一樣，咱們固然不能直接複製粘貼再來一份，有任但願是新聞發佈形式的，有人但願是博客形式的等等，並且由於經費緣由不能每一個網站租用一個空間。

　　其實這裏他們須要的網站結構類似度很高，並且都不是高訪問量網站，若是分紅多個虛擬空間來處理，至關於一個相同網站的實例對象不少，這是形成服務器的大量資源浪費。若是整合到一個網站中，共享其相關的代碼和數據，那麼對於硬盤、內存、CPU、數據庫空間等服務器資源均可以達成共享，減小服務器資源；而對於代碼，因爲是一份實例，維護和擴展都更加容易。

　　那麼此時就能夠用到享元模式了。UML圖以下：

　　1. 網站抽象類

1 public abstract class WebSite {
2 
3     public abstract void use();
4     
5 }複製代碼

　　2. 具體網站類

1 public class ConcreteWebSite extends WebSite {
 2 
 3     private String name = "";
 4     
 5     public ConcreteWebSite(String name) {
 6         this.name = name;
 7     }
 8     
 9     @Override
10     public void use() {
11         System.out.println("網站分類：" + name);
12     }
13     
14 }複製代碼

　　3. 網絡工廠類

　　這裏使用HashMap來做爲池，經過put和get方法實現加入池與從池中取的操做。

1 public class WebSiteFactory {
 2 
 3     private HashMap<String, ConcreteWebSite> pool = new HashMap<>();
 4     
 5     //得到網站分類
 6     public WebSite getWebSiteCategory(String key) {
 7         if(!pool.containsKey(key)) {
 8             pool.put(key, new ConcreteWebSite(key));
 9         }
10         
11         return (WebSite)pool.get(key);
12     }
13     
14     //得到網站分類總數
15     public int getWebSiteCount() {
16         return pool.size();
17     }
18     
19 }複製代碼

　　4. Client客戶端

　　這裏測試用例給了兩種網站，原先咱們須要作三個產品展現和三個博客的網站，也即須要六個網站類的實例，但其實它們本質上都是同樣的代碼，能夠利用用戶ID號的不一樣，來區分不一樣的用戶，具體數據和模板能夠不一樣，但代碼核心和數據庫倒是共享的。

1 public class Client {
 2 
 3     public static void main(String[] args) {
 4         WebSiteFactory factory = new WebSiteFactory();
 5         
 6         WebSite fx = factory.getWebSiteCategory("產品展現");
 7         fx.use();
 8         
 9         WebSite fy = factory.getWebSiteCategory("產品展現");
10         fy.use();
11         
12         WebSite fz = factory.getWebSiteCategory("產品展現");
13         fz.use();
14         
15         WebSite fa = factory.getWebSiteCategory("博客");
16         fa.use();
17         
18         WebSite fb = factory.getWebSiteCategory("博客");
19         fb.use();
20         
21         WebSite fc = factory.getWebSiteCategory("博客");
22         fc.use();
23         
24         System.out.println("網站分類總數爲：" + factory.getWebSiteCount());
25     }
26     
27 }複製代碼

　　運行結果以下：

　　能夠看出，雖然咱們作了6個網站，但網站分類只有2個。這樣基本算是實現了享元模式的共享對象的目的，但想一想上面提到的內部狀態和外部狀態，這裏實際上沒有體現對象間的不一樣，只體現了它們的共享部分。

　　5. 用戶類

　　因此咱們再加一個用戶類，做爲網站類的外部狀態，並在use()方法中傳遞用戶對象，UML以下：

　　下面添加一個User類。

1 public class User {
 2 
 3     private String name;
 4 
 5     public User(String name) {
 6         this.name = name;
 7     }
 8     
 9     public String getName() {
10         return name;
11     }
12     
13 }複製代碼

　　而後再對use()方法進行修改，添加參數，以抽象類爲例： public abstract void use(User user);

　　而客戶端中只需對每個網站添加一個用戶便可，如： fx.use(new User("adam"));

　　（具體內容可參考源碼，源碼地址見最下方）

　　運行結果以下：