1.单态设计模式实例 以及应用

这样的一段读取配置文件的代码

   /** 
    * 读取应用配置文件 
    */  
   public class AppConfig {  
       /** 
        * 用来存放配置文件中参数A的值 
        */  
       private String parameterA;  
       /** 
        * 用来存放配置文件中参数B的值 
        */  
       private String parameterB;    
     
       public String getParameterA() {  
           return parameterA;  
       }  
       public String getParameterB() {  
           return parameterB;  
       }  
       /** 
        * 构造方法 
        */  
       public AppConfig(){  
           //调用读取配置文件的方法  
           readConfig();  
       }  
       /** 
        * 读取配置文件，把配置文件中的内容读出来设置到属性上 
        */  
       private void readConfig(){  
           Properties p = new Properties();   
           InputStream in = null;  
           try {  
               in = AppConfig.class.getResourceAsStream(  
   "AppConfig.properties");  
               p.load(in);  
               //把配置文件中的内容读出来设置到属性上  
               this.parameterA = p.getProperty("paramA");  
               this.parameterB = p.getProperty("paramB");  
           } catch (IOException e) {  
               System.out.println("装载配置文件出错了，具体堆栈信息如下：");  
               e.printStackTrace();  
           }finally{  
               try {  
                   in.close();  
               } catch (IOException e) {  
                   e.printStackTrace();  
               }  
           }  
       } 
        public static void main(String[] args) {  
         //创建读取应用配置的对象  
         AppConfig config = new AppConfig();  
           
         String paramA = config.getParameterA();  
         String paramB = config.getParameterB();  
          
        System.out.println("paramA="+paramA+",paramB="+paramB);  
   }  


 
   }  

  

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

配置文件代码如下：

paramA=a
paramB=b

 

有何问题

        上面的实现很简单嘛，很容易的就实现了要求的功能。仔细想想，有没有什么问题呢？
        看看客户端使用这个类的地方，是通过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代码

 **
 * 饿汉式单例实现的示例
 */
 public class Singleton {
 /**
 * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次
 */
 private static Singleton uniqueInstance = new Singleton();
 /**
 * 私有化构造方法，好在内部控制创建实例的数目
 */
 private Singleton(){
 //
 }
 /**
 * 定义一个方法来为客户端提供类实例
 * @return 一个Singleton的实例
 */
 public static Singleton getInstance(){
 //直接使用已经创建好的实例
 return uniqueInstance;
 }
#
 /**
 * 示意方法，单例可以有自己的操作
 */
 public void singletonOperation(){
 //功能处理
 }
 /**
 * 示意属性，单例可以有自己的属性
 */
 private String singletonData;
 /**
 * 示意方法，让外部通过这些方法来访问属性的值
 * @return 属性的值
 */
 public String getSingletonData(){
 return singletonData;
  }
 }

 

2.4  使用单例模式重写示例

        要使用单例模式来重写示例，由于单例模式有两种实现方式，这里选一种来实现就

 好了，就选择饿汉式的实现方式来重写示例吧。
        采用饿汉式的实现方式来重写实例的示例代码如下：

写道

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. }

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

 public   class  Client {
     public   static   void  main(String[] args) {
         //创建读取应用配置的对象
         AppConfig config = AppConfig.getInstance();

         String paramA = config.getParameterA();
         String paramB = config.getParameterB();

         System.out.println("paramA=" +paramA+ ",paramB=" +paramB);
     }
 }