模式3.研磨设计模式之单例模式-1

单例模式（Singleton）

 

1  场景问题

1.1  读取配置文件的内容

        考虑这样一个应用，读取配置文件的内容。
        很多应用项目，都有与应用相关的配置文件，这些配置文件多是由项目开发人员自定义的，在里面定义一些应用需要的参数数据。当然在实际的项目中，这种配置文件多采用xml格式的。也有采用properties格式的，毕竟使用Java来读取properties格式的配置文件比较简单。
        现在要读取配置文件的内容，该如何实现呢？

1.2  不用模式的解决方案

        有些朋友会想，要读取配置文件的内容，这也不是个什么困难的事情，直接读取文件的内容，然后把文件内容存放在相应的数据对象里面就可以了。真的这么简单吗？先实现看看吧。
        为了示例简单，假设系统是采用的properties格式的配置文件。
（1）那么直接使用Java来读取配置文件，示例代码如下：

Java代码   

1. /** 
2.  * 读取应用配置文件 
3.  */  
4. public class AppConfig {  
5.     /** 
6.      * 用来存放配置文件中参数A的值 
7.      */  
8.     private String parameterA;  
9.     /** 
10.      * 用来存放配置文件中参数B的值 
11.      */  
12.     private String parameterB;    
13.   
14.     public String getParameterA() {  
15.         return parameterA;  
16.     }  
17.     public String getParameterB() {  
18.         return parameterB;  
19.     }  
20.     /** 
21.      * 构造方法 
22.      */  
23.     public AppConfig(){  
24.         //调用读取配置文件的方法  
25.         readConfig();  
26.     }  
27.     /** 
28.      * 读取配置文件，把配置文件中的内容读出来设置到属性上 
29.      */  
30.     private void readConfig(){  
31.         Properties p = new Properties();   
32.         InputStream in = null;  
33.         try {  
34.             in = AppConfig.class.getResourceAsStream(  
35. "AppConfig.properties");  
36.             p.load(in);  
37.             //把配置文件中的内容读出来设置到属性上  
38.             this.parameterA = p.getProperty("paramA");  
39.             this.parameterB = p.getProperty("paramB");  
40.         } catch (IOException e) {  
41.             System.out.println("装载配置文件出错了，具体堆栈信息如下：");  
42.             e.printStackTrace();  
43.         }finally{  
44.             try {  
45.                 in.close();  
46.             } catch (IOException e) {  
47.                 e.printStackTrace();  
48.             }  
49.         }  
50.     }  
51. }  

 

注意：只有访问参数的方法，没有设置参数的方法。

（2）应用的配置文件，名字是AppConfig.properties，放在AppConfig相同的包里面，简单示例如下：

Java代码   

1. paramA=a  
2. paramB=b  

 

（3）写个客户端来测试一下，示例代码如下：

Java代码   

1. public class Client {  
2.     public static void main(String[] args) {  
3.         //创建读取应用配置的对象  
4.         AppConfig config = new AppConfig();  
5.           
6.         String paramA = config.getParameterA();  
7.         String paramB = config.getParameterB();  
8.           
9.         System.out.println("paramA="+paramA+",paramB="+paramB);  
10.     }  
11. }  

 

运行结果如下：

Java代码   

1. paramA=a,paramB=b  

 

1.3  有何问题

        上面的实现很简单嘛，很容易的就实现了要求的功能。仔细想想，有没有什么问题呢？
        看看客户端使用这个类的地方，是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象。如果在系统运行中，有很多地方都需要使用配置文件的内容，也就是很多地方都需要创建AppConfig这个对象的实例。
        换句话说，在系统运行期间，系统中会存在很多个AppConfig的实例对象，这有什么问题吗？
        当然有问题了，试想一下，每一个AppConfig实例对象，里面都封装着配置文件的内容，系统中有多个AppConfig实例对象，也就是说系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。如果配置文件内容较少，问题还小一点，如果配置文件内容本来就多的话，对于系统资源的浪费问题就大了。事实上，对于AppConfig这种类，在运行期间，只需要一个实例对象就够了。
        把上面的描述进一步抽象一下，问题就出来了：在一个系统运行期间，某个类只需要一个类实例就可以了，那么应该怎么实现呢？

2  解决方案

2.1  单例模式来解决

        用来解决上述问题的一个合理的解决方案就是单例模式。那么什么是单例模式呢？
（1）单例模式定义
        保证一个类仅有一个实例，并提供一个访问它的全局访问点。
（2）应用单例模式来解决的思路
        仔细分析上面的问题，现在一个类能够被创建多个实例，问题的根源在于类的构造方法是公开的，也就是可以让类的外部来通过构造方法创建多个实例。换句话说，只要类的构造方法能让类的外部访问，就没有办法去控制外部来创建这个类的实例个数。
        要想控制一个类只被创建一个实例，那么首要的问题就是要把创建实例的权限收回来，让类自身来负责自己类实例的创建工作，然后由这个类来提供外部可以访问这个类实例的方法，这就是单例模式的实现方式。

2.2  模式结构和说明

单例模式结构见图1所：


 图1  单例模式结构图
Singleton：
        负责创建Singleton类自己的唯一实例，并提供一个getInstance的方法，让外部来访问这个类的唯一实例。

2.3  单例模式示例代码

        在Java中，单例模式的实现又分为两种，一种称为懒汉式，一种称为饿汉式，其实就是在具体创建对象实例的处理上，有不同的实现方式。下面分别来看这两种实现方式的代码示例。为何这么写，具体的在后面再讲述。
       （1）懒汉式实现，示例代码如下：

Java代码   

1. /** 
2.  * 懒汉式单例实现的示例 
3.  */  
4. public class Singleton {  
5.     /** 
6.      * 定义一个变量来存储创建好的类实例 
7.      */  
8.     private static Singleton uniqueInstance = null;  
9.     /** 
10.      * 私有化构造方法，好在内部控制创建实例的数目 
11.      */  
12.     private Singleton(){  
13.         //  
14.     }  
15.     /** 
16.      * 定义一个方法来为客户端提供类实例 
17.      * @return 一个Singleton的实例 
18.      */  
19.     public static synchronized Singleton getInstance(){  
20.         //判断存储实例的变量是否有值  
21.         if(uniqueInstance == null){  
22.             //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量  
23.             uniqueInstance = new Singleton();  
24.         }  
25.         //如果有值，那就直接使用  
26.         return uniqueInstance;  
27.     }  
28.     /** 
29.      * 示意方法，单例可以有自己的操作 
30.      */  
31.     public void singletonOperation(){  
32.         //功能处理  
33.     }  
34.     /** 
35.      * 示意属性，单例可以有自己的属性 
36.      */  
37.     private String singletonData;  
38.     /** 
39.      * 示意方法，让外部通过这些方法来访问属性的值 
40.      * @return 属性的值 
41.      */  
42.     public String getSingletonData(){  
43.         return singletonData;  
44.     }  
45. }  

 

 （2）饿汉式实现，示例代码如下：

Java代码   

1. /** 
2.  * 饿汉式单例实现的示例 
3.  */  
4. public class Singleton {  
5.     /** 
6.      * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次 
7.      */  
8.     private static Singleton uniqueInstance = new Singleton();  
9.     /** 
10.      * 私有化构造方法，好在内部控制创建实例的数目 
11.      */  
12.     private Singleton(){  
13.         //  
14.     }  
15.     /** 
16.      * 定义一个方法来为客户端提供类实例 
17.      * @return 一个Singleton的实例 
18.      */  
19.     public static Singleton getInstance(){  
20.         //直接使用已经创建好的实例  
21.         return uniqueInstance;  
22.     }  
23.       
24.     /** 
25.      * 示意方法，单例可以有自己的操作 
26.      */  
27.     public void singletonOperation(){  
28.         //功能处理  
29.     }  
30.     /** 
31.      * 示意属性，单例可以有自己的属性 
32.      */  
33.     private String singletonData;  
34.     /** 
35.      * 示意方法，让外部通过这些方法来访问属性的值 
36.      * @return 属性的值 
37.      */  
38.     public String getSingletonData(){  
39.         return singletonData;  
40.     }  
41. }  

 

 

2.4  使用单例模式重写示例

        要使用单例模式来重写示例，由于单例模式有两种实现方式，这里选一种来实现就好了，就选择饿汉式的实现方式来重写示例吧。
        采用饿汉式的实现方式来重写实例的示例代码如下：

Java代码   

1. /** 
2.  * 读取应用配置文件，单例实现 
3.  */  
4. public class AppConfig {  
5.     /** 
6.      * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次 
7.      */  
8.     private static AppConfig instance = new AppConfig();  
9.     /** 
10.      * 定义一个方法来为客户端提供AppConfig类的实例 
11.      * @return 一个AppConfig的实例 
12.      */  
13.     public static AppConfig getInstance(){  
14.         return instance;  
15.     }  
16.       
17.     /** 
18.      * 用来存放配置文件中参数A的值 
19.      */  
20.     private String parameterA;  
21.     /** 
22.      * 用来存放配置文件中参数B的值 
23.      */  
24.     private String parameterB;  
25.     public String getParameterA() {  
26.         return parameterA;  
27.     }  
28.     public String getParameterB() {  
29.         return parameterB;  
30.     }  
31.     /** 
32.      * 私有化构造方法 
33.      */  
34.     private AppConfig(){  
35.         //调用读取配置文件的方法  
36.         readConfig();  
37.     }  
38.     /** 
39.      * 读取配置文件，把配置文件中的内容读出来设置到属性上 
40.      */  
41.     private void readConfig(){  
42.         Properties p = new Properties();   
43.         InputStream in = null;  
44.         try {  
45.             in = AppConfig.class.getResourceAsStream(  
46. "AppConfig.properties");  
47.             p.load(in);  
48.             //把配置文件中的内容读出来设置到属性上  
49.             this.parameterA = p.getProperty("paramA");  
50.             this.parameterB = p.getProperty("paramB");  
51.         } catch (IOException e) {  
52.             System.out.println("装载配置文件出错了，具体堆栈信息如下：");  
53.             e.printStackTrace();  
54.         }finally{  
55.             try {  
56.                 in.close();  
57.             } catch (IOException e) {  
58.                 e.printStackTrace();  
59.             }  
60.         }  
61.     }     
62. }  

 

 当然，测试的客户端也需要相应的变化，示例代码如下：

Java代码 

1. public class Client {  
2.     public static void main(String[] args) {  
3.         //创建读取应用配置的对象  
4.         AppConfig config = AppConfig.getInstance();  
5.   
6.         String paramA = config.getParameterA();  
7.         String paramB = config.getParameterB();  
8.   
9.         System.out.println("paramA="+paramA+",paramB="+paramB);  
10.     }  
11. }  

 

 去测试看看，是否能满足要求。

 

注：本文转自   http://chjavach.iteye.com