亨元模式學習

在面向對象的程序設計語言看來，一切事務都被描述成對象（Object）。
 對象擁有狀態（屬性）和行爲（方法），我們將具有相同行爲的對象抽象爲類（Class），
 類可以被看作只保留行爲的對象模板，類可以在運行時被重新賦予狀態數據從而形成了對象。
 在運行時，對象佔用一定的內存空間用來存儲狀態數據。如果不作特殊的處理，
 儘管是由同一個類生成的兩個對象，而且這兩個對象的的狀態數據完 全相同，
 但在內存中還是會佔用兩份空間，這樣的情況對於程序的功能也許並沒有影響，
 但如果把狀態相同的同一類對象在內存中進行合併，必然會大大減少存儲空 間的浪費。
 
 舉一個現實中的例子，某淘寶店經營一款暢銷女式皮鞋，每天需要處理大量的訂單信息，
 在訂單中需要註明客戶購買的皮鞋信息，我們將皮鞋產品抽象出來：

class Shoe{
    String color;//顏色
    int size;//尺寸
    String position;//庫存位置
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public int getSize() {
        return size;
    }
    public void setSize(int size) {
        this.size = size;
    }
    public String getPosition() {
        return position;
    }
    public void setPosition(String position) {
        this.position = position;
    }
}

正如上面的代碼所描述，皮鞋分爲顏色、尺寸和庫存位置三項狀態數據。
   其中顏色和尺寸爲皮鞋的自然狀態，我們稱之爲對象內部狀態，這些狀態數據只與對象本身 有關，
   不隨外界環境的改變而發生變化。再來看庫存位置，我們將這個狀態稱爲對象的外部狀態，
   外部狀態與對象本身無必然關係，外部狀態總是因爲外界環境的改 變而變化，
   也就是說外部狀態是由外界環境來決定的。在本例中，皮鞋今天放在A倉庫，明天可能放在B倉庫，
   但無論存放在哪個倉庫，同一只皮鞋就是同一只皮 鞋，它的顏色和尺寸不會隨着存放位置的不同而發生變化。
      享元模式的核心思想就是將內部狀態相同的對象在存儲時進行緩存。也就是說同一顏色同一尺寸的皮鞋，
 我們在內存中只保留一份實例，在訪問對象時，我們訪問的其實是對象緩存的版本，而不是每次都重新生成對象。
      享元模式仍然允許對象具有外部屬性，由於我們訪問的始終是對象緩存的版本，所以我們在使用對象前，
 必須將外部狀態重新注入對象。由於享元模式禁止生成新的對象，所以在使用享元模式時，通常伴隨着工廠方法的應用。我們來看下面的例子：

class ShoeFactory {
    Collection<Shoe> shoes = new ArrayList<Shoe>();
    Shoe getSheo(String color, int size, String position) {
        //首先在緩存中查找對象
        for (Shoe shoe : shoes) {
            if (shoe.getColor() == color && shoe.getSize() == size) {
                //在緩存中命中對象後還原對象的外部屬性
                shoe.setPosition(position);
                return shoe;
            }
        }
        //如果緩存未命中則新建對象並加入緩存
        Shoe shoe = new Shoe();
        shoe.setColor(color);
        shoe.setSize(size);
        shoe.setPosition(position);
        shoes.add(shoe);
        return shoe;
    }
}

  在面向對象的程序設計語言看來，一切事務都被描述成對象（Object）。
 對象擁有狀態（屬性）和行爲（方法），我們將具有相同行爲的對象抽象爲類（Class），
 類可以被看作只保留行爲的對象模板，類可以在運行時被重新賦予狀態數據從而形成了對象。
 在運行時，對象佔用一定的內存空間用來存儲狀態數據。如果不作特殊的處理，
 儘管是由同一個類生成的兩個對象，而且這兩個對象的的狀態數據完 全相同，
 但在內存中還是會佔用兩份空間，這樣的情況對於程序的功能也許並沒有影響，
 但如果把狀態相同的同一類對象在內存中進行合併，必然會大大減少存儲空 間的浪費。
 
  舉一個現實中的例子，某淘寶店經營一款暢銷女式皮鞋，每天需要處理大量的訂單信息，
 在訂單中需要註明客戶購買的皮鞋信息，我們將皮鞋產品抽象出來：
 通過ShoeFactory工廠，我們每次拿到的皮鞋都是緩存的版本，如果緩存中沒有我們需要的對象，
 則新創建對象然後加入緩存中。注意上例中對象的外部屬性position是如何注回對象的。
 當我們在自己的業務場景中應用享元模式時，一定要注意分清對象的內部狀態和外部狀態，

享元模式強調緩存的版本只能包含對象的內部狀態。

二、定義
採用一個共享來避免大量擁有相同內容對象的開銷。
這種開銷中最常見、直觀的就是內存的損耗。享元模式以共享的方式高效的支持大量的細粒度對象。
在名字和定義中都體現出了共享這一個核心概念，
那麼怎麼來實現共享呢？要知道每個事物都是不同的，但是又有一定的共性，
如果只有完全相同的事物才能共享，那麼享元模式可以說就是不可行的；因此我們應該儘量將事物的共性共享，
而又保留它的個性。爲了做到這點，享元模式中區分了內蘊狀態和外蘊狀態。內蘊狀態就是共性，外蘊狀態就是個性了。
注：共享的對象必須是不可變的，不然一變則全變（如果有這種需求除外)
內蘊狀態存 儲在享元內部，不會隨環境的改變而有所不同，是可以共享的；外蘊狀態是不可以共享的，
它隨環境的改變而改變的，因此外蘊狀態是由客戶端來保持（因爲環境的 變化是由客戶端引起的）。
在每個具體的環境下，客戶端將外蘊狀態傳遞給享元，從而創建不同的對象出來。

三、舉例

1、

java通用類圖：

c++通用類圖：

Flyweight 模式中有一個類似 Factory 模式的對象構造工廠FlyweightFactory，

當客戶程序員（Client）需要一個對象時候就會向 FlyweightFactory 發出請求對象的消息 GetFlyweight（）消息，

FlyweightFactory 擁有一個管理、存儲對象的“倉庫” （或者叫對象池，vector 實現） ，

GetFlyweight（）消息會遍歷對象池中的對象，如果已經存在則直接返回給 Client，

否則創建一個新的對象返回給 Client。

2、

（1）

java來實現：

package test_java_Flyweight;

public abstract class Order {
    public abstract void sell();
}

package test_java_Flyweight;

public class FlavorOrder extends Order{
    public String flavor;

    public FlavorOrder(String flavor){
        this.flavor = flavor;
    }

    @Override
    public void sell() {
        // TODO Auto-generated method stub
    System.out.println("賣出一份" + flavor + "的咖啡。");
    }

}

package test_java_Flyweight;

import java.util.HashMap;
import java.util.Map;

public class FlavorFactory {
    private Map<String, Order> flavorPool =
            new HashMap<String, Order>();
    private static FlavorFactory flavorFactory =
            new FlavorFactory();
    private FlavorFactory(){
    }
    public static FlavorFactory getInstance(){
        return flavorFactory;
    }
    public Order getOrder(String flavor){
        Order order = null;
        // 如果此映射包含指定鍵的映射關係，則返回 true
        if(flavorPool.containsKey(flavor)){
            order = flavorPool.get(flavor);
        }else{
            order = new FlavorOrder(flavor);
            flavorPool.put(flavor, order);
        }

        return order;
    }

    public int getTotalFlavorsMade(){
        return flavorPool.size();
    }
}

package test_java_Flyweight;


import java.util.ArrayList;
import java.util.List;

public class Client {
    private static List<Order> orders = new ArrayList<Order>();
    private static FlavorFactory flavorFactory;
    private static void takeOrders(String flavor){
        orders.add(flavorFactory.getOrder(flavor));
    }
    public static void main(String[] args){
        flavorFactory = FlavorFactory.getInstance();
        // 增加訂單
           takeOrders("摩卡");
           takeOrders("卡布奇諾");
           takeOrders("香草星冰樂");
           takeOrders("香草星冰樂");
           takeOrders("拿鐵");
           takeOrders("卡布奇諾");
           takeOrders("拿鐵");
           takeOrders("卡布奇諾");
           takeOrders("摩卡");
           takeOrders("香草星冰樂");
           takeOrders("卡布奇諾");
           takeOrders("摩卡");
           takeOrders("香草星冰樂");
           takeOrders("拿鐵");
           takeOrders("拿鐵");
           // 賣咖啡
           for(Order order : orders){
               order.sell();
           }

           System.out.println("\n客戶一共買了" +  orders.size() + "杯咖啡！");
           System.out.println("共生成了" + flavorFactory.getTotalFlavorsMade() + "個FlavorOrder java對象");
    }

}

（2）

c++來實現：

// Flyweight.h

#ifndef _FLYWEIGHT_H_
#define _FLYWEIGHT_H_
#include <string>

using namespace std;

class Flyweight
{
public:
    virtual ~Flyweight();
    virtual void Operation(const string& extrinsicState);
    string GetIntrinsicState();
protected:
    Flyweight(string intrinsicState);
private:
    string _intrinsicState;
};

class ConcreteFlyweight:public Flyweight
{
public:
    ConcreteFlyweight(string intrinsicState);
    ~ConcreteFlyweight();
    void Operation(const string& extrinsicState);
protected:
private:
};
#endif // ~_FLYWEIGHT_H_

// Flyweight.cpp

#include "Flyweight.h"
#include <iostream>

using namespace std;

Flyweight::Flyweight(string intrinsicState)
{
    this->_intrinsicState = intrinsicState;
}

Flyweight::~Flyweight()
{
}

void Flyweight::Operation(const string& extrinsicState)
{
}


string Flyweight::GetIntrinsicState()
{
    return this->_intrinsicState;
}

ConcreteFlyweight::ConcreteFlyweight(string intrinsicState):Flyweight(intrinsicState)
{
    cout << "ConcreteFlyweight Build...." << intrinsicState << endl;
}

ConcreteFlyweight::~ConcreteFlyweight()
{
}

void ConcreteFlyweight::Operation(const string& extrinsicState)
{
    cout << "ConcreteFlyweight:" << endl;
}

//FlyweightFactory.h

#ifndef _FLYWEIGHTFACTORY_H_
#define _FLYWEIGHTFACTORY_H_
#include"Flyweight.h"
#include<string>
#include<vector>

using namespace std;

class FlyweightFactory
{
public:
    FlyweightFactory();
    ~FlyweightFactory();
    Flyweight* GetFlyweight(const string& key);
protected:
private:
    vector<Flyweight*> _fly;
};
#endif

//FlyweightFactory.cpp

#include "FlyweightFactory.h"
#include<iostream>
#include<string>
#include<cassert>

using namespace std;

FlyweightFactory::FlyweightFactory()
{
}

FlyweightFactory::~FlyweightFactory()
{
}

Flyweight* FlyweightFactory::GetFlyweight(const string& key)
{
    vector<Flyweight*>::iterator it = _fly.begin();

    for(; it != _fly.end(); it++)
    {
        if((*it)->GetIntrinsicState() == key)
        {
            cout << "already create by users.... " << endl;
            return *it;
        }

    }

    Flyweight* fn = new ConcreteFlyweight(key);

    _fly.push_back(fn);
    return fn;
}

測試代碼：

// main.cpp

#include"Flyweight.h"
#include"FlyweightFactory.h"
#include<iostream>

using namespace std;

int main(int argc, char* argv[])
{
    FlyweightFactory* fc  = new FlyweightFactory();
    Flyweight* fw1 = fc->GetFlyweight("hello");
    Flyweight* fw2 = fc->GetFlyweight("world");
    Flyweight* fw3 = fc->GetFlyweight("hello");
    return 0;
}

代碼說明：

Flyweight 模式在實現過程中主要是要爲共享對象提供一個存放的“倉庫” （對象池） ， 
這裏是通過 C++ STL中Vector容器，當然就牽涉到 STL 編程的一些問題（Iterator使用等） 。
另外應該注意的就是對對象“倉庫” （對象池）的管理策略（查找、插入等） ，這裏是通過直
接的順序遍歷實現的。

（3）

Android SDK源碼之亨元模式：

Android中SQLiteCompiledSql的使用，其實是很多數據庫系統典型的實現。從應用啓動，通過各種數據庫操作，我們不知道進行了多少次的查詢操作，而這些操作中又有相當一部分sql語句是相同的，這些編譯後的sql編譯對象其實是一樣的，是可以共用共享的，其實就是緩存。SQLiteCompiledSql就是這樣的一個需要共享的享元對象。

享元對象類SQLiteCompiledSql，主要是內部狀態sql語句：

class SQLiteCompiledSql {
    private String mSqlStmt = null;
    native_compile(sql);
    native_finalize();
}

享元工廠類：

public class SQLiteDatabase{
     Map<String, SQLiteCompiledSql> mCompiledQueries = Maps.newHashMap();
     SQLiteCompiledSql getCompiledStatementForSql(String sql) {
        SQLiteCompiledSql compiledStatement = null;
        boolean cacheHit;
        synchronized(mCompiledQueries) {
            if (mMaxSqlCacheSize == 0) {
                return null;
            }
            cacheHit = (compiledStatement = mCompiledQueries.get(sql)) != null;
        }
        if (cacheHit) {
            mNumCacheHits++;
        } else {
            mNumCacheMisses++;
        }
        return compiledStatement;
    }

    private void deallocCachedSqlStatements() {
        synchronized (mCompiledQueries) {
            for (SQLiteCompiledSql compiledSql : mCompiledQueries.values()) {
                compiledSql.releaseSqlStatement();
            }
            mCompiledQueries.clear();
        }
    }

    void addToCompiledQueries(String sql, SQLiteCompiledSql compiledStatement) {
         //省略具體代碼
    }
}