结构型模式—享元模式

Posted 浅墨浓香

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了结构型模式—享元模式相关的知识,希望对你有一定的参考价值。

1. 享元模式(Flyweight Pattern)的定义

(1)运用共享技术高效地支持大量细粒度的对象

  ①对象内部状态数据不变且重复出现,这部分不会随环境变化而改变,是可以共享的

  ②对象外部状态数据是变化的,会随环境变化而改变,是不可以共享的

  ③所谓的享元,就是把内部状态的数据分离出来共享,通过共享享元对象,可以减少对内存的占用。把外部状态分离出来,放到外部,让应用程序在使用的时候进行维护,并在需要的时候传递给享元对象使用。

  ④享元模式真正缓存和共享的是享元的内部状态,而外部状态是不被缓存共享的。同时内部状态和外部状态是独立的,外部状态的变化不会影响到内部状态。

(2)享元模式的结构和说明

 

  ①Flyweight:接口或抽象类,通过这个接口Flyweight可以接受并作用于外部状态。通过这个接口传入外部的状态,在享元对象的方法处理中可能会使用这些外部的数据。

  ②ConcreteFlyweight:具体的享元实现对象,必须是可共享的,为内部状态提供成员变量进行存储。(真正要被共享的对象

  ③UnsharedConcreteFlyweight:非共享的享元实现对象,并不是所有的Flyweight实现对象都需要共享。非共享的享元实现对象通常是对共享享元对象的组合对象,这种对象虽然不需要加入到享元工厂中去共享,但也继承自Flyweight,其好处是可以统一接口。注意,本例中的UnsharedConcreteFlyweight是从Flyweight继承而来,有时也可以不用继承自Flyweight。(该类的作用:提供外部状态存储

  ④FlyweightFactory:为控制内部状态的共享,并且让外部能简单地使用共享数据,提供一个工厂来管理享元,把它称为享元工厂。其作用主要用来创建并管理共享的享元对象享元池一般设计成键值对。这里也对外提供访问共享享元的接口。

  ⑤Client:享元客户端,主要的工作是维持一个对Flyweight的引用,计算或存储享元对象的外部状态。当然这里可以访问共享和不共享的Flyweight对象。

(3)思考享元模式

  ①享元模式的本质:分离与共享。享元模式的关键在于分离变与不变,把不变部分作为享元对象的内部状态,而变化部分则作为外部状态,由外部来维护.这样享元对象就能够被共享,从而减少对象的数量,并节省大量的内存空间。

  ②享元模式的变与不变:为什么在一个地方要预留接口,一个常见的原因是这里存在变化,可能在今后需要扩展或改变己有的实现,而预留接口作为“可插入性的保证”

  ③享元对象:又有共享(ConcreteFlyweight)与不共享(UnsharedConcreteFlyweight)之分。不共享一般出现在和组合模式合用的情况,通常共享是叶子对象,一般不共享的部分是由共享部分组合而成,由于所有细粒度的叶子对象己经缓存了,那么缓存组合对象就没有什么意义。(如权限管理中某安全实体的“查看”和“修改”是可共享的,如果将“查看”和“修改”组合成“操作”权限的话,则操作”权限是不用缓存(共享)的,因为己经在细粒度上进行了缓存)。(见后面的例子)

【编程实验】围棋软件设计

  ①内部状态:每个围棋那么多的棋子,可设置为享元对象,有如下属性颜色、大小、形状。

  ②外部状态:棋子在棋盘中的位置。这是不可共享的。

//结构型模式:享元模式
//场景:围棋软件设计。
//内部状态——围棋棋子数量多,但分只为两类:白棋和黑棋。
//          有颜色、大小、形态等属性,是可共享的对象。
//外部状态——棋子在棋盘中的位置。

#include <iostream>
#include <string>
#include <map>

using namespace std;

//************************************享元类**************************
class Coordinate; //前向声明

//享元抽象类
class ChessFlyweight
{
public:
    virtual string& getColor() = 0;
    virtual void setColor(string color) = 0;
    
    //显示棋子在棋盘中的位置
    //可以通过这个接口,将外部状态传入享元对象中
    virtual void display(Coordinate& c) = 0;
};

//非享元对象:UnsharedConcreteFlyweight(外部状态)
class Coordinate
{
    int x,y;
public:
    Coordinate(int x, int y){this->x = x;this->y = y;}
    int getX(){return x;}
    void setX(int x){this->x = x;}

    int getY(){return y;}
    void setY(int x){this->y = y;}        
};

//享元对象:ConcreteFlyweight(内部状态)
class ConcreteChess : public ChessFlyweight
{
private:
    string color;
public:
    ConcreteChess(string color){this->color = color;} 
    string& getColor() {return color;}
    void setColor(string color){this->color = color;}
    
    void display(Coordinate& c)
    {
        cout << "Chess\'s Color: " << color << endl; 
        cout << "Position: x = " << c.getX() << " y = " << c.getY() << endl;
    }
};

//************************************享元工厂类**************************
class ChessFlyweightFactory
{
private:
    static map<string,ChessFlyweight*> chessMap;
public:
    static ChessFlyweight* getChess(string color)
    {
        ChessFlyweight* ret = chessMap[color]; 
        if(ret == NULL)
        {
            ret = new ConcreteChess(color);
            chessMap[color] = ret;
        }
        return ret;   
    }

    static void clear()
    {
        map<string, ChessFlyweight*>::iterator iter = chessMap.begin();
        while(iter != chessMap.end())
        {
            delete iter->second;
            cout <<iter->second << endl;
            ++iter;
        }
        chessMap.clear();
    }    
};

map<string,ChessFlyweight*> ChessFlyweightFactory::chessMap;

int main()
{
    ChessFlyweight* chess1 = ChessFlyweightFactory::getChess("black");
    ChessFlyweight* chess2 = ChessFlyweightFactory::getChess("black");
    ChessFlyweight* chess3 = ChessFlyweightFactory::getChess("white");
    
    cout << "chess1 = " << chess1 << endl;
    cout << "chess2 = " << chess2 << endl;
    cout << "chess3 = " << chess3 << endl;
    
    //增加外部状态的处理
    cout << "extrinsic state: " << endl;
    Coordinate c1(10, 10);
    Coordinate c2(20, 20);
    Coordinate c3(30, 30);
    
    chess1->display(c1);
    chess2->display(c2);
    chess3->display(c3);
    
    //删除享元池中的对象
    ChessFlyweightFactory::clear();
    
    return 0;
}

2. 享元模式的对象管理

(1)实用引用计数的基本思路

  在享元工厂中定义另外一个map,它的key值与缓存对象的key是一样的,而value就是被引用的次数,这样当外部每次获取该享元的时候,就把对应的引用计数加1,然后再记录回去。

(2)实现垃圾回收的基本思路

  ①确定垃圾:定义一个缓存对象的配置对象,在这个对象中描述了缓存的开始时间和最长不被使用时间,则当前的时间-缓存开始时间≥最长不被使用使间是表示为垃圾。当然每次对象被使用时,就把那个缓存开始的时间更新为使用时的当前时间

  ②回收时机:判断出是垃圾的时候就可以回收了。谁来判断垃圾?一般定义一个内部线程,这个线程在享元工厂被创建时启动,每隔一定的时间来循环缓存中所有对象的缓存配置,看是否是垃圾,如果是就可以启动回收了。

(3)怎么回收:直接从缓存的Map对象删除相应的对象。

3. 享元模式的优缺点

(1)优点:减少对象数量,节省内存空间

(2)缺点:维护共享对象,需要额外开销。如需要额外的线程来维护垃圾回收。

4. 使用场景

(1)系统中存在大量的相似对象

(2)细粒度的对象都具有较接近的外部状态,而且内部状态与环境无关,也就是说对明没有特定的身份。

(3)需要缓冲池的场景

(4)如果不考虑对象的外部状态,可以用相对较少的共享对象取代很多组合对象,可以使用享元模式来共享对象,然后组合对象来使用这些共享对象。

【编程实验】权限管理系统

 

//结构型模式:享元模式
//场景:权限管理。
//几个概念
//1.安全实体:如某个数据表
//2.权限:指很对安全实体进行的操作,如查看、修改、删除等。
//几个问题
//1.因安全实体的权限可能被成千上万的人共享。如“人员列表”的查询权限
//  为了减少创建对象,可以将“人员列表”的“查询”权限作为一个享元对象,放入享元工厂
//2.为了增加实用性,这里采用享元模式+组合模式的方式实现了多层次的权限管理。
//  组合:将安全实体的权限进行组合,如“查看”+“修改” = “操作”权限,由于“操作”是组
//  合的权限,所以无须在享元工厂中缓存,即这个组合对象是个UnsharedConcreteFlyweight
//  对象。
//3. 享元工厂的垃圾回收:创建一个线程,专门负责过期的垃圾回收

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <ctime>
#include <windows.h>
#include <process.h>

using namespace std;

//////////////////////////////////////////////////////////////////////////
// 字符串分割
// 
// -------------------------------------------------------------------------
// 函数     : Split
// 功能     : 分割STL标准字符串
// 返回值   : void 
// 参数     : Container<std::basic_string<CharT> >& v 存放分割结果
// 参数     : const std::basic_string<CharT>& s 待分割字符串
// 参数     : const std::basic_string<CharT>& c 分割字符串
// -------------------------------------------------------------------------
template<typename CharT, template<typename S, typename Q = std::allocator<S> > class Container>
void Split(Container<std::basic_string<CharT> >& v, const std::basic_string<CharT>& s, const std::basic_string<CharT>& c);

template<template<typename S, typename Q = std::allocator<S> > class Container>
void Split(Container<std::basic_string<char> >& v, const std::basic_string<char>& s, const std::basic_string<char>& c)
{
    if (0 == c.length())
        return;

    std::basic_string<char>::size_type pos1 = 0;
    std::basic_string<char>::size_type pos2 = 0;

    pos1 = 0;
    pos2 = s.find(c);
    while (std::basic_string<char>::npos != pos2)
    {
        v.push_back(s.substr(pos1, pos2 - pos1));

        pos1 = pos2 + c.size();
        pos2 = s.find(c, pos1);
    }

    if (pos1 != s.length())
    {
        v.push_back(s.substr(pos1));
    }
}

//*******************************************辅助类******************************
//测试数据(在内存中模拟数据库中的值)
class TestDB
{
private:
    TestDB(){}
public:
    //用来存放单独授权数据的值
    static vector<string> vectorDB;

    //用来存放组合授权数据的值
    //其中的key为组合数据的id,value为该组合包含的多条授权数据的值
    static map<string, vector<string> > mapDB;
};
//单独授权数据
static vector<string>::value_type init_value[] =
{
    vector<string>::value_type("ZhangSan,PersonTable,Query,1"),
    vector<string>::value_type("LiSi,PersonTable,Query,1"),
    vector<string>::value_type("LiSi,OperateSalaryTable,,2"),
    vector<string>::value_type("ZhangSan0,PersonTable,Query,1"),
    vector<string>::value_type("ZhangSan1,PersonTable,Query,1"),
    vector<string>::value_type("ZhangSan2,PersonTable,Query,1"),
};
vector<string> TestDB::vectorDB(init_value, init_value + 6);

//组合授权数据
static vector<string>::value_type initValue[] =
{
    vector<string>::value_type("SalaryTable,Query"),
    vector<string>::value_type("SalaryTable,Modify")
};
static vector<string> compositePermit(initValue, initValue + 2);
static map<string, vector<string> >::value_type initMap_value[] =
{
    map<string, vector<string> >::value_type("OperateSalaryTable", compositePermit)
};

map<string, vector<string> > TestDB::mapDB(initMap_value, initMap_value + 1);


//**********************************享元类************************
//享元接口:描述授权数据的接口
class  Flyweight
{
public:
    virtual bool match(string securityEntity, string permit) = 0;

    //享元模式与组合模式的结合。为Flyweight添加子Flyweight对象
    virtual void add(Flyweight* f) = 0;
};

//具体享元对象(封装授权数据中重复出现的部分)
//由于add是针对组合对象的,而这个可共享的是叶子对象,所以这里抛出
//异常就可以了。
//享元工厂里存放的是这个对象,如“薪资数据表的查看权限”。因为某一权限
//可能被分配给成上千万个人,所以需要缓存。即享元
class AuthorizationFlyweight : public Flyweight
{
private:
    //内部状态

    string securityEntity;//安全实体
    string permit;        //权限

public:
    //构造函数,传入状态数据,包含安全实体和权限的数据,用“,”分隔
    AuthorizationFlyweight(string state)
    {
        vector<string> v;
        Split(v, state, ",");
        securityEntity = v[0];
        permit = v[1];
    }

    string& getSecurityEntity(){ return securityEntity; }
    string& getPermit(){ return permit; }

    bool match(string securityEntity, string permit)
    {
        bool ret = (this->securityEntity == securityEntity &&
                    this->permit == permit);

        return ret;
    }

    void add(Flyweight* f)
    {
        //叶子对象,什么都不做!这里也可以抛出异常!
    }
};

//不需要共享的享元对象的实现,也是组合模式中的组合对象
class UnsharedConcreteFlyweight : public Flyweight
{
private:
    //记录每个组合对象所包含的子组件
    vector<Flyweight*> flyweights;
public:
    void add(Flyweight* f)
    {

        flyweights.push_back(f);
    }

    bool match(string securityEntity, string permit)
    {
        bool ret = false;

        vector<Flyweight*>::iterator iter = flyweights.begin();
        while (iter != flyweights.end())
        {
            if ((*iter)->match(securityEntity, permit))
            {
                ret = true;
                break;
            }
            ++iter;
        }
        return ret;
    }

};

//**************************************垃圾回收************************
//描述享元对象缓存的配置对象
class CacheConfModel
{
private:

    //被引用次数
    int refCount;

    //缓存开始计时的开始时间
    long beginTime;

    //缓存对象存放的持续时间,其实是最长不被使用时间
    double durableTime;

    //缓存对象需要被永久存储,也就是不需要从缓存中删除
    bool forever;
public:
    CacheConfModel() :refCount(0), beginTime(0), durableTime(0), forever(false){}

    int getRefCount(){ return refCount; }
    void setRefCount(int refCount){ this->refCount = refCount; }
    int addRefCount(){ return ++refCount; }
    int decRefCount(){ return --refCount; }

    bool isForever(){ return forever; }
    void setForever(bool forever){ this->forever = forever; }

    long getBeginTime(){ return beginTime; }
    void setBeginTime(long beginTime){ this->beginTime = beginTime; }

    double getDurableTime(){ return durableTime; }
    void setDurableTime(double durableTime){ this->durableTime = durableTime; }

};

//******************************************************************
//享元工厂,通常实现为单例
//加入实现垃圾回收和引用计数的功能
class FlyweightFactory
{
private:
    //构造函数设为私有
    FlyweightFactory()
    {
        //启动清除缓存值的线程
        HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, clearCache, NULL, 0, NULL);

    };

    //缓存多个Flyweight对象
    static map<string, Flyweight*> fsMap;

    //用来缓存被共享对象的缓存配置,key和上面fsMap一致
    static map<string, CacheConfModel> cacheConfMap;

    //默认保存6秒钟,主要为了测试方便,这个时间可以根据实际来设置
    static const long DURABLE_TIME = 6L;

    //删除key对应的享元对象,连带清除对应的缓存配置
    void removeFlyweight(string key) //线程不安全,实际应用中要加同步
    {
        fsMap.erase(key);
        cacheConfMap.erase(key);
    }

    //维护清除缓存的线程函数
    static unsigned int __stdcall clearCache(PVOID pvParam)
    {
        while (true)
        {
            map<string, CacheConfModel>::iterator iter = cacheConfMap.begin();
            vector<string> tmpKey;

            CacheConfModel ccm;
            while (iter != cacheConfMap.end())
            {
                ccm = iter->second;

                //比较是否需要清除
                if (time(NULL) - ccm.getBeginTime() >= 
                    ccm.getDurableTime())
                {
                    //可以清除,先记录下来
                    tmpKey.push_back(iter->first);
                }
                ++iter;
            }

            //真正清除
            vector<string>::iterator iterKey = tmpKey.begin();
            while (iterKey != tmpKey.end())
            {
                (FlyweightFactory::getInstance())->removeFlyweight(*iterKey);
                ++iterKey;
            }

            //显示
            cout << "now thread=" << fsMap.size() << " [";
            map<string, Flyweight*>::iterator fsIter = fsMap.begin();
            while (fsIter != fsMap.end())
            {
                cout << fsIter->first << ";";
                ++fsIter;
            }
            cout << "]" << endl;

            //休息1秒钟,再重新判断
            Sleep(1000);
        }
        return 0;
    }

public:
    static FlyweightFactory* getInstance(){
        static FlyweightFactory factory;
        return &factory;
    }

    //缓存多个Flyweight对象(线程不安全,实际应用中要加同步)
    Flyweight* getFlyweight(string key)
    {
        Flyweight* f = fsMap[key];

        if (f == NULL)
        {
            f = new AuthorizationFlyweight(key);
            fsMap[key] = f;

            //同时设置缓存配置数据和引用计数
            CacheConfModel cm;
            cm.setBeginTime((long)time(NULL));
            cm.setDurableTime(DURABLE_TIME);
            cm.setForever(false);
            cm.addRefCount();

            cacheConfMap[key] = cm;
        } else
        {
            CacheConfModel cm = cacheConfMap[key];
            cm.setBeginTime((long)time(NULL));
            cm.addRefCount();
            cacheConfMap[key] = cm;
        }
        return f;
    }

    //获取某个享元被使用的次数(线程不安全,没有同步!)
    int getUseTimes(string key)
    {
        CacheConfModel ccm = cacheConfMap[key];
        return ccm.getRefCount();
    }

};

map<string, Flyweight*>  FlyweightFactory::fsMap;
map<string, CacheConfModel>  FlyweightFactory::cacheConfMap;

//安全管理,实现成单例
class SecurityMgr
{
private:
    SecurityMgr(){}
public:
    //饿汉式
    static SecurityMgr* getInstance()
    {
        static SecurityMgr instance;
        return &instance;
    }

    //从数据库中获取某人所拥有的权限
    vector<Flyweight*> queryByUser(string user)
    {
        vector<Flyweight*> ret;
        vector<string> vc;
        vector<string>::iterator iter = TestDB::vectorDB.begin();

        while (iter != TestDB::vectorDB.end())
        {
            vc.clear();
            Split(vc, *iter, ",");

            if (vc.size() <4) break;

            if (vc[0] == user)
            {

                Flyweight* fm = NULL;
                if (vc[3] == "2"){
                    //表示组合
                    fm = new UnsharedConcreteFlyweight();
                    vector<string> tempSs = TestDB::mapDB[vc[1]];
                    vector<string>::iterator iter = tempSs.begin();
                    while (iter != tempSs.end())
                    {
                        Flyweight* tempFm = (FlyweightFactory::getInstance())->getFlyweight(*iter);
                        //把这个对象加入到组合对象中
                        fm->add(tempFm);
                        ++iter;
                    }

                } else
                {
                    fm = (FlyweightFactory::getInstance())->getFlyweight(vc[1] + "," + vc[2]);
                }
                ret.push_back(fm);
            }

            ++iter;
        }

        return ret;
    }

    //判断某用户对某个安全实体是否拥有某种权限
    bool hasPermit(string user, string securityEntity, string permit)
    {
        bool ret = false;
        vector<Flyweight*> vfw = queryByUser(user);

        //cout << "Now testing: " << securityEntity << "\\\'s " << permit << " permission, map.size = "
        //<< maps.size() << endl;

        if (vfw.size() == 0)
        {
            cout << user << ": no permit to operate " << securityEntity << endl;
            return ret;
        }

        vector<Flyweight*>::iterator iter = vfw.begin();
        while (iter != vfw.end())
        {
            cout << "am == " << (*iter) << endl;
            if ((*iter)->match(securityEntity, permit))
            {
                ret = true;
                break;
            }

            ++iter;
        }

        return ret;
    }
};

int main()
{
    //客户端调用

    //需要先登录,然后再判断是否有权限
    SecurityMgr* mgr = SecurityMgr::getInstance();

    bool f1 = mgr->hasPermit("ZhangSan", "PersonTable", "Query");
    bool f2 = mgr->hasPermit("LiSi", 结构型模式之享元

结构型模式之 享元模式

设计模式-结构型模式-享元设计模式

设计模式-结构型模式-享元设计模式

结构型模式之享元模式

从零开始学习Java设计模式 | 结构型模式篇:享元模式