享元模式（Flyweight）

[b] 享元模式（Flyweight）[/b]

近期看了一下享元模式，下面就针对享元模式简单整理一下个人的理解：

享元模式的核心思想-“共享”。何时使用享元模式。Java中的应用-数据库连接池。
享元的英文是Flyweight，它是一个来自于体育方面的专业用语，在拳击、摔跤和举重比赛中特指最轻量的级别。把这个单词移植到软件工程里面，也是用来表示特别小的对象，即细粒度对象。Flyweight享元，可以理解为共享元对象，也就是共享细粒度对象。享元模式就是通过使用共享的方式，达到高效地支持大量的细粒度对象。它的目的就是节省占用的空间资源，从而实现系统性能得到改善。

享元模式主要作用是实现对象的共享，即使用共享池，从而减少内存分配的开销。享元模式通常与工厂模式一起使用，它包含了多个共享的组合对象，因此：享元模式=单例模式+工厂模式+合成模式，其结构如图所示。


其中：FlyweightFactoiy享元工厂负责创建和管理享元对象，它必须保证享元对象可以被系统适当共享。当一个客户端对象请求一个享元对象的时候，享元工厂需要检查系统中是否已经有一个符合要求的享元对象，如果已经有了，享元工厂就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂就应当创建一个新的合适的享元对象。Flyweight是所有的具体享元类的超类，为这些类规定出需要实现的公共接口或抽象类。MyFlyweight1和MyFlyweight2则是实现抽象享元所规定的接口。

下面通过一个简单的例子来说明下：

1、先定义一个抽象的Flyweight类：

public abstract class Flyweight{

    public abstract void operation();

}

2、在实现一个具体类：

public class ConcreteFlyweight extends Flyweight{
    private String string;

    public ConcreteFlyweight(String str){
        string = str;
    }

    public void operation(){
        System.out.println("Concrete---Flyweight : " + string);
    }

}

3、实现一个工厂方法类：

/**
 * 实现一个工厂方法类：
 * 这个工厂方法类非常关键，这里增加注释：
 * @author Administrator
 */
public class FlyweightFactory {

	Hashtable flyweights = new Hashtable();				//在此处定义了一个Hashtable用来存储各个对象

	public Flyweight getFlyweight(Object obj){
		Flyweight flyweight = (Flyweight) flyweights.get(obj);	//选出要实例化的对象
		if(flyweight == null){									//如果在Hashtable中没有要选择的对象，此时变量flyweight为null
			flyweight = new ConcreteFlyweight(obj.toString());		
			flyweights.put(obj, flyweight);					//产生一个新的flyweight对象存储在Hashtable中，并将该对象返回
		}
		return flyweight;					//将该对象返回
	}
	public int getFlyweightSize(){
		return flyweights.size();
	}

}

4、最后看看Client的调用:

public class Client {
	//实例化工厂
	static FlyweightFactory factory = new FlyweightFactory(); 
	static Flyweight fly1;
	static Flyweight fly2;
	static Flyweight fly3;
	static Flyweight fly4;
	static Flyweight fly5;
	static Flyweight fly6;

	 //构造方法实例变量
    public Client(){
        fly1 = factory.getFlyweight("Google");
        fly2 = factory.getFlyweight("Qutr");
        fly3 = factory.getFlyweight("Google");
        fly4 = factory.getFlyweight("Google");
        fly5 = factory.getFlyweight("baidu");
        fly6 = factory.getFlyweight("Google");
    }
    //打印显示信息
    public void showFlyweight(){
        fly1.operation();
        fly2.operation();
        fly3.operation();
        fly4.operation();
        fly5.operation();
        fly6.operation();
        int objSize = factory.getFlyweightSize();
        System.out.println("objSize = " + objSize);
    }

    public static void main(String[] args){
        System.out.println("The FlyWeight Pattern!");
        Client c = new Client();
        c.showFlyweight();
    }
}

打印结果：
The FlyWeight Pattern!
Concrete---Flyweight : Google
Concrete---Flyweight : Qutr
Concrete---Flyweight : Google
Concrete---Flyweight : Google
Concrete---Flyweight : baidu
Concrete---Flyweight : Google
objSize = 3

我们定义了6个对象，其中有4个是相同的，按照Flyweight模式的定义“Google”应该共享一个对象，在实际的对象数中我们可以看出实际的对象却是只有3个。

[img]http://dl.iteye.com/upload/attachment/221563/9fd51d6a-aaa2-3ec5-90ad-54f6ae6e552b.jpg[/img]

总结：
Flyweight(享元)模式是如此的重要，因为它能帮你在一个复杂的系统中大量的节省内存空间。在GOF的书中举了文本处理的例子，我觉得非常恰当。也就是说在一个系统中如果有多个相同的对象，那么只共享一份就可以了，不必每个都去实例化一个对象。比如说（这里引用GOF书中的例子）一个文本系统，每个字母定一个对象，那么大小写字母一共就是52个，那么就要定义52个对象。如果有一个1M的文本，那么字母是何其的多，如果每个字母都定义一个对象那么内存早就爆了。那么如果要是每个字母都共享一个对象，那么就大大节约了资源。