`
seaizon
  • 浏览: 145240 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

研磨设计模式之单例模式-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. }  
/**
 * 读取应用配置文件
 */
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相同的包里面,简单示例如下:

Java代码
  1. paramA=a  
  2. paramB=b  
paramA=a
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. }  
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);
	}
}

 

运行结果如下:

Java代码
  1. paramA=a,paramB=b  
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. }  
/**
 * 懒汉式单例实现的示例
 */
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)饿汉式实现,示例代码如下:

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. }  
/**
 * 饿汉式单例实现的示例
 */
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  使用单例模式重写示例

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

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. }  
/**
 * 读取应用配置文件,单例实现
 */
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();
			}
		}
	}	
}

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

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. }  
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://chjavach.iteye.com/blog/721076

分享到:
评论

相关推荐

    研磨设计模式之单例模式

    通过研磨设计模式之单例模式的资料,你可以深入理解单例模式的原理、实现方式及其优缺点,进一步提升自己的编程技能和设计思维。学习并熟练掌握设计模式,对于成为一名优秀的Java开发者至关重要。

    研磨设计模式源码

    《研磨设计模式源码》是一份非常宝贵的资源,它提供了设计模式的实践代码,帮助开发者深入理解并应用这些模式。设计模式是软件工程中经过长期实践总结出来的一套通用解决方案,它们描述了在特定场景下如何解决常见...

    研磨设计模式(完整带书签).part2.pdf

    《研磨设计模式》完整覆盖GoF讲述的23个设计模式并加以细细研磨。初级内容从基本讲起,包括每个模式的定义、功能、思路、结构、基本实现、运行调用顺序、基本应用示例等,让读者能系统、完整、准确地掌握每个模式,...

    研磨设计模式-配套源代码 UTF-8格式

    《研磨设计模式》是一本深入探讨软件设计原则与实践的经典书籍,其配套源代码提供了丰富的实例,帮助读者更好地理解和应用各种设计模式。这个UTF-8格式的压缩包包含了书中介绍的各种设计模式的实现,是学习和研究...

    研磨设计模式--chjavach的博客文章

    研磨设计模式的过程是持续学习和实践的过程,chjavach的博客文章提供了深入探讨这些模式的宝贵资源,值得我们仔细阅读和学习。通过深入理解和运用这些设计模式,可以提升个人的编程技巧,同时也为团队合作和项目维护...

    研磨设计模式-配套源代码

    以上只是设计模式中的一部分,研磨设计模式的配套源代码可能涵盖了这些或更多的模式。通过学习这些源代码,你可以更深入地理解每个模式的实现细节,以及如何在实际项目中灵活应用。这将有助于提升你的编程技能,使...

    研磨设计模式PDF

    《研磨设计模式》这本书是陈臣和王斌两位作者合作的成果,专注于讲解软件设计中的模式应用。设计模式是软件工程中的一种最佳实践,它总结了在特定上下文中解决问题的常见方法,使得开发者可以复用这些解决方案,提高...

    研磨设计模式-配套源代码.7z

    《研磨设计模式》是一本深入探讨软件设计模式的书籍,其配套源代码包含了许多经典设计模式的实际应用示例。这些源代码可以帮助读者更直观地理解设计模式的原理和使用方法,进一步提升软件开发能力。 设计模式是软件...

    研磨设计模式[书签]

    《研磨设计模式》是由陈臣和王斌合著,由清华大学出版社出版的一本深入探讨设计模式的专业书籍。设计模式是软件工程中的一个重要概念,它代表了在特定上下文中解决问题的常见方法,经过时间和实践的验证,具有很高的...

    研磨设计模式-配套源代码.rar

    《研磨设计模式》是一本深入探讨软件设计模式的书籍,配套源代码是作者为了帮助读者更好地理解和应用书中介绍的设计模式而提供的实践示例。设计模式是软件开发中经过实践检验的、解决常见问题的模板,它为软件设计...

    研磨设计模式(完整带书签).part1.pdf

    《研磨设计模式》完整覆盖GoF讲述的23个设计模式并加以细细研磨。初级内容从基本讲起,包括每个模式的定义、功能、思路、结构、基本实现、运行调用顺序、基本应用示例等,让读者能系统、完整、准确地掌握每个模式,...

    研磨设计模式博文集

    这个“研磨设计模式博文集”显然是一份深入探讨设计模式的资料集合,其中可能包含了对多种设计模式的详细解析、示例代码以及实际应用中的经验分享。在软件开发中,设计模式能够帮助开发者提高代码质量、可读性和可...

    研磨设计模式全部源代码

    这个压缩包“研磨设计模式全部源代码”包含了多种设计模式的实现,这些模式可以帮助开发者写出更可维护、可扩展和可复用的代码。下面将详细讲解其中可能包含的一些重要设计模式及其应用。 1. 工厂模式:这是最简单...

    研磨设计模式.rar

    《研磨设计模式》这本书是软件开发领域中的经典之作,主要关注的是面向对象设计中的设计模式。设计模式是在特定上下文中解决常见问题的最佳实践,它为开发者提供了在类似情况下重复使用解决方案的模板,有助于提高...

    研磨设计模式讲课PPT

    研磨设计模式是一本深入探讨软件设计原则与实践的书籍,其讲课PPT为我们提供了丰富的设计模式知识。设计模式是软件工程中经过实践验证的、解决常见问题的模板,是经验丰富的开发人员智慧的结晶。这些模式可以帮助...

    研磨设计模式 源代码

    《研磨设计模式》是一本深入探讨软件设计模式的经典书籍,源代码包含了书中所讲解的各种设计模式的实际应用示例。设计模式是软件工程中的重要概念,它们是经过反复验证、在特定情境下解决常见问题的有效解决方案。...

    研磨设计模式 演示源代码

    1. **单例模式**:确保一个类只有一个实例,并提供一个全局访问点。在资源管理、缓存或者线程池等场景中广泛应用。 2. **工厂模式**:提供一个接口来创建对象,但让子类决定实例化哪一个类。工厂方法让类的实例化...

    研磨设计模式-part2

    《研磨设计模式》完整覆盖GoF讲述的23个设计模式并加以细细研磨。初级内容从基本讲起,包括每个模式的定义、功能、思路、结构、基本实现、运行调用顺序、基本应用示例等,让读者能系统、完整、准确地掌握每个模式,...

Global site tag (gtag.js) - Google Analytics