亨元模式

时间：2020-09-03 16:36:15 收藏：0 阅读：45

介绍：

　　享元模式使用共享对象，用来尽可能减少内存使用量以及分享数据给尽可能多的相似对象；它适合用于当大量对象只是重复因而导致无法令人接受的使用大量内存。通常对象中的部分状态是可以分享。常见做法是把它们放在外部数据结构，当需要使用时再将它们传递给享元。

定义：

　　享元模式(FlyWeight)，运用共享技术有效的支持大量细粒度的对象。

结构图：

内部状态存储在享元内部，不会随环境的改变而有所不同，是可以共享的

外部状态是不可以共享的，它随环境的改变而改变的，因此外部状态是由客户端来保持(因为环境的变化是由客户端引起的)。

代码：

// Flyweight抽象类

所有具体享元类的超类或接口，通过这个接口，Flyweight可以接受并作用于外部状态。

class Flyweight
{

protected:
     //外部状态
    String extrinsic;       
public:
     //内部状态
    String intrinsic;
     //要求享元角色必须接受外部状态
    Flyweight(String extrinsic)
    {
        this.extrinsic = extrinsic;
    }
     //定义业务操作
    void operate(int extrinsic) = 0;
    String getIntrinsic() 
    {
        return intrinsic;
    }
    void setIntrinsic(String intrinsic) 
    {
        this.intrinsic = intrinsic;
    }   
}

ConcreteFlyweight类

ConcreteFlyweight是继承Flyweight超类或实现Flyweight接口，并为其内部状态增加存储空间。

 class ConcreteFlyweight : Flyweight 
 {
 public:
    //接受外部状态
    ConcreteFlyweight(String extrinsic) 
    {
        extrinsic = extrinsic;
    }
    
    //根据外部状态进行逻辑处理
    void operate(int extrinsic) 
    {
        System.out.println("具体Flyweight:" + extrinsic);
    }
}

UnsharedConcreteFlyweight类

指那些不需要共享的Flyweight子类。

class UnsharedConcreteFlyweight : Flyweight 
{
public:
    UnsharedConcreteFlyweight(String extrinsic) 
    {
        extrinsic = extrinsic;
    }

    void operate(int extrinsic) 
    {
        System.out.println("不共享的具体Flyweight:" + extrinsic);
    }
}

FlyweightFactory类

一个享元工厂，用来创建并管理Flyweight对象，主要是用来确保合理地共享Flyweight，当用户请求一个Flyweight时，FlyweightFactory对象提供一个已创建的实例或创建一个实例。

class FlyweightFactory 
{
private:
//定义一个池容器
    map<String, Flyweight*> pool;

//享元工厂
    Flyweight* getFlyweight(String extrinsic) 
    {
        Flyweight* flyweight = null;

        map<String, Flyweight*>::iterator iter=std::find(pool.begin(),pool.end(),extrinsic);
        if(iter != pool.end()) 
        {    
            //池中有该对象
            flyweight = *iter;
            System.out.print("已有 " + extrinsic + " 直接从池中取---->");
        } 
        else 
        {
            //根据外部状态创建享元对象
            flyweight = new ConcreteFlyweight(extrinsic);
            //放入池中
            pool.pushback(extrinsic, flyweight);
            System.out.print("创建 " + extrinsic + " 并从池中取出---->");
        }

        return flyweight;
    }
}

//客户端

Flyweight flyweightX = FlyweightFactory.getFlyweight("1");
flyweightX.operate(++ extrinsic);

Flyweight flyweightY = FlyweightFactory.getFlyweight("2");
flyweightY.operate(++ extrinsic);

Flyweight flyweightZ = FlyweightFactory.getFlyweight("3");
flyweightZ.operate(++ extrinsic);

Flyweight flyweightReX = FlyweightFactory.getFlyweight("1");
flyweightReX.operate(++ extrinsic);

使用时机：

如果一个应用程序使用了大量的对象，而这些对象造成了很大的存储开销的时候就可以考虑是否可以使用享元模式.

优点：

大大减少对象的创建，降低系统的内存，使效率提高

缺点：

提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。