研磨设计模式之单例模式Word文件下载.docx
《研磨设计模式之单例模式Word文件下载.docx》由会员分享，可在线阅读，更多相关《研磨设计模式之单例模式Word文件下载.docx（29页珍藏版）》请在冰豆网上搜索。
publicStringgetParameterA（）{
returnparameterA;
}
publicStringgetParameterB（）{
returnparameterB;
*构造方法
publicAppConfig（）{
//调用读取配置文件的方法
readConfig（）;
*读取配置文件，把配置文件中的内容读出来设置到属性上
privatevoidreadConfig（）{
Propertiesp=newProperties（）;
InputStreamin=null;
try{
in=AppConfig.class.getResourceAsStream（
"
AppConfig.properties"
）;
p.load（in）;
//把配置文件中的内容读出来设置到属性上
this.parameterA=p.getProperty（"
paramA"
this.parameterB=p.getProperty（"
paramB"
}catch（IOExceptione）{
System.out.println（"
装载配置文件出错了，具体堆栈信息如下：
e.printStackTrace（）;
}finally{
try{
in.close（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
注意：
只有访问参数的方法，没有设置参数的方法。
（2）应用的配置文件，名字是AppConfig.properties，放在AppConfig相同的包里面，简单示例如下：
paramA=a
paramB=b
（3）写个客户端来测试一下，示例代码如下：
publicclassClient{
publicstaticvoidmain（String[]args）{
//创建读取应用配置的对象
AppConfigconfig=newAppConfig（）;
StringparamA=config.getParameterA（）;
StringparamB=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）懒汉式实现，示例代码如下：
*懒汉式单例实现的示例
publicclassSingleton{
*定义一个变量来存储创建好的类实例
privatestaticSingletonuniqueInstance=null;
*私有化构造方法，好在内部控制创建实例的数目
privateSingleton（）{
//
*定义一个方法来为客户端提供类实例
*@return一个Singleton的实例
publicstaticsynchronizedSingletongetInstance（）{
//判断存储实例的变量是否有值
if（uniqueInstance==null）{
//如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
uniqueInstance=newSingleton（）;
//如果有值，那就直接使用
returnuniqueInstance;
*示意方法，单例可以有自己的操作
publicvoidsingletonOperation（）{
//功能处理
*示意属性，单例可以有自己的属性
privateStringsingletonData;
*示意方法，让外部通过这些方法来访问属性的值
*@return属性的值
publicStringgetSingletonData（）{
returnsingletonData;
（2）饿汉式实现，示例代码如下：
*饿汉式单例实现的示例
*定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次
privatestaticSingletonuniqueInstance=newSingleton（）;
publicstaticSingletongetInstance（）{
//直接使用已经创建好的实例
2.4
使用单例模式重写示例
要使用单例模式来重写示例，由于单例模式有两种实现方式，这里选一种来实现就好了，就选择饿汉式的实现方式来重写示例吧。
采用饿汉式的实现方式来重写实例的示例代码如下：
*读取应用配置文件，单例实现
privatestaticAppConfiginstance=newAppConfig（）;
*定义一个方法来为客户端提供AppConfig类的实例
*@return一个AppConfig的实例
publicstaticAppConfiggetInstance（）{
returninstance;
*私有化构造方法
privateAppConfig（）{
}
当然，测试的客户端也需要相应的变化，示例代码如下：
AppConfigconfig=AppConfig.getInstance（）;
去测试看看，是否能满足要求。
3
模式讲解
3.1
认识单例模式
（1）单例模式的功能
单例模式的功能是用来保证这个类在运行期间只会被创建一个类实例，另外单例模式还提供了一个全局唯一访问这个类实例的访问点，就是那个getInstance的方法。
不管采用懒汉式还是饿汉式的实现方式，这个全局访问点是一样的。
对于单例模式而言，不管采用何种实现方式，它都是只关心类实例的创建问题，并不关心具体的业务功能。
（2）单例模式的范围
也就是在多大范围内是单例呢？
观察上面的实现可以知道，目前Java里面实现的单例是一个虚拟机的范围。
因为装载类的功能是虚拟机的，所以一个虚拟机在通过自己的ClassLoader装载饿汉式实现的单例类的时候就会创建一个类的实例。
这就意味着如果一个机器上有多个虚拟机，那么每个虚拟机里面都应该有一个这个类的实例，但是整个机器上就有很多个实例了。
另外请注意一点，这里讨论的单例模式并不适用于集群环境，对于集群环境下的单例这里不去讨论，那不属于这里的内容范围。
（3）单例模式的命名
一般建议单例模式的方法命名为：
getInstance（），这个方法的返回类型肯定是单例类的类型了。
getInstance方法可以有参数，这些参数可能是创建类实例所需要的参数，当然，大多数情况下是不需要的。
单例模式的名称：
单例、单件、单体等等，翻译的不同，都是指的同一个模式。
3.2
懒汉式和饿汉式实现
前面提到了单例模式有两种典型的解决方案，一种叫懒汉式，一种叫饿汉式，这两种方式究竟是如何实现的，下面分别来看看。
为了看得更清晰一点，只是实现基本的单例控制部分，不再提供示例的属性和方法了；
而且暂时也不去考虑线程安全的问题，这个问题在后面会重点分析。
1：
第一种方案懒汉式
（1）私有化构造方法
要想在运行期间控制某一个类的实例只有一个，那首先的任务就是要控制创建实例的地方，也就是不能随随便便就可以创建类实例，否则就无法控制创建的实例个数了。
现在是让使用类的地方来创建类实例，也就是在类外部来创建类实例。
那么怎样才能让类的外部不能创建一个类的实例呢？
很简单，私有化构造方法就可以了！
示例代码如下：
privateSingleton（）{
（2）提供获取实例的方法
构造方法被私有化了，外部使用这个类的地方不干了，外部创建不了类实例就没有办法调用这个对象的方法，就实现不了功能处理，这可不行。
经过思考，单例模式决定让这个类提供一个方法来返回类的实例，好让外面使用。
publicSingletongetInstance（）{
（3）把获取实例的方法变成静态的
又有新的问题了，获取对象实例的这个方法是个实例方法，也就是说客户端要想调用这个方法，需要先得到类实例，然后才可以调用，可是这个方法就是为了得到类实例，这样一来不就形成一个死循环了吗？
这不就是典型的“先有鸡还是先有蛋的问题”嘛。
解决方法也很简单，在方法上加上static，这样就可以直接通过类来调用这个方法，而不需要先得到类实例了，示例代码如下：
publicstaticSingletongetInstance（）{
（4）定义存储实例的属性
方法定义好了，那么方法内部如何实现呢？
如果直接创建实例并返回，这样行不行呢？
示例代码如下
publicstaticSingletongetInstance（）{
returnnewSingleton（）;
当然不行了，如果每次客户端访问都这样直接new一个实例，那肯定会有多个实例，根本实现不了单例的功能。
怎么办呢？
单例模式想到了一个办法，那就是用一个属性来记录自己创建好的类实例，当第一次创建过后，就把这个实例保存下来，以后就可以复用这个实例，而不是重复创建对象实例了。
privateSingletoninstance=null;
（5）把这个属性也定义成静态的
这个属性变量应该在什么地方用呢？
肯定是第一次创建类实例的地方，也就是在前面那个返回对象实例的静态方法里面使用。
由于要在一个静态方法里面使用，所以这个属性被迫成为一个类变量，要强制加上static，也就是说，这里并没有使用static的特性。
privatestaticSingletoninstance=null;
（6）实现控制实例的创建
现在应该到getInstance方法里面实现控制实例创建了，控制的方式很简单，只要先判断一下，是否已经创建过实例了。
如何判断？
那就看存放实例的属性是否有值，如果有值，说明已经创建过了，如果没有值，那就是应该创建一个，示例代码如下：
//先判断instance是否有值
if（instance==null）{
//如果没有值，说明还没有创建过实例，那就创建一个
//并把这个实例设置给instance
instance=newSingleton（）;
//如果有值，或者是创建了值，那就直接使用
returninstance;
（7）完整的实现
至此，成功解决了：
在运行期间，控制某个类只被创建一个实例的要求。
完整的代码如下，为了大家好理解，用注释标示了代码的先后顺序，示例代码如下：
//4：
定义一个变量来存储创建好的类实例
//5：
因为这个变量要在静态方法中使用，所以需要加上static修饰
privatestaticSingletoninstance=null;
//1：
私有化构造方法，好在内部控制创建实例的数目
privateSingleton（）{
//2：
定义一个方法来为客户端提供类实例
//3：
这个方法需要定义成类方法，也就是要加static
//6：
判断存储实例的变量是否有值
if（instance==null）{
//6.1：
如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
instance=newSingleton（）;
//6.2：
如果有值，那就直接使用
2：
第二种方案饿汉式
这种方案跟第一种方案相比，前面的私有化构造方法，提供静态的getInstance方法来返回实例等步骤都一样。
差别在如何实现getInstance方法，在这个地方，单例模式还想到了另外一种方法来实现getInstance方法。
不就是要控制只创造一个实例吗？
那么有没有什么现成的解决办法呢？
很快，单例模式回忆起了Java中static的特性：
∙static变量在类装载的时候进行初始化
∙多个实例的static变量会共享同一块内存区域。
这就意味着，在Java中，static变量只会被初始化一次，就是在类装载的时候，而且多个实例都会共享这个内存空间，这不就是单例模式要实现的功能吗？
真是得来全不费功夫啊。
根据这些知识，写出了第二种解决方案的代码，示例代码如下：
定义一个静态变量来存储创建好的类实例
//直接在这里创建类实例，只会创建一次
privatestaticSingletoninstance=newSingleton（）;
privateSingleton（）{
//这个方法里面就不需要控制代码了
//5：
直接使用已经创建好的实例
注意一下，这个方案是用到了static的特性的，而第一个方案是没有用到的，因此两个方案的步骤会有一些不同，在第一个方案里面，强制加上static也是算作一步的，而在这个方案里面，是主动加上static，就不单独算作一步了。
所以在查看上面两种方案的代码的时候，仔细看看编号，顺着编号的顺序看，可以体会出两种方案的不一样来。
不管是采用哪一种方式，在运行期间，都只会生成一个实例，而访问这些类的一个全局访问点，就是那个静态的getInstance方法。
3：
单例模式的调用顺序示意图
由于单例模式有两种实现方式，那么它的调用顺序也分成两种。
先看懒汉式的调用顺序，如图2所示：
图2
懒汉式调用顺序示意图
饿汉式的调用顺序，如图3所示：
升级会员 