结构模式--之--享元模式

享元模式是对象的结构模式，享元模式以共享的方式高效地支持大量的细粒度对象。享元对象能做到共享的关键区分内蕴状态和外蕴状态。

一个内蕴状态是存储在享元对象内部的，并且是不会随着环境改变而有所不同，因此，一个享元可以具有内蕴状态并可以共享。

一个外蕴状态是随着环境改变而改变，不可以共享的状态。享元对象 的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。外蕴状态不可以影响享元对象的内蕴状态。换句话说，它们是相互独立的。

 

根据所涉及的享元对象的内部表象，享元模式可以分成单纯享元模式和复合享元模式。

 

单纯享元模式：

在单纯享元模式中，所有的享元对象都是可以共享的。

 

单纯享元模式所涉及的角色如下：

1.抽象享元角色：此角色是所有的具体享元类的超类，为这些类规定出需要实现的公共接口。那些需要外蕴状态的操作可以通过调用商业方法以参数形式传入

2.具体享元角色：实现抽象享元角色所规定的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享的。

3.享元工厂角色：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个复合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象，如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。

4.客户端角色：本角色需要维护一个对所有享元对象的引用。本角色需要自行存储所有享元对象的外蕴状态。

 

示例性代码：

public class SimpleFlyweightTest {
    public static void main(String[] args) {
        //创建一个享元工厂对象
        FlyweightFactory factory = new FlyweightFactory();
        //向享元工厂对象请求一个内蕴状态的为”a“的享元对象
        Flyweight fly = factory.factory(new Character('a'));
        //以参量方式传入一个外蕴状态
        fly.operation("First Call");
        //向享元工厂对象请求一个内蕴状态的为”b“的享元对象
        fly = factory.factory(new Character('b'));
        //以参量方式传入一个外蕴状态
        fly.operation("Second Call");
        //向享元工厂对象请求一个内蕴状态的为”a“的享元对象
        fly = factory.factory(new Character('a'));
        //以参量方式传入一个外蕴状态
        fly.operation("Third Call");
    }

}

//抽象享元角色
abstract class Flyweight{
    //示意性方法，参数state是外蕴状态
    abstract public void operation(String state);
}

//具体享元角色，享元角色可以有内蕴状态，这里以一个Character类型属性代表，它的值应当在享元对象被创建时
//赋予，所有的内蕴状态在对象创建之后，就不会再改变了。
class ConcreteFlyweight extends Flyweight{
    
    private Character intrinsicState = null;
    
    //构造子，内蕴状态作为参量传入
    public ConcreteFlyweight(Character state){
        this.intrinsicState = state;
    }
    //外蕴状态作为参量传入方法中，改变方法的行为，但并不改变对象的内蕴状态
    @Override
    public void operation(String state) {
        System.out.println("Intrinsic State="+intrinsicState + ", Extrinsic State =" + state );
    }
    
}

//享元工厂角色，客户端不可以直接将具体享元类实例化，必须通过一个工厂对象，利用一个factory()方法得到
//享元对象。一般而言，享元工厂对象在整个系统中只有一个
class FlyweightFactory{
    private HashMap map = new HashMap();
    private Flyweight lnkFlyweight;
    
    //默认构造子
    public FlyweightFactory(){}
    
    //构造子
    public Flyweight factory(Character state){
        if(map.containsKey(state)){
            return (Flyweight)map.get(state);
        }else{
            Flyweight fly = new ConcreteFlyweight(state);
            map.put(state, fly);
            return fly;
        }
        
    }
    
    //辅助方法
    public void checkFlyweight(){
        Flyweight fly;
        int i=0;
        System.out.println("-------check flyweight--------");
        for(Iterator it = map.entrySet().iterator();it.hasNext();){
            Map.Entry e = (Map.Entry)it.next();
            System.out.println("Item" +(++i)+":"+e.getKey());
        }
        System.out.println("----------check flyweight--------");
    }
}

复合的享元模式：

单纯享元模式中，所有的享元对象都是单纯享元对象，也就是可以直接共享的。一种较复杂的情况是，将一些单纯享元使用合成模式加以复合，形成复合享元对象，这样的复合享元对象本身不能共享，但是它们可以分解成单纯享元对象，而后者可以共享。

 

角色：

1.抽象享元角色：它是所有的具体享元类的超类，为这些类规定需要实现的公共接口，那些需要外蕴状态的操作可以通过方法的参数传入。它使得享元变得可能，但并不强制子类实行共享，因此并非所有的享元对象都是可以共享的。

2.具体享元角色：实现抽象享元角色所规定的接口，如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享。有时候具体享元角色又叫单纯具体享元角色，因为复合享元角色是由单纯具体享元角色通过复合而成的。

3.复合享元角色：复合享元角色所代表的对象是不可以共享的。但是一个复合享元对象可以分解成为多个本身是单纯享元对角的组合。复合享元角色又称为不可共享的享元对象

4.享元工厂:它负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。

5.客户端角色：它还需要自行存储所有对象的外蕴状态。

示例代码：

public class MultiFlyweight {
    public static void main(String[] args) {
        //创建一个享元工厂对象
        FlyweightFactory factory = new FlyweightFactory();
        //向享元工厂对象请求一个内蕴状态的为”a“的享元对象
        Flyweight fly = factory.factory(new Character('a'));
        //以参量方式传入一个外蕴状态
        fly.operation("First Call");
        //向享元工厂对象请求一个内蕴状态的为”b“的享元对象
        fly = factory.factory(new Character('b'));
        //以参量方式传入一个外蕴状态
        fly.operation("Second Call");
        //向享元工厂对象请求一个内蕴状态的为”a“的享元对象
        fly = factory.factory(new Character('a'));
        //以参量方式传入一个外蕴状态
        fly.operation("Third Call");
        
        Flyweight fly2 = factory.factor("aba");
        fly2.operation("Composite Call");
        
    }

}
//抽象享元角色
abstract class Flyweight{
    abstract public void operation(String state);
}

//具体享元角色
class ConcreteFlyweight extends Flyweight{
    
    private Character intrinsicState = null;
    
    //构造方法，内蕴状态作为参量传入
    public ConcreteFlyweight(Character state){
        this.intrinsicState = state;
    }
    //外蕴状态作为参量传入到方法中
    @Override
    public void operation(String state) {
        System.out.println("Intrinsic State="+intrinsicState + ", Extrinsic State =" + state );
    }
    
}

//具体复合享元角色
class ConcreteCompositeFlyweight extends Flyweight{
    private Map map = new HashMap();
    private Flyweight flyweight;
    //增加一个新的单纯享元对象到聚焦中
    public void add(Character key,Flyweight fly){
        map.put(key, fly);
    }
    
    //外蕴状态作为参量传入到方法中
    @Override
    public void operation(String extrinsicState) {
        Flyweight fly = null;
        for(Iterator it = map.entrySet().iterator();it.hasNext();){
            Map.Entry e = (Map.Entry)it.next();
            fly = (Flyweight)e.getValue();
            fly.operation(extrinsicState);
        }
    }
    
}

//享元工厂角色
class FlyweightFactory{
    private HashMap map = new HashMap();
    //复合享元工厂方法，所需状态以参量形式传入 
    public Flyweight factor(String compositeState){
        ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight();
        int length = compositeState.length();
        Character state = null;
        for(int i=0;i<length;i++){
            state = new Character(compositeState.charAt(i));
            System.out.println("factory("+state+")");
            compositeFly.add(state, this.factory(state));
        }
        return compositeFly;
    }
    
    //单纯享元工厂方法，所需状态以参量形式传入
    public Flyweight factory(Character state){
        //检查具有此状态的享元是否存在
        if(map.containsKey(state)){
            //具有此状态的享元已经存在，因此直接将它返还
            return (Flyweight)map.get(state);
        }else{
            Flyweight fly = new ConcreteFlyweight(state);
            map.put(state, fly);
            return fly;
        }
    }
    //辅助方法
    public void checkFlyweight(){
        Flyweight fly;
        int i=0;
        System.out.println("-------check flyweight--------");
        for(Iterator it = map.entrySet().iterator();it.hasNext();){
            Map.Entry e = (Map.Entry)it.next();
            System.out.println("Item" +(++i)+":"+e.getKey());
        }
        System.out.println("----------check flyweight--------");
    }
}

 

享元模式应当在什么条件下使用？

当以下所有条件都满足时，可以考虑使用享元模式

1.一个系统有大量的对象

2.这些对象的耗费大量的内存

3.这些对象的状态中的大部分都可以外部化

4.这些对象可以按照内蕴状态分成很多的组，当把外蕴对象从对象中剔除时，每一个组都可以仅用一个对象替代

5.软件系统不依赖于这些对象的身份，换言之，这些对象可以是不可分辨的。

最后，使用享元模式需要维护一个记录了系统已有的所有享元对象的表，而这需要耗费资源，因此，应当在有足够多的享元实例可供共享时才值得使用享元模式。

 

优缺点：

1.享元模式使得系统更加复杂，为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化

2.享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长