亨元模式——池技术

博客分类： 

设计模式之禅——亨元模式

 

一、亨元模式的定义

       亨元模式是池技术的重要实现方式；我理解的就是，在使用一个对象时，如果这个对象在内存中有，就从内存中取出使用，如果没有，就新建一个这个对象，然后存到内存中去。这样能够使用共享对象，能够有效的支持大量的细颗粒对象。

       亨元模式有两个要求：细颗粒的对象和共享对象。我们知道分配太多的对象到应用程序中将有损程序的性能，同时还容易造成内存溢出，这时就应该使用亨元模式了。最适合在缓冲池的场景了。

       其实数据库连接池等，都是一种亨元模式，在JDK中也有亨元模式，比如String类的intern()方法（最后为给出这个方法的示例）

 

二、亨元模式示例代码：

首先是抽象的亨元角色：

伦理片 http://www.dotdy.com/

Java代码  

1. package com.wang.flyweightPattern;  
2.   
3. /** 
4.  * 抽象亨元角色 
5.  *  
6.  * @author wang 
7.  *  
8.  */  
9. public abstract class Flyweight {  
10.   
11.     /* 
12.      * 内部状态 
13.      */  
14.     private String intrinsic;  
15.   
16.     /* 
17.      * 外部状态 
18.      */  
19.     protected final String extrinsic;  
20.   
21.     /** 
22.      * 要求亨元角色必须接受外部状态 
23.      *  
24.      * @param extrinsic 
25.      *            外部状态 
26.      */  
27.     public Flyweight(String extrinsic) {  
28.         this.extrinsic = extrinsic;  
29.     }  
30.   
31.     /** 
32.      * 定义业务操作 
33.      */  
34.     public abstract void operate();  
35.   
36.     public String getIntrinsic() {  
37.         return intrinsic;  
38.     }  
39.   
40.     public void setIntrinsic(String intrinsic) {  
41.         this.intrinsic = intrinsic;  
42.     }  
43.   
44. }  

 具体的亨元角色，可以有多个，都是继承自抽象亨元角色：

Java代码  

1. package com.wang.flyweightPattern;  
2.   
3. /** 
4.  * 具体亨元角色 
5.  *  
6.  * @author wang 
7.  *  
8.  */  
9. public class ConcreteFlyweight1 extends Flyweight {  
10.   
11.     public ConcreteFlyweight1(String extrinsic) {  
12.         super(extrinsic);  
13.     }  
14.   
15.     @Override  
16.     public void operate() {  
17.         System.out.println("ConcreteFlyweight1 ... operate...");  
18.     }  
19.   
20. }  

 最后就是亨元的工厂：

Java代码  

1. package com.wang.flyweightPattern;  
2.   
3. import java.util.HashMap;  
4.   
5. /** 
6.  * 亨元工厂 
7.  *  
8.  * @author wang 
9.  *  
10.  */  
11. public class FlyweightFactory {  
12.   
13.     /* 
14.      * 定义一个容量池 
15.      */  
16.     private static HashMap<String, Flyweight> pool = new HashMap<String, Flyweight>();  
17.   
18.     public static Flyweight getFlyweight(String extrinsic) {  
19.           
20.         // 需要返回的对象  
21.         Flyweight flyweight = null;  
22.         /* 
23.          * 如果池中有该对象，从池中取； 
24.          * 如果池中没有该对象，创建一个对象，并放到池中。 
25.          */  
26.         if( pool.containsKey(extrinsic) ){  
27.             flyweight = pool.get(extrinsic);  
28.         } else {  
29.             flyweight = new ConcreteFlyweight1(extrinsic);  
30.             pool.put(extrinsic, flyweight);  
31.         }  
32.         return flyweight;  
33.     }  
34. }  

 当我们看到最后的亨元工厂后，会不会感觉很熟悉，“着我用过啊”，对，亨元模式很常用，这就是亨元模式。

三、最后我们看看JDK中的亨元模式的一个小例子：

影音先锋电影 http://www.iskdy .com/

Java代码  

1. package com.wang.flyweightPattern.example;  
2.   
3. /** 
4.  * String类中的亨元模式 
5.  *  
6.  * @author wang 
7.  * 
8.  */  
9. public class StringIntern {  
10.   
11.     public static void main(String[] args) {  
12.   
13.         String str1 = "和谐";  
14.         String str2 = "社会";  
15.         String str3 = "和谐社会";  
16.         String str4;  
17.         str4 = str1 + str2;  
18.         System.out.println(str3 == str4);  
19.         /* 
20.          * String类中的intern()方法， 
21.          * 如果是String的对象池中有该类型的值， 
22.          * 则直接返回对象池中的对象 
23.          */  
24.         str4 = (str1 + str2).intern();  
25.         System.out.println(str3 == str4);  
26.     }  
27. }