文档章节

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

We911
 We911
发布于 2017/02/08 10:18
字数 2489
阅读 6
收藏 0

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

声明:都是原创的文章

 

看到很多朋友在写单例,也来凑个热闹,虽然很简单,但是也有很多知识点在单例里面,看看是否能写出点不一样来。 

 

 

单例模式(Singleton)

 

1  场景问题

1.1  读取配置文件的内容

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


1.2  不用模式的解决方案

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
  * 读取应用配置文件
  */
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();
             }
         }
     }
}

 

注意:只有访问参数的方法,没有设置参数的方法。

(2)应用的配置文件,名字是AppConfig.properties,放在AppConfig相同的包里面,简单示例如下:

?
1
2
paramA=a
paramB=b

(3)写个客户端来测试一下,示例代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
public  class  Client {
     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);
     }
}

运行结果如下:

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)懒汉式实现,示例代码如下:

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

(2)饿汉式实现,示例代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/**
  * 饿汉式单例实现的示例
  */
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
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/**
  * 读取应用配置文件,单例实现
  */
public  class  AppConfig {
     /**
      * 定义一个变量来存储创建好的类实例,直接在这里创建类实例,只会创建一次
      */
     private  static  AppConfig instance = new  AppConfig();
     /**
      * 定义一个方法来为客户端提供AppConfig类的实例
      * @return 一个AppConfig的实例
      */
     public  static  AppConfig getInstance(){
         return  instance;
     }
     
     /**
      * 用来存放配置文件中参数A的值
      */
     private  String parameterA;
     /**
      * 用来存放配置文件中参数B的值
      */
     private  String parameterB;
     public  String getParameterA() {
         return  parameterA;
     }
     public  String getParameterB() {
         return  parameterB;
     }
     /**
      * 私有化构造方法
      */
     private  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();
             }
         }
     }  
}

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

?
1
2
3
4
5
6
7
8
9
10
11
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);
     }
}

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

 

 

未完待续,精彩稍后继续 

本文转载自:http://blog.csdn.net/liduanw/article/details/8192914

共有 人打赏支持
We911
粉丝 1
博文 63
码字总数 0
作品 0
深圳
程序员
编程中的那些套路——关于策略模式

该文章属于《编程中的那些经典套路——设计模式汇总》系列,并且以下内容基于语言PHP 今天讲讲策略模式,策略模式 和工厂模式十分相像(或者说在代码逻辑层面,他们是一样的)。 但策略模式与...

gzchen
08/27
0
0
代理模式(Proxy Pattern):动态代理 - 最易懂的设计模式解析

前言 今天我来全面总结开发中最常用的设计模式 - 代理模式中的动态代理模式 其他设计模式介绍 1分钟全面了解“设计模式” 单例模式(Singleton) - 最易懂的设计模式解析 简单工厂模式(Sim...

Carson_Ho
04/09
0
0
javascript 设计模式之工厂(Factory)模式

工厂模式介绍 工厂模式是一个创建型的模式,主要就是创建对象。其中工厂模式又分为简单工厂模式和抽象工厂模式。简单工厂模式是通过工厂方法确定创建 对应类型的对象。抽象工厂模式是通过子类...

hlxiong
2014/04/14
0
0
设计模式知识汇总(附github分享)

写在前面 主要内容 为了更系统的学习设计模式,特地开了这样一个基于Java的设计模式【集中营】,都是笔者在实际工作中用到过或者学习过的一些设计模式的一些提炼或者总检。慢慢地初见规模,也...

landy8530
10/10
0
0
设计模式-工厂模式/委派模式/代理模式/单例模式

1.工厂模式:spring中运用的都是工厂模式,不参与业务的枚举就是工厂模式,所有人均可以调用,工厂模式就是在底层框架中写好. 例如:new 了一个Map 那这个Map创造的过程其实是底层工厂模式代码创造...

森火
09/11
0
0

没有更多内容

加载失败,请刷新页面

加载更多

初级开发-编程题

` public static void main(String[] args) { System.out.println(changeStrToUpperCase("user_name_abc")); System.out.println(changeStrToLowerCase(changeStrToUpperCase("user_name_abc......

小池仔
今天
6
0
现场看路演了!

HiBlock
昨天
16
0
Rabbit MQ基本概念介绍

RabbitMQ介绍 • RabbitMQ是一个消息中间件,是一个很好用的消息队列框架。 • ConnectionFactory、Connection、Channel都是RabbitMQ对外提供的API中最基本的对象。Connection是RabbitMQ的s...

寰宇01
昨天
10
0
官方精简版Windows10:微软自己都看不过去了

微软宣布,该公司正在寻求解决方案,以减轻企业客户的Windows 10规模。该公司声称,企业客户下载整个Windows 10文件以更新设备既费钱又费时。 微软宣布,该公司正在寻求解决方案,以减轻企业...

linux-tao
昨天
19
0
TypeScript基础入门之JSX(二)

转发 TypeScript基础入门之JSX(二) 属性类型检查 键入检查属性的第一步是确定元素属性类型。 内在元素和基于价值的元素之间略有不同。 对于内部元素,它是JSX.IntrinsicElements上的属性类型...

durban
昨天
12
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部