java享元模式

讲解1

享元模式：“享”就是分享之意，指一物被众人共享，而这也正是该模式的终旨所在。

　　享元模式有点类似于单例模式，都是只生成一个对象来被共享使用。这里有个问题，那就是对共享对象的修改，为了避免出现这种情况，我们将这些对象的公共部分，或者说是不变化的部分抽取出来形成一个对象。这个对象就可以避免到修改的问题。

　　享元的目的是为了减少不会要额内存消耗，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗。

　　下面我们来看一个简单的例子：

建筑接口：JianZhu

1 public interface Jianzhu {
2     void use();
3 }

体育馆实现类：TiYuGuan

 1 public class TiYuGuan implements Jianzhu {
 2     private String name;
 3     private String shape;
 4     private String yundong;
 5     public TiYuGuan(String yundong){
 6         this.setYundong(yundong);
 7     }
 8     public String getName() {
 9         return name;
10     }
11     public void setName(String name) {
12         this.name = name;
13     }
14     public String getShape() {
15         return shape;
16     }
17     public void setShape(String shape) {
18         this.shape = shape;
19     }
20     public String getYundong() {
21         return yundong;
22     }
23     public void setYundong(String yundong) {
24         this.yundong = yundong;
25     }
26     @Override
27     public void use() {
28         System.out.println("该体育馆被使用来召开奥运会" + "  运动为："+ yundong+"  形状为："+shape+ "  名称为："+name);
29     }
30 }

建筑工厂类：JianZhuFactory

 1 import java.util.*;
 2 
 3 public class JianZhuFactory {
 4     private static final Map<String,TiYuGuan> tygs = new HashMap<String,TiYuGuan>();
 5     public static TiYuGuan getTyg(String yundong){
 6         TiYuGuan tyg = tygs.get(yundong);
 7         if(tyg == null){
 8             tyg = new TiYuGuan(yundong);
 9             tygs.put(yundong,tyg);
10         }
11         return tyg;
12     }
13     public static int getSize(){
14         return tygs.size();
15     }
16 }

测试类：Clienter

 1 public class Clienter {
 2     public static void main(String[] args) {
 3         String yundong ="足球";
 4         for(int i = 1;i <= 5;i++){
 5             TiYuGuan tyg = JianZhuFactory.getTyg(yundong);
 6             tyg.setName("中国体育馆");
 7             tyg.setShape("圆形");
 8             tyg.use();
 9             System.out.println("对象池中对象数量为："+JianZhuFactory.getSize());
10         }
11     }
12 }

执行结果：

该体育馆被使用来召开奥运会  运动为：足球  形状为：圆形  名称为：中国体育馆
对象池中对象数量为：1
该体育馆被使用来召开奥运会  运动为：足球  形状为：圆形  名称为：中国体育馆
对象池中对象数量为：1
该体育馆被使用来召开奥运会  运动为：足球  形状为：圆形  名称为：中国体育馆
对象池中对象数量为：1
该体育馆被使用来召开奥运会  运动为：足球  形状为：圆形  名称为：中国体育馆
对象池中对象数量为：1
该体育馆被使用来召开奥运会  运动为：足球  形状为：圆形  名称为：中国体育馆
对象池中对象数量为：1

　　如上示例中，使用工厂模式进行配合，创建对象池，测试类中的循环，你可以想象成为要举行5场比赛，每场比赛的场地就是体育馆

　　通过执行结果可以看出，在这个对象池（HashMap）中，一直都只有一个对象存在，第一次使用的时候创建对象，之后的每次调用都用的是那个对象，不会再重新创建。

　　其实在Java中就存在这种类型的实例：String。

　　Java中将String类定义为final（不可改变的），JVM中字符串一般保存在字符串常量池中，这个字符串常量池在jdk 6.0以前是位于常量池中，位于永久代，而在JDK 7.0中，JVM将其从永久代拿出来放置于堆中。

　　我们使用如下代码定义的两个字符串指向的其实是同一个字符串常量池中的字符串值。

1 String s1 = "abc";
2 String s2 = "abc";

　　如果我们以s1==s2进行比较的话所得结果为：true，因为s1和s2保存的是字符串常量池中的同一个字符串地址。这就类似于我们今天所讲述的享元模式，字符串一旦定义之后就可以被共享使用，因为他们是不可改变的，同时被多处调用也不会存在任何隐患。

　　享元模式使用的场景：

　　　　当我们项目中创建很多对象，而且这些对象存在许多相同模块，这时，我们可以将这些相同的模块提取出来采用享元模式生成单一对象，再使用这个对象与之前的诸多对象进行配合使用，这样无疑会节省很多空间。

 

 

讲解2

 

享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。

 

 

FlyWeightFactory负责创建和管理享元单元，当一个客户端请求时，工厂需要检查当前对象池中是否有符合条件的对象，如果有，就返回已经存在的对象，如果没有，则创建一个新对象，FlyWeight是超类。一提到共享池，我们很容易联想到Java里面的JDBC连接池，想想每个连接的特点，我们不难总结出：适用于作共享的一些个对象，他们有一些共有的属性，就拿数据库连接池来说，url、driverClassName、username、password及dbname，这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理，建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据，在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。

 

看个例子：

 

 

看下数据库连接池的代码：

 

[java] view plaincopy

1. public class ConnectionPool {  
2.       
3.     private Vector<Connection> pool;  
4.       
5.     /*公有属性*/  
6.     private String url = "jdbc:mysql://localhost:3306/test";  
7.     private String username = "root";  
8.     private String password = "root";  
9.     private String driverClassName = "com.mysql.jdbc.Driver";  
10.   
11.     private int poolSize = 100;  
12.     private static ConnectionPool instance = null;  
13.     Connection conn = null;  
14.   
15.     /*构造方法，做一些初始化工作*/  
16.     private ConnectionPool() {  
17.         pool = new Vector<Connection>(poolSize);  
18.   
19.         for (int i = 0; i < poolSize; i++) {  
20.             try {  
21.                 Class.forName(driverClassName);  
22.                 conn = DriverManager.getConnection(url, username, password);  
23.                 pool.add(conn);  
24.             } catch (ClassNotFoundException e) {  
25.                 e.printStackTrace();  
26.             } catch (SQLException e) {  
27.                 e.printStackTrace();  
28.             }  
29.         }  
30.     }  
31.   
32.     /* 返回连接到连接池 */  
33.     public synchronized void release() {  
34.         pool.add(conn);  
35.     }  
36.   
37.     /* 返回连接池中的一个数据库连接 */  
38.     public synchronized Connection getConnection() {  
39.         if (pool.size() > 0) {  
40.             Connection conn = pool.get(0);  
41.             pool.remove(conn);  
42.             return conn;  
43.         } else {  
44.             return null;  
45.         }  
46.     }  
47. }  

 

 

 

通过连接池的管理，实现了数据库连接的共享，不需要每一次都重新创建连接，节省了数据库重新创建的开销，提升了系统的性能！