12.轻量模式--Flyweight

原文地址：http://blog.csdn.net/jjunjoe/article/details/6671890

Flyweight模式（又叫享元模式）：
Flyweight模式运用共享技术有效地支持大量细粒度的对象。

在Flyweight模式中，在享元对象内部并且不会随环境改变而改变的共享部分，可以称为是享元对象的内部状态，而随环境改变而改变的、不可以共享的状态就是外部状态了。享元模式可以避免大量非常相类似的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本上都是相同的，有时就能够大幅度的减少需要实例化的类的数量。如果能把那些参数移到类实例的外面，在方法调用时将他们传递进来，就可以通过共享大幅度的减少单个实例的数目。

如果一个应用程序是用了大量的对象，而大量的这些对象造成了很大的存储开销时就应该考虑使用Flyweight模式；还有就是如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用Flyweight模式。

比如在文档编辑器的设计过程中，我们如果为每一字母创建一个对象的话，系统可能会因为大量的对象而造成存储开销的浪费。例如一个字母“a”在文档中出现了100000次，而实际上我们可以让这一万个字母“a”共享一个对象，当然因为在不同的位置可能字母“a”有不同的显示效果（例如字体和大小等设置不同），在这种情况我们可以为将对象的状态分为“外部状态”和“内部状态”，将可以被共享（不会变化）的状态作为内部状态存储在对象中，而外部对象（例如上面提到的字体、大小等）我们可以在适当的时候将外部对象最为参数传递给对象（例如在显示的时候，将字体、大小等信息传递给对象）。

Flyweight模式典型的结构图为：
 

Flyweight模式中有一个类似Factory模式的对象构造工厂FlyweightFactory，当客户程序员（Client）需要一个对象时候就会向FlyweightFactory发出请求对象的消息GetFlyweight（）消息，FlyweightFactory拥有一个管理、存储对象的“仓库”（或者叫对象池，vector实现），GetFlyweight（）消息会遍历对象池中的对象，如果已经存在则直接返回给Client，否则创建一个新的对象返回给Client。当然可能也有不想被共享的对象（例如结构图中的UnshareConcreteFlyweight），但不在本模式的讲解范围，故在实现中不给出。

Flyweight模式的实现代码如下：

//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:内蕴["<<this->GetIntrinsicState()<<"] 外蕴["<<extrinsicState<<"]"<<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_H_


//FlyweightFactory.cpp
#include "FlyweightFactory.h"
#include <iostream>
#include <string>
#include <cassert>
using namespace std;
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 created 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();

    string str("aa");
    Flyweight* fw1 = fc->GetFlyweight("hello");     // 内部状态
    fw1->Operation(str);        // 外部状态

    str = "bb";
    Flyweight* fw2 = fc->GetFlyweight("world!");    // 内部状态
    fw2->Operation(str);        // 外部状态

    str = "cc";    
    Flyweight* fw3 = fc->GetFlyweight("hello");     // 内部状态
    fw3->Operation(str);        // 外部状态

    return 0;
}

Flyweight模式的缺点：Flyweight模式可以运用共享技术有效的支持大量细粒度的对象，但使用Flyweight模式需要维护一个记录了系统已有的所有享元的列表，而这本身需要消耗资源，另外享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。因此，应当在有足够多的对象实例可供共享式才值得使用享元模式。