设计模式之享元模式

享元模式(FlyWeight)，其含义是运用共享技术有效地支持大量细粒度的对象，即系统只使用少量的对象，而这些对象都相近，状态变化很小，对象使用次数却很多。

享元模式能做到共享的关键是区分内蕴状态和外蕴状态，一个内蕴状态是存储在享元对象内部的，并且是不会随环境改变而有所不同的。因此一个享元可以具有内蕴状态并可以共享。一个外蕴状态是随环境改变而改变的、不可以共享的状态。享元对象的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。外蕴状态不可以影响享元对象的内蕴对象。换句话说，它们是互相独立的。

其适用性：

一个应用程序使用了大量的对象，

完全由于使用大量的对象，造成很大的存储开销，

对象的大多数状态都可变为外部状态，

如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，

应用程序不依赖于对象标识。由于Flyweight对象可以被共享，对于概念上明显有别的对象，标识测试将返回真值。

  结构如下：

           

  享元模式在使用时分为单纯享元模式和复合享元模式两种，单纯享元模式中Flyweight都是可共享的，也是现在Flyweight实现的较多实例。现在先列出单纯享元模式：

 Flyweight.java

package org.designpattern.structural.flyweight;

    public abstract class Flyweight {
         protected Character intrinsicState;

         protected Flyweight(Character intrinsicState){
             this.intrinsicState = intrinsicState;
         };
         public abstract  void  operation(String extrinsicState);
         public Character getIntrinsicState(){
             return this.intrinsicState;
         };
     }

  ConcreteFlyweight.java继承了Flyweight，实现了一个operation方法，类略。Flyweight是通过工厂得到的，下面是FlyweightFactory.java

	package org.designpattern.structural.flyweight;
	import java.util.HashMap;

	public class FlyweightFactory {
	    private HashMap flyWeights;
  	    public FlyweightFactory(){
 	       flyWeights = new HashMap();
	    }
	    public Flyweight getFlyweight(Character key){
 	       if(this.flyWeights.containsKey(key)){
	            System.out.println(key + " already created!");
	            return (Flyweight) flyWeights.get(key);
	        }else{
	             Flyweight flyweight = new ConcreteFlyweight(key);
	             flyWeights.put(key,flyweight);
	             return flyweight;
	        }
	    }	} 

  如果是单纯享元模式，到这里再加上客户测试类就结束了。如果使用复合享元模式，复合元素的对象的状态是会改变的，所以复合享元对象是不能共享的。需要再增加一个类UnsharedConcreteFlyeweight.java

public class UnsharedConcreteFlyweight extends Flyweight {

    private HashMap<Character,Flyweight> unsharedFlyweights;
    private Flyweight  flyweight;

    public UnsharedConcreteFlyweight(Character intrinsicState) {
        super(intrinsicState);
        this.unsharedFlyweights = new HashMap(20);
    }

    public void add(Character key,Flyweight flyweight){
        this.unsharedFlyweights.put(key,flyweight);
    }
    @Override
    public void operation(String extrinsicState) {
        System.out.println("extrinsicState:" + extrinsicState);
        Iterator<Map.Entry<Character,Flyweight>> it = unsharedFlyweights.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry<Character,Flyweight> entry = it.next();
            Flyweight fly = entry.getValue();
            fly.operation(extrinsicState);
        }
    }

   } 

此时在FlyweighFactory.java中需要增加一个方法支持不可共享的Flyweight的调用：

 public Flyweight getUnsharedFlyweight(String keys ){

        UnsharedConcreteFlyweight unsharedConcreteFlyweight = new UnsharedConcreteFlyweight(null);
        for(int i=0;i<keys.length();i++){
            Character character = new Character(keys.charAt(i));
            unsharedConcreteFlyweight.add(character,getFlyweight(character));
        }
        return unsharedConcreteFlyweight;

    }

 下面是客户测试类：

   package org.designpattern.structural.flyweight;
   public class Main {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        Flyweight fly1 = factory.getFlyweight('a');
        fly1.operation("First call!");
        Flyweight fly2 = factory.getFlyweight('b');
        fly2.operation("Second call!");
        Flyweight fly3 = factory.getFlyweight('a');
        fly3.operation("Third call!");
        System.out.println(fly1 == fly3);

        Flyweight unsharedFlyweight = factory.getUnsharedFlyweight("abcde");
        unsharedFlyweight.operation("Forth call!");
     }

  } 

 享元模式的有效性很大程度上取决于在何种情景下使用它，其主要缺点是使系统设计变得更加复杂，将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。我们通常会把Flyweight工厂设计为单例模式，其可以和许多模式共同使用更有效。