概述

在有大量物件時，有可能會造成記憶體溢位，我們把其中共同的部分抽象出來，如果有相同的業務請求，直接返回在記憶體中已有的物件，避免重新建立。

版權說明

目錄

享元模式

定義

享元模式是一種結構型模式，運用共享技術有效地支援大量細粒度的物件。

單純享元模式

在享元模式中，就其定義我們可以構建出單純的享元模式。下圖是單純享元模式的類圖：

在單純的享元模式中，需要給出一個抽象介面，以規定出所有具體享元角色需要實現的方法。實現如下：
Flyweight.java

public interface Flyweight {
    public
 
 void operation(String state);
}

對於享元部分，ConcreteFlyweight 必須是可共享的，它儲存的任何狀態都必須是內部(intrinsic)，ConcreteFlyweight 必須和它的應用環境場合無關。比如字串 “Hello” 就無需關心使用它的場合，它是一個不可變的物件。
ConcreteFlyweight.java

public class ConcreteFlyweight implements Flyweight {

    private String intrinsicState = null;

    /**
     * 建構函式 內蘊狀態作為引數傳入
     */
 

    public ConcreteFlyweight(String _intrinsicState) {
        this.intrinsicState = _intrinsicState;
    }

    /**
     * 外蘊狀態作為引數傳入方法中 改變方法的行為 但是並不改變物件的內蘊狀態
     */
    @Override
    public void operation(String extrinsicState) {
        System.out.println("內蘊狀態：" + intrinsicState);
        System.out.println("外蘊狀態："
 
 + extrinsicState);
    }

}

在享元模式中，有一個至關重要的模組就是工廠模組了。在 Flyweight Factory 裡維護了一個 Flyweight 池(存放內部狀態)，Flyweight Factory 就是通過這個 Flyweight 池對整個享元模式進行控制。
FlyweightFactory.java

public class FlyweightFactory {

    private Map<Integer, Flyweight> labels = new HashMap<Integer, Flyweight>();

    public Flyweight factory(String intrinsicState) {

        int hashCode = intrinsicState.hashCode();

        Flyweight fly = labels.get(hashCode);

        if (fly == null) {
            fly = new ConcreteFlyweight(intrinsicState);
            labels.put(hashCode, fly);
        }

        return fly;
    }
}

在上面的工廠模組中可以看到，FlyweightFactory 實際上是起到了一個過濾篩選的功能，過濾重複的物件，快取新物件。

不共享的享元模式

與共享的享元物件相對的就是不共享的享元物件。關於不共享的享元物件，可能你會有一些疑問，既然不共享，為何還要包含到享元模式中來呢？這可能是出於完整性的考慮，或是要某些場景下既要使用共享的享元，又要使用不共享的享元吧。關於這一點本人也還沒有完全理解，也有可能根本不需要這一個不共享的享元物件吧。下面是不共享的享元類圖：

不共享的享元實現與 ConcreteFlyweight 無異。如下：
UnsharedConcreteFlyweight.java

public class UnsharedConcreteFlyweight implements Flyweight {

    private String intrinsicState = null;

    public UnsharedConcreteFlyweight(String _intrinsicState) {
        this.intrinsicState = _intrinsicState;
    }

    @Override
    public void operation(String extrinsicState) {
        System.out.println("內蘊狀態：" + intrinsicState);
        System.out.println("外蘊狀態：" + extrinsicState);
    }
}

下面是對單純的享元與不共享的享元進行測試的程式碼。
Client.java

public class Client {

    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();

        Flyweight fly1 = factory.factory("Hello");
        fly1.operation("ExtrinsicState-1");

        Flyweight fly2 = factory.factory("DesignPattern");
        fly2.operation("ExtrinsicState-2");

        Flyweight fly3 = factory.factory("Flyweight");
        fly3.operation("ExtrinsicState-3");

        Flyweight fly4 = factory.factory("Hello");
        fly4.operation("ExtrinsicState-4");

        System.out.println("fly1 == fly2 ? " + (fly1 == fly2));
        System.out.println("fly1 == fly3 ? " + (fly1 == fly3));
        System.out.println("fly1 == fly4 ? " + (fly1 == fly4));

        Flyweight fly5 = new UnsharedConcreteFlyweight("Unshared");
        fly5.operation("ExtrinsicState-5");
    }
}

內蘊狀態：Hello
外蘊狀態：ExtrinsicState-1
內蘊狀態：DesignPattern
外蘊狀態：ExtrinsicState-2
內蘊狀態：Flyweight
外蘊狀態：ExtrinsicState-3
內蘊狀態：Hello
外蘊狀態：ExtrinsicState-4
fly1 == fly2 ? false
fly1 == fly3 ? false
fly1 == fly4 ? true
內蘊狀態：Unshared
外蘊狀態：ExtrinsicState-5

複合享元模式

在上面的單純享元中，所有的享元可以說是在同一個分組裡。有時候這樣的大集合可能並不能發揮出很好的應用功能，所以引入了複合式的享元模式。下面是複合式享元模式類圖：

複合式享元相當於多個單純享元的集合。也就是說複合享元相當於對單純享元進行了一個再分組，在複合享元的每個分組裡又是一個獨立的單純享元模式。相關關鍵程式碼如下：
ConcreteCompositeFlyweight.java

public class ConcreteCompositeFlyweight implements Flyweight {

    private Map<Integer, Flyweight> labels = new HashMap<Integer, Flyweight>();

    public void add(int key, Flyweight flyweight) {
        labels.put(key, flyweight);
    }

    @Override
    public void operation(String extrinsicState) {
        Flyweight flyweight = null;
        for (Object key : labels.keySet()) {
            flyweight = labels.get(key);
            flyweight.operation(extrinsicState);
        }
    }
}

對於其構建工廠也需要進行重新設計，如下：
FlyweightFactory.java

public class FlyweightFactory {

    private Map<Integer, Flyweight> labels = new HashMap<Integer, Flyweight>();

    /**
     * 單純享元工廠
     */
    public Flyweight factory(String intrinsicState) {
         ... ...
         return fly;
    }

    /**
     * 複合享元工廠
     */
    public Flyweight compositeFactory(List<String> intrinsicStates) {
        ConcreteCompositeFlyweight flyweight = new ConcreteCompositeFlyweight();

        for (String intrinsicState : intrinsicStates) {
            flyweight.add(intrinsicState.hashCode(), factory(intrinsicState));
        }

        return flyweight;
    }
}

測試類
Client.java

public void compositeFlyweight() {
        List<String> intrinsicStates = new ArrayList<String>();
        intrinsicStates.add("Hello");
        intrinsicStates.add("Java");
        intrinsicStates.add("DesignPattern");
        intrinsicStates.add("Flyweight");

        FlyweightFactory factory = new FlyweightFactory();
        Flyweight flyweight1 = factory.compositeFactory(intrinsicStates);
        Flyweight flyweight2 = factory.compositeFactory(intrinsicStates);
        System.out.println("flyweight1 == flyweight2 ? " + (flyweight1 == flyweight2));

        flyweight1.operation("複合享元-1");
        flyweight2.operation("複合享元-2");
    }

flyweight1 == flyweight2 ? false
內蘊狀態：Java
外蘊狀態：複合享元-1
內蘊狀態：Flyweight
外蘊狀態：複合享元-1
內蘊狀態：Hello
外蘊狀態：複合享元-1
內蘊狀態：DesignPattern
外蘊狀態：複合享元-1
內蘊狀態：Java
外蘊狀態：複合享元-2
內蘊狀態：Flyweight
外蘊狀態：複合享元-2
內蘊狀態：Hello
外蘊狀態：複合享元-2
內蘊狀態：DesignPattern
外蘊狀態：複合享元-2

JDK 裡的享元模式

在 JDK 的設計裡，也有很享元模式。比如一些常量池的設計（String 常量池、Integer 常量池等等）；

Ref

GitHub 原始碼下載