簡說設計模式——享元模式

一、什么是享元模式

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

　　比如我們每次創建字符串對象時，都需要創建一個新的字符串對象的話，內存開銷會很大，所以如果第一次創建了字符串對象“adam“，下次再創建相同的字符串”adam“時，只是把它的引用指向”adam“，這樣就實現了”adam“字符串再內存中的共享。

　　舉個最簡單的例子，網絡聯機下棋的時候，一台服務器連接了多個客戶端（玩家），如果我們每個棋子都要創建對象，那一盤棋可能就有上百個對象產生，玩家多點的話，因為內存空間有限，一台服務器就難以支持了，所以這里要使用享元模式，將棋子對象減少到幾個實例。下面給出享元模式的定義。

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

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

　　1. Flyweight抽象類

　　所有具體享元類的超類或接口，通過這個接口，Flyweight可以接受並作用於外部狀態。

public abstract class Flyweight {

    //內部狀態
    public String intrinsic;
    //外部狀態
    protected final String extrinsic;
    
    //要求享元角色必須接受外部狀態
    public Flyweight(String extrinsic) {
        this.extrinsic = extrinsic;
    }
    
    //定義業務操作
    public abstract void operate(int extrinsic);

    public String getIntrinsic() {
        return intrinsic;
    }

    public void setIntrinsic(String intrinsic) {
        this.intrinsic = intrinsic;
    }

}

　　2. ConcreteFlyweight類

　　繼承Flyweight超類或實現Flyweight接口，並為其內部狀態增加存儲空間。

public class ConcreteFlyweight extends Flyweight {

    //接受外部狀態
    public ConcreteFlyweight(String extrinsic) {
        super(extrinsic);
    }

    //根據外部狀態進行邏輯處理
    @Override
    public void operate(int extrinsic) {
        System.out.println("具體Flyweight:" + extrinsic);
    }

}

　　3. UnsharedConcreteFlyweight類

　　指那些不需要共享的Flyweight子類。

public class UnsharedConcreteFlyweight extends Flyweight {

    public UnsharedConcreteFlyweight(String extrinsic) {
        super(extrinsic);
    }

    @Override
    public void operate(int extrinsic) {
        System.out.println("不共享的具體Flyweight:" + extrinsic);
    }

}

　　4. FlyweightFactory類

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

public class FlyweightFactory {

    //定義一個池容器
    private static HashMap<String, Flyweight> pool = new HashMap<>();
    
    //享元工廠
    public static Flyweight getFlyweight(String extrinsic) {
        Flyweight flyweight = null;
        
        if(pool.containsKey(extrinsic)) {    //池中有該對象
            flyweight = pool.get(extrinsic);
            System.out.print("已有 " + extrinsic + " 直接從池中取---->");
        } else {
            //根據外部狀態創建享元對象
            flyweight = new ConcreteFlyweight(extrinsic);
            //放入池中
            pool.put(extrinsic, flyweight);
            System.out.print("創建 " + extrinsic + " 並從池中取出---->");
        }
        
        return flyweight;
    }
}

　　5. Client客戶端

public class Client {

    public static void main(String[] args) {
        int extrinsic = 22;
        
        Flyweight flyweightX = FlyweightFactory.getFlyweight("X");
        flyweightX.operate(++ extrinsic);
        
        Flyweight flyweightY = FlyweightFactory.getFlyweight("Y");
        flyweightY.operate(++ extrinsic);
        
        Flyweight flyweightZ = FlyweightFactory.getFlyweight("Z");
        flyweightZ.operate(++ extrinsic);
        
        Flyweight flyweightReX = FlyweightFactory.getFlyweight("X");
        flyweightReX.operate(++ extrinsic);
        
        Flyweight unsharedFlyweight = new UnsharedConcreteFlyweight("X");
        unsharedFlyweight.operate(++ extrinsic);
    }
    
}

　　運行結果如下：

　　

　　從這個結果我們可以看出來，第一次創建X、Y、Z時，都是先創建再從池中取出，而第二次創建X時，因為池中已經存在了，所以直接從池中取出，這就是享元模式。

二、內部狀態和外部狀態

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

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

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

　　我們舉一個最簡單的例子，棋牌類游戲大家都有玩過吧，比如說說圍棋和跳棋，它們都有大量的棋子對象，圍棋和五子棋只有黑白兩色，跳棋顏色略多一點，但也是不太變化的，所以棋子顏色就是棋子的內部狀態；而各個棋子之間的差別就是位置的不同，我們落子嘛，落子顏色是定的，但位置是變化的，所以方位坐標就是棋子的外部狀態。

　　那么為什么這里要用享元模式呢？可以想象一下，上面提到的棋類游戲的例子，比如圍棋，理論上有361個空位可以放棋子，常規情況下每盤棋都有可能有兩三百個棋子對象產生，因為內存空間有限，一台服務器很難支持更多的玩家玩圍棋游戲，如果用享元模式來處理棋子，那么棋子對象就可以減少到只有兩個實例，這樣就很好的解決了對象的開銷問題。

三、享元模式的應用

　　1. 何時使用

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

　　2. 方法

• 用唯一標識碼判斷，如果在內存中有，則返回這個唯一標識碼所標識的對象，用HashMap/HashTable存儲

　　3. 優點

• 大大減少了對象的創建，降低了程序內存的占用，提高效率

　　4. 缺點

• 提高了系統的復雜度。需要分離出內部狀態和外部狀態，而外部狀態具有固化特性，不應該隨着內部狀態的改變而改變

 　　5. 使用場景

• 系統中存在大量相似對象
• 需要緩沖池的場景

 　　6. 應用實例

• String常量池
• 數據庫連接池

 　　7. 注意事項

• 注意划分內部狀態和外部狀態，否則可能會引起線程安全問題
• 這些類必須有一個工廠類加以控制

 四、享元模式的實現

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

　　為了更好的理解享元模式，這里再舉一個實例，比如接了我一個小型的外包項目，是做一個產品展示網站，后來他的朋友們也希望做這樣的網站，但要求都有些不同，我們當然不能直接復制粘貼再來一份，有任希望是新聞發布形式的，有人希望是博客形式的等等，而且因為經費原因不能每個網站租用一個空間。

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

　　那么此時就可以用到享元模式了。UML圖如下：

　　1. 網站抽象類

public abstract class WebSite {

    public abstract void use();
    
}

　　2. 具體網站類

public class ConcreteWebSite extends WebSite {

    private String name = "";
    
    public ConcreteWebSite(String name) {
        this.name = name;
    }
    
    @Override
    public void use() {
        System.out.println("網站分類：" + name);
    }
    
}

 　　3. 網絡工廠類

　　這里使用HashMap來作為池，通過put和get方法實現加入池與從池中取的操作。

public class WebSiteFactory {

    private HashMap<String, ConcreteWebSite> pool = new HashMap<>();
    
    //獲得網站分類
    public WebSite getWebSiteCategory(String key) {
        if(!pool.containsKey(key)) {
            pool.put(key, new ConcreteWebSite(key));
        }
        
        return (WebSite)pool.get(key);
    }
    
    //獲得網站分類總數
    public int getWebSiteCount() {
        return pool.size();
    }
    
}

 　　4. Client客戶端

　　這里測試用例給了兩種網站，原先我們需要做三個產品展示和三個博客的網站，也即需要六個網站類的實例，但其實它們本質上都是一樣的代碼，可以利用用戶ID號的不同，來區分不同的用戶，具體數據和模板可以不同，但代碼核心和數據庫卻是共享的。

public class Client {

    public static void main(String[] args) {
        WebSiteFactory factory = new WebSiteFactory();
        
        WebSite fx = factory.getWebSiteCategory("產品展示");
        fx.use();
        
        WebSite fy = factory.getWebSiteCategory("產品展示");
        fy.use();
        
        WebSite fz = factory.getWebSiteCategory("產品展示");
        fz.use();
        
        WebSite fa = factory.getWebSiteCategory("博客");
        fa.use();
        
        WebSite fb = factory.getWebSiteCategory("博客");
        fb.use();
        
        WebSite fc = factory.getWebSiteCategory("博客");
        fc.use();
        
        System.out.println("網站分類總數為：" + factory.getWebSiteCount());
    }
    
}

 　　運行結果如下：

　　

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

　　5. 用戶類

　　所以我們再加一個用戶類，作為網站類的外部狀態，並在use()方法中傳遞用戶對象，UML如下：

　　下面添加一個User類。

public class User {

    private String name;

    public User(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
}

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

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

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

　　運行結果如下：

　　

　　這樣就可以協調內部與外部狀態，哪怕接手了上千個網站的需求，只要要求相同或類似，實際開發代碼也就是分類的哪幾種。

 

　　源碼地址：https://gitee.com/adamjiangwh/GoF