【源碼分析設計模式 7】Integer中的享元模式

一、基本概念

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

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

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

二、享元模式的結構

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

1、Flyweight 是抽象享元角色。它是產品的抽象類，同時定義出對象的外部狀態和內部狀態的接口和實現；

2、ConcreteFlyweight 是具體享元角色，是具體的產品類，實現抽象角色定義的業務；

3、UnsharedConcreteFlyweight 是不可共享的享元角色，一般不會出現在享元工廠中；

4、FlyweightFactory 是享元工廠，它用於構造一個池容器，同時提供從池中獲得對象的方法。

三、內部狀態和外部狀態

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

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

2、內部狀態指對象共享出來的信息，存儲在享元對象內部並且不會隨環境的改變而改變；

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

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

四、享元模式的優缺點

1、優點

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

2、缺點

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

五、享元模式的使用場景

1、何時應用

（1）系統中有大量對象時

（2）這些對象消耗大量內存時

（3）這些對象的狀態大部分可以外部化時

（4） 需要緩衝池的場景

2、實現方式

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

3、應用實例

（1）string常量池

（2）數據庫連接池

六、代碼實例

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

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

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

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

1、網站抽象類

package designMode.Flyweight.web2;
 
public abstract class WebSite {
    public abstract void use();
}

2、網站具體類

package designMode.Flyweight.web2;
 
public class ConcreteWebSite extends WebSite {
    private String name = "";
    public ConcreteWebSite(String name) {
        this.name = name;
    }
    @Override
    public void use() {
        System.out.println("網站分類：" + name);
    }
}

3、網站工廠類

package designMode.Flyweight.web2;
 
import java.util.HashMap;
 
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號的不同，來區分不同的用戶，具體數據和模板可以不同，但代碼核心和數據庫卻是共享的。

package designMode.Flyweight.web2;
 
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());
    }
}

5、運行結果

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

6、用戶類

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

下面添加一個User類。

package designMode.Flyweight.web2;
 
public class User {
    private String name;
    public User(String name){
        this.name = name;
    }
 
    public String getName(){
        return name;
    }
}

然後再對use()方法進行修改，添加參數，以抽象類爲例：

package designMode.Flyweight.web2;
 
public abstract class WebSite {
    public abstract void use();
    public abstract void use(User user);
}

而客戶端中只需對每一個網站添加一個用戶即可，如：

fx.use(new User("素小暖"));

運行結果如下：

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

七、Integer的享元模式解析

1、測試類

package designMode.advance.flyWeight;

public class FlyWeight {
    public static void main(String[] args) {
        //如果 Integer.valueOf(x) x 在  -128 --- 127 直接，就是使用享元模式返回,如果不在
        //範圍類，則仍然 new

        //小結:
        //1. 在valueOf 方法中，先判斷值是否在 IntegerCache 中，如果不在，就創建新的Integer(new), 否則，就直接從 緩存池返回
        //2. valueOf 方法，就使用到享元模式
        //3. 如果使用valueOf 方法得到一個Integer 實例，範圍在 -128 - 127 ，執行速度比 new 快
        
        Integer x = 127; // 得到 x實例，類型 Integer
        Integer y = new Integer(127); // 得到 y 實例，類型 Integer
        Integer z = Integer.valueOf(127);//..
        Integer w = new Integer(127);

        System.out.println(x.equals(y)); // 大小，true
        System.out.println(x == y ); //  false
        System.out.println(x == z ); // true
        System.out.println(w == x ); // false
        System.out.println(w == y ); // false


        Integer x1 = Integer.valueOf(200);
        Integer x2 = Integer.valueOf(200);
        System.out.println("x1==x2" + (x1 == x2)); // false
    }
}

2、如果想了解怎麼實現共享的，就得分析Integer的源代碼

Integer x = 127;和Integer z = Integer.valueOf(127);是一個意思；

下面我們來看下valueOf方法：

//意思就是 在一個區間之內，直接用IntegerCache.cache[]數組裏面的數返回，否則new 一個新對象。
 public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

再看一下IntegerCache類：

//是Integer內部的私有靜態類,裏面的cache[]就是jdk事先緩存的Integer。
private static class IntegerCache {
    static final int low = -128;//區間的最低值
    static final int high;//區間的最高值，後面默認賦值爲127，也可以用戶手動設置虛擬機參數
    static final Integer cache[]; //緩存數組

    static {
        // high value may be configured by property
        int h = 127;
        //這裏可以在運行時設置虛擬機參數來確定h  :-Djava.lang.Integer.IntegerCache.high=250
        String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {//用戶設置了
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);//雖然設置了但是還是不能小於127
            // 也不能超過最大值
            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        //循環將區間的數賦值給cache[]數組
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
    }

    private IntegerCache() {}
}

其實很簡單，就是用一個Integer數組先緩存了，後面如果是是在區間內的數直接從緩存數組中取，否則才構造新的Integer。緩存思想還是很重要的！謝謝大家觀看。

八、享元模式和單例模式的區別

1、享元模式可以再次創建對象，也可以取緩存對象；單例模式則是嚴格控制單個進程中只有一個實例對象。

2、享元模式可以通過自己控制對外部的單例，也可以在需要時創建更多的對象；單例模式是自身控制，需要增加不屬於該對象本身的邏輯。

兩者都可以實現節省對象創建的時間， threadPool線程池、數據庫連接池都有使用享元模式。