享元模式

　　Flyweight在拳击比赛中指最轻量级，即“蝇量级”或“雨量级”，这里选择使用“享元模式”的意译，是因为这样更能反映模式的用意。享元模式是对象的结构模式。享元模式以共享的方式高效地支持大量的细粒度对象。

---

Java中的String类型

　　在JAVA语言中，String类型就是使用了享元模式。String对象是final类型，对象一旦创建就不可改变。在JAVA中字符串常量都是存在常量池中的，JAVA会确保一个字符串常量在常量池中只有一个拷贝。String a="abc"，其中"abc"就是一个字符串常量。

[java]  view plain copy print ?

1. public class Test {  
2.   
3.     public static void main(String[] args) {  
4.           
5.         String a = "abc";  
6.         String b = "abc";  
7.         System.out.println(a==b);  
8.           
9.     }  
10. }  

　上面的例子中结果为：true ，这就说明a和b两个引用都指向了常量池中的同一个字符串常量"abc"。这样的设计避免了在创建N多相同对象时所产生的不必要的大量的资源消耗。

 

享元模式的结构

　　享元模式采用一个共享来避免大量拥有相同内容对象的开销。这种开销最常见、最直观的就是内存的损耗。享元对象能做到共享的关键是区分内蕴状态(Internal State)和外蕴状态(External State)。

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

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

　　享元模式可以分成单纯享元模式和复合享元模式两种形式。

单纯享元模式　　

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

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

　　●　　抽象享元(Flyweight)角色 ：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。

　　●　　具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。

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

源代码

　　抽象享元角色类

[java]  view plain copy print ?

1. package com.bankht.Flyweight;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-26 上午11:43:03 
6.  *  
7.  * @类说明 ：抽象享元角色类 
8.  */  
9. public interface Flyweight {  
10.     // 一个示意性方法，参数state是外蕴状态  
11.     public void operation(String state);  
12. }  

 

　　具体享元角色类ConcreteFlyweight有一个内蕴状态，在本例中一个Character类型的intrinsicState属性代表，它的值应当在享元对象被创建时赋予。所有的内蕴状态在对象创建之后，就不会再改变了。

　　如果一个享元对象有外蕴状态的话，所有的外部状态都必须存储在客户端，在使用享元对象时，再由客户端传入享元对象。这里只有一个外蕴状态，operation()方法的参数state就是由外部传入的外蕴状态。

[java]  view plain copy print ?

1. package com.bankht.Flyweight;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-26 上午11:43:26 
6.  *  
7.  * @类说明 ： 
8.  */  
9. public class ConcreteFlyweight implements Flyweight {  
10.     private Character intrinsicState = null;  
11.   
12.     /** 
13.      * 构造函数，内蕴状态作为参数传入 
14.      *  
15.      * @param state 
16.      */  
17.     public ConcreteFlyweight(Character state) {  
18.         this.intrinsicState = state;  
19.     }  
20.   
21.     /** 
22.      * 外蕴状态作为参数传入方法中，改变方法的行为， 但是并不改变对象的内蕴状态。 
23.      */  
24.     @Override  
25.     public void operation(String state) {  
26.         System.out.println("Intrinsic State = " + this.intrinsicState);  
27.         System.out.println("Extrinsic State = " + state);  
28.     }  
29.   
30. }  

 

　　享元工厂角色类，必须指出的是，客户端不可以直接将具体享元类实例化，而必须通过一个工厂对象，利用一个factory()方法得到享元对象。一般而言，享元工厂对象在整个系统中只有一个，因此也可以使用单例模式。

　　当客户端需要单纯享元对象的时候，需要调用享元工厂的factory()方法，并传入所需的单纯享元对象的内蕴状态，由工厂方法产生所需要的享元对象。

[java]  view plain copy print ?

1. package com.bankht.Flyweight;  
2.   
3. import java.util.HashMap;  
4. import java.util.Map;  
5.   
6. /** 
7.  * @author: 特种兵—AK47 
8.  * @创建时间：2012-6-26 上午11:43:52 
9.  *  
10.  * @类说明 ： 
11.  */  
12. public class FlyweightFactory {  
13.     private Map<Character, Flyweight> files = new HashMap<Character, Flyweight>();  
14.   
15.     public Flyweight factory(Character state) {  
16.         // 先从缓存中查找对象  
17.         Flyweight fly = files.get(state);  
18.         if (fly == null) {  
19.             // 如果对象不存在则创建一个新的Flyweight对象  
20.             fly = new ConcreteFlyweight(state);  
21.             // 把这个新的Flyweight对象添加到缓存中  
22.             files.put(state, fly);  
23.         }else{  
24.             System.out.println(state+"--->>状态对应对象已经存在");  
25.         }  
26.         return fly;  
27.     }  
28. }  

 

　　客户端类

[java]  view plain copy print ?

1. package com.bankht.Flyweight;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-26 上午11:44:17 
6.  *  
7.  * @类说明 ：客户端类 
8.  */  
9. public class Client {  
10.   
11.     public static void main(String[] args) {  
12.   
13.         FlyweightFactory factory = new FlyweightFactory();  
14.         Flyweight fly = factory.factory(new Character('a'));  
15.         fly.operation("First Call");  
16.   
17.         fly = factory.factory(new Character('b'));  
18.         fly.operation("Second Call");  
19.   
20.         fly = factory.factory(new Character('a'));  
21.         fly.operation("Third Call");  
22.     }  
23.   
24. }  

 

　　虽然客户端申请了三个享元对象，但是实际创建的享元对象只有两个，这就是共享的含义。运行结果如下：

[html]  view plain copy print ?

1. Intrinsic State = a  
2. Extrinsic State = First Call  
3. Intrinsic State = b  
4. Extrinsic State = Second Call  
5. a--->>状态对应对象已经存在  
6. Intrinsic State = a  
7. Extrinsic State = Third Call  

 

复合享元模式

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

　复合享元角色所涉及到的角色如下：

　　●　　抽象享元(Flyweight)角色 ：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。

　　●　　具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。

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

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

源代码

　　抽象享元角色类

[java]  view plain copy print ?

1. package com.bankht.Flyweight.complex;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-26 下午02:16:25 
6.  *  
7.  * @类说明 ：抽象享元角色类 
8.  */  
9. public interface Flyweight {  
10.     // 一个示意性方法，参数state是外蕴状态  
11.     public void operation(String state);  
12. }  

 

　　具体享元角色类

[java]  view plain copy print ?

1. package com.bankht.Flyweight.complex;  
2.   
3. /** 
4.  * @author: 特种兵—AK47 
5.  * @创建时间：2012-6-26 下午02:16:50 
6.  *  
7.  * @类说明 ：具体享元角色类 
8.  */  
9. public class ConcreteFlyweight implements Flyweight {  
10.     private Character intrinsicState = null;  
11.   
12.     /** 
13.      * 构造函数，内蕴状态作为参数传入 
14.      *  
15.      * @param state 
16.      */  
17.     public ConcreteFlyweight(Character state) {  
18.         this.intrinsicState = state;  
19.     }  
20.   
21.     /** 
22.      * 外蕴状态作为参数传入方法中，改变方法的行为， 但是并不改变对象的内蕴状态。 
23.      */  
24.     @Override  
25.     public void operation(String state) {  
26.         // TODO Auto-generated method stub  
27.         System.out.println("Intrinsic State = " + this.intrinsicState);  
28.         System.out.println("Extrinsic State = " + state);  
29.     }  
30.   
31. }  

 

　　复合享元对象是由单纯享元对象通过复合而成的，因此它提供了add()这样的聚集管理方法。由于一个复合享元对象具有不同的聚集元素，这些聚集元素在复合享元对象被创建之后加入，这本身就意味着复合享元对象的状态是会改变的，因此复合享元对象是不能共享的。

　　复合享元角色实现了抽象享元角色所规定的接口，也就是operation()方法，这个方法有一个参数，代表复合享元对象的外蕴状态。一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的；而一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不相等的，不然就没有使用价值了。

[java]  view plain copy print ?

1. package com.bankht.Flyweight.complex;  
2.   
3. import java.util.HashMap;  
4. import java.util.Map;  
5.   
6. /** 
7.  * @author: 特种兵—AK47 
8.  * @创建时间：2012-6-26 下午02:17:16 
9.  *  
10.  * @类说明 ： 
11.  */  
12. public class ConcreteCompositeFlyweight implements Flyweight {  
13.   
14.     private Map<Character, Flyweight> files = new HashMap<Character, Flyweight>();  
15.   
16.     /** 
17.      * 增加一个新的单纯享元对象到聚集中 
18.      */  
19.     public void add(Character key, Flyweight fly) {  
20.         files.put(key, fly);  
21.     }  
22.   
23.     /** 
24.      * 外蕴状态作为参数传入到方法中 
25.      */  
26.     @Override  
27.     public void operation(String state) {  
28.         Flyweight fly = null;  
29.         for (Object o : files.keySet()) {  
30.             fly = files.get(o);  
31.             fly.operation(state);  
32.         }  
33.   
34.     }  
35.   
36. }  

 

　　享元工厂角色提供两种不同的方法，一种用于提供单纯享元对象，另一种用于提供复合享元对象。

[java]  view plain copy print ?

1. package com.bankht.Flyweight.complex;  
2.   
3. import java.util.HashMap;  
4. import java.util.List;  
5. import java.util.Map;  
6.   
7. /** 
8.  * @author: 特种兵—AK47 
9.  * @创建时间：2012-6-26 下午02:17:42 
10.  *  
11.  * @类说明 ：享元工厂角色提供两种不同的方法，一种用于提供单纯享元对象，另一种用于提供复合享元对象。 
12.  */  
13. public class FlyweightFactory {  
14.     private Map<Character, Flyweight> files = new HashMap<Character, Flyweight>();  
15.   
16.     /** 
17.      * 复合享元工厂方法 
18.      */  
19.     public Flyweight factory(List<Character> compositeState) {  
20.         ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight();  
21.   
22.         for (Character state : compositeState) {  
23.             compositeFly.add(state, this.factory(state));  
24.         }  
25.   
26.         return compositeFly;  
27.     }  
28.   
29.     /** 
30.      * 单纯享元工厂方法 
31.      */  
32.     public Flyweight factory(Character state) {  
33.         // 先从缓存中查找对象  
34.         Flyweight fly = files.get(state);  
35.         if (fly == null) {  
36.             // 如果对象不存在则创建一个新的Flyweight对象  
37.             fly = new ConcreteFlyweight(state);  
38.             // 把这个新的Flyweight对象添加到缓存中  
39.             files.put(state, fly);  
40.         }  
41.         return fly;  
42.     }  
43. }  

 

　　客户端角色

[java]  view plain copy print ?

1. package com.bankht.Flyweight.complex;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. /** 
7.  * @author: 特种兵—AK47 
8.  * @创建时间：2012-6-26 下午02:18:11 
9.  *  
10.  * @类说明 ：客户端类 
11.  */  
12. public class Client {  
13.   
14.  public static void main(String[] args) {  
15.   List<Character> compositeState = new ArrayList<Character>();  
16.   compositeState.add('a');  
17.   compositeState.add('b');  
18.   compositeState.add('c');  
19.   compositeState.add('a');  
20.   compositeState.add('b');  
21.   
22.   FlyweightFactory flyFactory = new FlyweightFactory();  
23.   Flyweight compositeFly1 = flyFactory.factory(compositeState);  
24.   Flyweight compositeFly2 = flyFactory.factory(compositeState);  
25.   compositeFly1.operation("Composite Call");  
26.   
27.   System.out.println("---------------------------------");  
28.   System.out.println("复合享元模式是否可以共享对象：" + (compositeFly1 == compositeFly2));  
29.   
30.   Character state = 'a';  
31.   Flyweight fly1 = flyFactory.factory(state);  
32.   Flyweight fly2 = flyFactory.factory(state);  
33.   System.out.println("单纯享元模式是否可以共享对象：" + (fly1 == fly2));  
34.  }  
35. }  

 

运行结果如下：

 

[html]  view plain copy print ?

1. Intrinsic State = b  
2. Extrinsic State = Composite Call  
3. Intrinsic State = c  
4. Extrinsic State = Composite Call  
5. Intrinsic State = a  
6. Extrinsic State = Composite Call  
7. ---------------------------------  
8. 复合享元模式是否可以共享对象：false  
9. 单纯享元模式是否可以共享对象：true  

 

　　从运行结果可以看出，一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的。即外运状态都等于Composite Call。

　　从运行结果可以看出，一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不相等的。即内蕴状态分别为b、c、a。

　　从运行结果可以看出，复合享元对象是不能共享的。即使用相同的对象compositeState通过工厂分别两次创建出的对象不是同一个对象。

　　从运行结果可以看出，单纯享元对象是可以共享的。即使用相同的对象state通过工厂分别两次创建出的对象是同一个对象。

享元模式的优缺点

　　享元模式的优点在于它大幅度地降低内存中对象的数量。但是，它做到这一点所付出的代价也是很高的：

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

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

 

享元模式的实际应用

享元模式在一般的项目开发中并不常用，而是常常应用于系统底层的开发，以便解决系统的性能问题。

Java中的String类型就是使用了享元模式。

我们额外的谈一下PHP中String的处理。作为一种弱类型语言，PHP的字符串类型是一种基本类型，不是对象。另外，它的执行方式与Java有明显区别，每一个脚本文件执行开始，将会装入所有需要的资源；执行结束后，又将占用的资源就立即全部释放，所以它基本上不会产生类似的性能问题，它的字符串处理的设计，自然也使用不到享元模式。

温馨提示： 

 

       面向对象虽然很好地解决了抽象性的问题，但是对于一个实际运行的软件系统，我们还需要考虑面向对象的代价问题，享元模式解决的就是面向对象的代价问题。享元模式采用对象共享的做法来降低系统中对象的个数，从而降低细粒度对象给系统带来的内存压力。

在具体实现方面，我们要注意对象状态的处理，一定要正确地区分对象的内蕴状态和外蕴状态，这是实现享元模式的关键所在。

享元模式的优点在于它大幅度地降低内存中对象的数量。为了做到这一点，享元模式也付出了一定的代价：

1、享元模式为了使对象可以共享，它需要将部分状态外部化，这使得系统的逻辑变得复杂。

2、享元模式将享元对象的部分状态外部化，而读取外部状态使得运行时间会有所加长。

另外，还有一个比较令人关心的问题：到底系统需要满足什么样的条件才能使用享元模式。对于这个问题，总结出以下几点：

1、一个系统中存在着大量的细粒度对象；

2、这些细粒度对象耗费了大量的内存。

3、这些细粒度对象的状态中的大部分都可以外部化；

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

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

满足以上的这些条件的系统可以使用享元对象。最后，使用享元模式需要维护一个记录了系统已有的所有享元的哈希表，也称之为对象池，而这也需要耗费一定的资源。因此，应当在有足够多的享元实例可供共享时才值得使用享元模式。