设计模式 （十三）享元模式(Flyweight)

享元模式(Flyweight)就是把部分和整体的关系用树形结构来表示，从而使客户端能够把一个个的部分对象和有他们组合起来的整体对象采用同样的方式看待，他也是一个继承的替代，其实具体的说，享元模式就是用时间交换了空间。用程序的运行速度来读取是否重复的对象内容，然后不创建一个重复的对象来节省空间，于此同时就大大提高了程序的运行效率。

下面就简单的原理图：

然后通过一个字符的库创建简单的理解了一下享元模式，我们要创建一个字符库，这样就避免不了一些字符使我们想重复用的，这样如果我们每次用都重新的创建一个对象，然后分配空间，那么对于好多重复的字符会明显的浪费空间，这个时候就引入了享元模式。

首先创建一个字符的接口，定义了一个负责拿到所在实例中的字符的方法getName();如下：

[java]  view plain copy

1. package coml.designpattern.flyweight;  
2.   
3. public interface Characters {  
4.     public String getName();  
5. }  

紧接着定义了一个公用的子类实现了这个接口，书中是做了N个子类实现，这里我就用了一个子类，并在Flyweight种也有区别，个人觉得这样减少了代码的复用：

[java]  view plain copy

1. package coml.designpattern.flyweight;  
2.   
3. public class Character implements Characters {  
4.   
5.     private String name;  
6.   
7.     public Character(String name) {  
8.         this.name = name;  
9.     }  
10.   
11.     @Override  
12.     public String getName() {  
13.         // TODO Auto-generated method stub  
14.         return this.name;  
15.     }  
16.   
17. }  

然后在Flyweight中定义创建字符的具体的方法和相关的逻辑：

[java]  view plain copy

1. package coml.designpattern.flyweight;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. public class Flyweight {  
7.     private List list = new ArrayList();  
8.   
9.     public Characters getCharacter(String name) {  
10.         Characters characters = null;  
11.   
12.         for (int i = 0; i < list.size(); i++) {  
13.             characters = (Characters) list.get(i);  
14.             if (name.equals(characters.getName())) {  
15.                 System.out.println(name + "不是第一次使用，未分配空间");  
16.                 break;  
17.             } else {  
18.                 characters = null;  
19.             }  
20.         }  
21.   
22.         if (characters == null) {  
23.             characters = new Character(name);  
24.             System.out.println(name + "第一次使用，并分配空间");  
25.             list.add(characters);  
26.         }  
27.   
28.         return characters;  
29.     }  
30. }  

定义了一个list，每次有新对象的时候就放进去，然后每次调用GetCharacter时候都会去遍历整个list想要的对象有没有创建好，如果有就不再创建，如果没有在创建，书中这里是用了N个Characters的实现类，在if语句块里面定义了N中情况，每一个字符就是一个对象，我这里就一个实现类，然后用不同的引用而已， 其实效果是一样的，然后客户端的调用：

[java]  view plain copy

1. package coml.designpattern.flyweight;  
2.   
3. public class Client {  
4.     public static void main(String[] args) {  
5.         Flyweight flyweight = new Flyweight();  
6.         Characters study1 = flyweight.getCharacter("study");  
7.         Characters pattern = flyweight.getCharacter("pattern");  
8.         Characters study2 = flyweight.getCharacter("study");  
9.         Characters java = flyweight.getCharacter("java");  
10.         Characters study3 = flyweight.getCharacter("study");  
11.         Characters js = flyweight.getCharacter("js");  
12.   
13.         System.out.println(study1.getName() + "\t" + java.getName() + "\t"  
14.                 + study2.getName() + "\t" + pattern.getName() + "\t"  
15.                 + study3.getName() + "\t" + js.getName() + "\t");  
16.     }  
17. }  

输出结果：

[html]  view plain copy

1. study第一次使用，并分配空间  
2. pattern第一次使用，并分配空间  
3. study不是第一次使用，未分配空间  
4. java第一次使用，并分配空间  
5. study不是第一次使用，未分配空间  
6. js第一次使用，并分配空间  
7. study   java    study   pattern study   js    

这样发现study虽然使用了三次但是他只创建了一次，如果使用N次，那么会很明显的减少了空间的使用；

在数据库连接池就是实际中的应用，先创建好一个池，每次有人要取得数据不会再像JDBC一样创建一个新的连接，这样减少了服务器端的压力，提高了项目的性能；

使用享元模式可以大大节省空间，但是需要维护所有的享元对象，如果 要维护的享元很多，在查找的时候要消耗大量的时间，因此享元模式是典型的以时间来交换空间。