java 单例模式的好处

java 单例模式的好处  

单例模式是一种常见的设计模式，在《Java与模式》一书中，阎宏博士对单例模式做了全面的总结。

单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。

单例模式有一下特点：

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

说明：一下的代码来自阎宏博士的《Java与模式》一书，其中对一些类的写法做调整（符合Java1.5的习惯），另外还加了测试方法。

一、懒汉式单例

在类被加载的时候，唯一实例已经被创建。这个设计模式在Java中容易实现，在别的语言中难以实现。

/**

* Created by IntelliJ IDEA.

* User: leizhimin

* Date: 2007-9-11

* Time: 14:57:08

* <> 单例模式-懒汉式单例

*/

public class LazySingleton {

     /**

      * 私有静态对象,加载时候不做初始化

      */

     private static LazySingleton m_intance=null;

     /**

      * 私有构造方法,避免外部创建实例

      */

     private LazySingleton(){

     }

     /**

      * 静态工厂方法,返回此类的唯一实例. 

      * 当发现实例没有初始化的时候,才初始化.

      * @return LazySingleton

      */

     synchronized public static LazySingleton getInstance(){

         if(m_intance==null){

             m_intance=new LazySingleton();

         }

         return m_intance;

     }

}

二、饿汉式单例

在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。

/**

* Created by IntelliJ IDEA.

* User: leizhimin

* Date: 2007-9-11

* Time: 14:45:25

* <> 单例模式-饿汉式单例

*/

public class EagerSingleton {

     /**

      * 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象

      */

     private static final EagerSingleton m_instance = new EagerSingleton();

     /**

      * 私有构造方法,避免外部创建实例

      */

     private EagerSingleton() {

     }

     /**

      * 静态工厂方法,返回此类的唯一实例.

      * @return EagerSingleton

      */

     public static EagerSingleton getInstance() {

         return m_instance;

     }

}

三、登记式单例

这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。

/**

* Created by IntelliJ IDEA.

* User: leizhimin

* Date: 2005-9-11

* Time: 15:20:16

* <> 单例模式- 登记式单例

*/

public class RegSingleton {

     /**

      * 登记薄,用来存放所有登记的实例

      */

     private static Map m_registry = new HashMap();

     //在类加载的时候添加一个实例到登记薄

     static {

         RegSingleton x = new RegSingleton();

         m_registry.put(x.getClass().getName(), x);

     }

     /**

      * 受保护的默认构造方法

      */

     protected RegSingleton() {

     }

     /**

      * 静态工厂方法,返回指定登记对象的唯一实例;

      * 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回

      * @param name

      * @return RegSingleton

      */

     public static RegSingleton getInstance(String name) {

         if (name == null) {

             name = "RegSingleton";

         }

         if (m_registry.get(name) == null) {

             try {

                 m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());

             } catch (InstantiationException e) {

                 e.printStackTrace();

             } catch (IllegalAccessException e) {

                 e.printStackTrace();

             } catch (ClassNotFoundException e) {

                 e.printStackTrace();

             }

         }

         return m_registry.get(name);

     }

     /**

      * 一个示意性的商业方法

      * @return String

      */

     public String about() {

         return "Hello,I am RegSingleton!";

     }

}

四、单例模式的一个应用

该应用是配置文件管理类。为了本例能正确运行，我在C盘下先建立了一个xxxx.properties文件，内容如下：

-------------------

user=root

password=leizhimin

这个配置文件管理类的代码如下：

/**

* Created by IntelliJ IDEA.

* User: leizhimin

* Date: 2005-9-11

* Time: 15:55:01

* 单例模式应用-单例类应用-配置文件管理

*/

public class ConfigManager {

     /**

      * 属性文件全名

      */

     private static final String PFILE = "C:\xxx.properties";

     /**

      * 对应于属性文件的文件对象变量

      */

     private File m_file = null;

     /**

      * 属性文件的最后修改日期

      */

     private long m_lastModifiedTime = 0;

     /**

      * 属性文件所对应的属性对象变量

      */

     private Properties m_props = null;

     /**

      * 本类可能存在的唯一的一个实例

      */

     private static ConfigManager m_instance = new ConfigManager();

     /**

      * 私有构造子,用以保证外界无法直接实例化

      */

     private ConfigManager() {

         m_file = new File(PFILE);

         m_lastModifiedTime = m_file.lastModified();

         if (m_lastModifiedTime == 0) {

             System.err.println(PFILE + " file does not exist!");

         }

         m_props = new Properties();

         try {

             m_props.load(new FileInputStream(PFILE));

         } catch (IOException e) {

             e.printStackTrace();

         }

     }

     /**

      * 静态工厂方法

      *

      * @return ConfigManager

      */

     synchronized public static ConfigManager getInstance() {

         return m_instance;

     }

     /**

      * 获取属性配置项的值

      *

      * @param name

      * @param defaultVal

      * @return Object

      */

     public final Object getConfigItem(String name, Object defaultVal) {

         long newTime = m_file.lastModified();

         if (newTime == 0) {

             //属性文件不存在

             if (m_lastModifiedTime == 0) {

                 System.err.println(PFILE + " file does not exist!");

             } else {

                 System.err.println(PFILE + " file was deleted!");

             }

             return defaultVal;

         } else if (newTime > m_lastModifiedTime) {

             m_props.clear();

             try {

                 m_props.load(new FileInputStream(PFILE));

             } catch (IOException e) {

                 e.printStackTrace();

             }

         }

         m_lastModifiedTime = newTime;

         Object val = m_props.getProperty(name);

         if (val == null) {

             return defaultVal;

         } else {

             return val;

         }

     }

}

测试配置文件类：

/**

* Created by IntelliJ IDEA.

* User: leizhimin

* Date: 2007-9-11

* Time: 16:42:45

* 配置文件管理类测试

*/

public class Test_ConfigManager {

     public static void main(String[] args) {

         ConfigManager cfgm = ConfigManager.getInstance();

         Object val1 = cfgm.getConfigItem("sdf", "leizhimin");

         Object val2 = cfgm.getConfigItem("user", "leizhimin");

         System.out.println(val1.toString());

         System.out.println(val2.toString());

     }

}

运行结果：

leizhimin

root

Process finished with exit code 0

五、笔者写的一个JDBC数据库工具类的单例实现

/**

* Created by IntelliJ IDEA.

* User: leizhimin

* Date: 2005-9-11

* Time: 18:04:46

* 单例模式在JDBC编程中的应用,用于设计数据库工具类

*/

public class DBUtil {

     //单一实例

     private static final DBUtil _instance = new DBUtil();

     //数据源的JNDI

     private static final String datasource = "java:comp/env/jdbc/zvfims";

     /**

      * 私有构造方法,防止外部实例化

      */

     private DBUtil() {

     }

     /**

      * 数据库工具类实例工厂

      *

      * @return DBUtil

      */

     public DBUtil getInstance() {

         return _instance;

     }

     /**

      * 业务方法:用于获取数据库连接

      *

      * @return Connection

      */

     public Connection makeConnection() {

         Connection conn = null;

         try {

             Context ctx = new InitialContext();

             DataSource ds = (DataSource) ctx.lookup(datasource);

             conn = ds.getConnection();

         } catch (NamingException e) {

             System.out.println("获取数据源异常,请AppServer的JNDI数据源配置!");

             e.printStackTrace();

         } catch (SQLException e) {

             System.err.println("获取数据库连接发生异常!");

             e.printStackTrace();

         }

         return conn;

     }

}

通过这个单例类和开放的业务方法，可以为整个系统应用提供数据库连接。