设计模式之结构模式之享元模式

1，UML图
  
  

   单纯享元模式：
      抽象享元角色：此角色是所有的具体享元类的超类，为这些规定出需要实现的公共接口。那些需要外蕴状态(External State)的操作可以通过调用商业方法以参数形式传入。
      具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定的接口。如果有内蕴状态的话，必须负责为内蕴状态的话，必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享的。
      享元工厂(FlyweightFactory)角色：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色 会检查系统中是否已经有一个复合要要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。
      客户端(Client)角色：本角色需要维护一个对所有享元对象的作用。本角色需要自行存储所有享元对象的外蕴状态。



   复合享元模式：

      抽象享元角色：此角色是所有的具体享元类的超类，为这些类规定出需要实现的公共接口。那 些需要外蕴状态(External State)的操作可以通过方法的参数传入。抽象享元 的接口使得享元变得可能，但是并不强制子类实行共享，因此并非所有的享元对象都是可以共享的。
      具体享元(ConreteFlyweight)角色：实现抽象享元角色所规定的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享。有时候具体享元角色又叫做单纯具体享角色，因为复合享元角色是由单纯具体享元角色通过复合而成。
      复合享元(UnsharableFlyweight)角色：复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个本身是单纯享对象的组合。复合享元角色又称做不可共享的享元对象。
      享元工厂(FlyweightFactory)角色：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象请求一个享元对象的时候，享元工厂角色需要检查系统中是否已经有一个符合要求的享元对象，如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个新的合适的享元对象。
      客户端(Client)角色：本角色还需要自行存储所有享元外蕴状态。
  
2, 模式说明
  
      享元模式以共享的方式高效地支持大量的细粒度对象。享元对象能做到共享的关键是区分内蕴状态(InternalState)和外蕴状态(External State)。
      一个内蕴状态是存储在享元对象内部的，并且是不会随环境改变而有所不同的。国此一个享元可以具有内蕴状态并可以共享。
      一个外蕴状态是随环境改变而改变的、不可以共享的状态。享元对象的外蕴状态必须由客户端保存，并在享元对象被创建后，在需要使用的时候再传入到享元对象内部。
      外蕴状态不可以影响享元对象的内蕴状态。换句话说，它们是相互独立的。

   
3，模式示例代码[size=large][/size]
   
   单纯享元模式：

      

          package com.maohao.struct.flyweight;

          public abstract class Flyweight {

	    //参数state是外蕴状态
	    abstract public void operation(String state);
          }
       

      

          package com.maohao.struct.flyweight;

          public class ConcreteFlyweight extends Flyweight {

	  private Character intrinsicState = null;
	
	  /**
	    * 构造子，内蕴状态作为参量传入
	  */
	  public ConcreteFlyweight(Character state) {
		
		this.intrinsicState = state;
	  }
	
	/**
	 * 外蕴状态作为参量传入方法中，改变方法的行为
	 * 但是并不发育对象的内蕴状态
	 */
	  @Override
	  public void operation(String state) {

	   	 System.out.println("...");
	  }

        }
       

      

          package com.maohao.struct.flyweight;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class FlyweightFactory {

    private HashMap flies = new HashMap();
    private Flyweight lnkFlyweight;
    
    /**
     * 默认构造子
     */
    public FlyweightFactory(){}
    
    /**
     * 构造子，内蕴状态作为参量传入
     */
    public Flyweight factory(Character state) {
    	
    	if(flies.containsKey(state)) {
    		return (Flyweight)flies.get(state);
    	} else {
    		Flyweight fly = new ConcreteFlyweight(state);
    		flies.put(state, fly);
    		return fly;
    	}
    }
    
    /**
     * 辅助方法
     */
    public void checkFlyweight() {
    	
    	Flyweight fly;
    	int i = 0;
    	for(Iterator it = flies.entrySet().iterator(); it.hasNext() ;) {
    		
    		Map.Entry e = (Map.Entry)it.next();
    		System.out.println("Item" + (++i) + ":" + e.getKey());
    	}
    }
}
       

   复合享元模式：
      

package com.maohao.struct.flyweight;

public abstract class Flyweight2 {

	//参数state是外蕴状态
	abstract public void operation(String state);
}
       

  package com.maohao.struct.flyweight;

public class ConcreteFlyweight2 extends Flyweight2 {

	private Character intrinsicState = null;
	
	/**
	 * 构造子，内蕴状态作为参量传入
	 */
	public ConcreteFlyweight2(Character state) {
		
		this.intrinsicState = state;
	}
	
	/**
	 * 外蕴状态作为参量传入方法中，改变方法的行为
	 * 但是并不发育对象的内蕴状态
	 */
	@Override
	public void operation(String state) {

		System.out.println("...");
	}

}

package com.maohao.struct.flyweight;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class ConcreteCompositeFlyweight extends Flyweight2 {

	private HashMap flies = new HashMap(10);
	private Flyweight2 flyweight;
	
	/**
	 * 默认构造子
	 */
	public ConcreteCompositeFlyweight() {}
	
	/**
	 * 增加一个新的单纯享元对象到聚集中
	 */
	public void add(Character key, Flyweight2 fly) {
		flies.put(key, fly);
	}
	
	/**
	 * 外蕴状态作为参量传入到方法中
	 */
	@Override
	public void operation(String state) {

		Flyweight2 fly = null;
		for(Iterator it = flies.entrySet().iterator(); it.hasNext(); ) {
			Map.Entry e = (Map.Entry)it.next();
			fly = (Flyweight2)e.getValue();
			fly.operation(state);
		}
	}

}

package com.maohao.struct.flyweight;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class FlyweightFactory2 {

    private HashMap flies = new HashMap();
    
    /**
     * 默认构造子
     */
    public FlyweightFactory2(){}
    
    public Flyweight2 factory(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 Flyweight2 factory(Character state) {
    	
    	if(flies.containsKey(state)) {
    		return (Flyweight2)flies.get(state);
    	} else {
    		Flyweight2 fly = new ConcreteFlyweight2(state);
    		flies.put(state, fly);
    		return fly;
    	}
    }
    
    /**
     * 辅助方法
     */
    public void checkFlyweight() {
    	
    	Flyweight fly;
    	int i = 0;
    	for(Iterator it = flies.entrySet().iterator(); it.hasNext() ;) {
    		
    		Map.Entry e = (Map.Entry)it.next();
    		System.out.println("Item" + (++i) + ":" + e.getKey());
    	}
    }
}

4。模式优缺点

   优点：大幅度地降低内存中对象的数量。
   缺点：享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。

5。模式何时使用

  （1）一个系统有大量的对象
  （2）这些对象耗费大量的内存
  （3）这些对象的状态中的大部分都可以外部化
  （4）这些对象可以按照内蕴状态分成很多的组，当把外蕴对象从对象中剔除时，每一个组都可以仅用一个对象代替
  （5）软件系统不依赖于这些对象的身份，换言之，这些对象可以是不可分辨的。
   使用享元模式需要维护一个记录了系统已有的所有享元的表，而这需要耗费资源。因此，应当在有足够多的享元实例可供共享时才值得使用享元模式。

6，与其他模式比较
     
   与单例模式：享元模式中的享元对象常常与单例模式中的单例对象混淆。享元模式中的单纯享元对象相对于每一个内蕴状态而言是惟一的，但是它们不是单例对象。一个单例类是不能直接实例化的，而单纯享元对象是可以直接实例化的。

   与工厂方法模式：享元工厂角色是一个特殊的工厂方法模式，特殊之处在于这个工厂维护一个所创建过的产品对象的记录，并根据这个记录和产品对象的内部状态循环使用这些产品对象。

   与代理模式：在代理模式里面，为了避免加载大量的耗费资源的对象，可以使用一些轻量级的代理对象，只在系统真正使用到原始对象时才真正加载它们。享元模式不是这样。在一个使用享元模式的系统里可能看上去有很多的享元对象，好像都是独立的拷贝，但是它其实是被多个客户端共享的单一实例。

   与合成模式：严格地讲，享元模式并不是一个单纯的模式，而是一个由数个模式组合而成的复合模式。如前所述，享元模式的工厂角色是一个工厂方法模式，只是工厂的内部记录了所创建的产品实例，并选择使用这些实例。享元对象是合成模式的应用，抽象 享元角色就是复合构件角色，而具体享元角色就是具体构件角色。复合享元是树枝构件，而单纯享元是树叶构件。

7，模式应用
   
    String类使用了享元模式。String对象是不变对象，一旦创建出来就不能改变。如果需要改变一个字符串的值，就只好创建一个新的String对象。在JVM内部，String对象都是共享的。如果一个系统中有两个String对象所包含的字符串相同的话，JVM实际上只创建一个String对象提供给两个引用，从而实现String对象的共享。STring的intern()方法给出这个字符串在共享池中的惟一实例。