单态模式类特点:
1.单态模式类只能有一个唯一实例
2.构造器私有,外部不能创建实例
3.必须要有一个让外部获取该唯一实例的static方法
单态模式分为两种:
1.懒汉模式,在类被加载的时候就构建该类的唯一实例
2.饿汉模式,在该类被第一次使用的时候构建该类的唯一实例

解决方案 »

  1.   

    懒汉模式例:/**
     * 数据库连接管理类<br>
     * Author:BluesLee<br>
     * CreateDate:2008-01-22<br>
     * Modifier:BluesLee<br>
     * ModifyDate:2008-01-22<br>
     * Version:1.0<br>
     * Copyright(c)2008 深蓝工作室<br>
     * All right reserved.<br>
     */
    public class DBManager {
    private static Logger logger = Logger.getLogger(DBManager.class); /**
     * 本静态变量用来存放本系统启动时由Struts生成的连接池的数据源
     */
    private static DataSource datasource; /**
     * 由于本类使用单态设计模式,因此不允许在使用中通过New进行实例化,那么本类就要提供一个 此类的实例供外界使用,这就是供外界使用的实例
     */
    private static DBManager dbConManager = new DBManager();//类被加载时构建实例 private DBManager() {
    } /**
     * 此静态方法用来向类的静态变量赋值,用来在系统中使用 <br>
     * Author:BluesLee<br>
     * CreateDate:2008-01-22<br>
     * Modifier:BluesLee<br>
     * ModifyDate:2008-01-22<br>
     * Version:1.0<br>
     * 
     * @param mydatasource
     *            传入的struts生成的数据源
     */
    public void setDatasource(DataSource mydatasource) {
    logger.info("设置数据源");
    if (datasource == null) {
    datasource = mydatasource;
    }
    } /**
     * 由于本类使用单态模式,不允许其他的类使用New进行创建实例 因此在这里提供一个共有的静态方法来向外界提供自己的一个实例。 <br>
     * Author:BluesLee<br>
     * CreateDate:2008-01-22<br>
     * Modifier:BluesLee<br>
     * ModifyDate:2008-01-22<br>
     * Version:1.0<br>
     * 
     * @return 返回本类的唯一实例
     */
    public static DBManager getInstance() {
    logger.info("获得数据库连接管理类的实例");
    return dbConManager;
    } /**
     * 此方法提供一个可用的数据库连接,从连接池中取得可用连接 <br>
     * Author:BluesLee<br>
     * CreateDate:2008-01-22<br>
     * Modifier:BluesLee<br>
     * ModifyDate:2008-01-22<br>
     * Version:1.0<br>
     * 
     * @return 可用的数据库连接
     * @throws java.lang.SQLException
     *             有可能要抛出的SQL异常
     */
    public Connection getConnection() throws SQLException {
    Connection conn = null;
    try {
    logger.info("从连接池中获得空闲的数据库连接");
    conn = datasource.getConnection();
    return conn;
    } catch (SQLException ex) {
    logger.error("DBManager.getConnection(获取数据库连接失败):[SQLException]"
    + ex.getMessage());
    throw ex;
    }
    } /**
     * 这是一个用来关闭所有的数据库连接相关的打开对象的方法,这样作的好处是不用在每一次调用了sql之后 要写一大串的关闭操作。<br>
     * Author:BluesLee<br>
     * CreateDate:2008-01-22<br>
     * Modifier:BluesLee<br>
     * ModifyDate:2008-01-22<br>
     * Version:1.0<br>
     * 
     * @param conn
     *            将要关闭的数据库连接
     * @param st
     *            将要关闭的数据库操作对象
     * @param pst
     *            将要关闭的预处理数据库操作对象
     * @param cst
     *            将要关闭的数据库存储过程调用对象
     * @param rst
     *            将要关闭的数据库记录集对象
     * @throws java.lang.Exception
     *             有可能要抛出的异常
     */
    public void closeAll(Connection conn, Statement st, PreparedStatement pst,
    CallableStatement cst, ResultSet rst) throws DBManagerException {
    try {
    if (rst != null) {
    rst.close();
    }
    if (st != null) {
    st.close();
    }
    if (pst != null) {
    pst.close();
    }
    if (cst != null) {
    cst.close();
    }
    if (conn != null) {
    conn.close();
    }
    } catch (SQLException e) {
    throw new DBManagerException("数据库对象关闭出错!"+e.getMessage(),e);
    }
    }
    }
      

  2.   

    就是只让一个类在JVM运行期间只产生一个对象实现方法一般是就是私有化构造函数 提供静态方法获得这个单例子对象public class Singleton {    //单例对象
       private static Singleton  singleton= null;
       
       private Singleton(){ //私有构造函数
       }
       //获得单例的方法
       public static Singleton getSingleton(){
           if(singleton == null ) {
               singleton = new Singleton();
           }
           return singleton; 
       }
    }
      

  3.   

    饿汉模式例:
    注意,当以饿汉模式来创建单态模式时,获取实例的静态方法必须是线程安全的,否则很可能会出现两个或多个该类实例/**
     * 数据库连接管理类<br>
     * Author:BluesLee<br>
     * CreateDate:2008-01-22<br>
     * Modifier:BluesLee<br>
     * ModifyDate:2008-01-22<br>
     * Version:1.0<br>
     * Copyright(c)2008 深蓝工作室<br>
     * All right reserved.<br>
     */
    public class DBManager {
        private static Logger logger = Logger.getLogger(DBManager.class);    /**
         * 本静态变量用来存放本系统启动时由Struts生成的连接池的数据源
         */
        private static DataSource datasource;    /**
         * 由于本类使用单态设计模式,因此不允许在使用中通过New进行实例化,那么本类就要提供一个 此类的实例供外界使用,这就是供外界使用的实例
         */
        private static DBManager dbConManager = null;//类被加载时构建实例    private DBManager() {
        }    /**
         * 此静态方法用来向类的静态变量赋值,用来在系统中使用 <br>
         * Author:BluesLee<br>
         * CreateDate:2008-01-22<br>
         * Modifier:BluesLee<br>
         * ModifyDate:2008-01-22<br>
         * Version:1.0<br>
         * 
         * @param mydatasource
         *            传入的struts生成的数据源
         */
        public void setDatasource(DataSource mydatasource) {
            logger.info("设置数据源");
            if (datasource == null) {
                datasource = mydatasource;
            }
        }    /**
         * 由于本类使用单态模式,不允许其他的类使用New进行创建实例 因此在这里提供一个共有的静态方法来向外界提供自己的一个实例。 <br>
         * Author:BluesLee<br>
         * CreateDate:2008-01-22<br>
         * Modifier:BluesLee<br>
         * ModifyDate:2008-01-22<br>
         * Version:1.0<br>
         * 
         * @return 返回本类的唯一实例
         */
        public static synchronized DBManager getInstance() {//必须是线程安全的
            logger.info("获得数据库连接管理类的实例");
            if(dbConManager==null){
                  dbConManager=new DBManager();
            }
            return dbConManager;
        }    /**
         * 此方法提供一个可用的数据库连接,从连接池中取得可用连接 <br>
         * Author:BluesLee<br>
         * CreateDate:2008-01-22<br>
         * Modifier:BluesLee<br>
         * ModifyDate:2008-01-22<br>
         * Version:1.0<br>
         * 
         * @return 可用的数据库连接
         * @throws java.lang.SQLException
         *             有可能要抛出的SQL异常
         */
        public Connection getConnection() throws SQLException {
            Connection conn = null;
            try {
                logger.info("从连接池中获得空闲的数据库连接");
                conn = datasource.getConnection();
                return conn;
            } catch (SQLException ex) {
                logger.error("DBManager.getConnection(获取数据库连接失败):[SQLException]"
                        + ex.getMessage());
                throw ex;
            }
        }    /**
         * 这是一个用来关闭所有的数据库连接相关的打开对象的方法,这样作的好处是不用在每一次调用了sql之后 要写一大串的关闭操作。<br>
         * Author:BluesLee<br>
         * CreateDate:2008-01-22<br>
         * Modifier:BluesLee<br>
         * ModifyDate:2008-01-22<br>
         * Version:1.0<br>
         * 
         * @param conn
         *            将要关闭的数据库连接
         * @param st
         *            将要关闭的数据库操作对象
         * @param pst
         *            将要关闭的预处理数据库操作对象
         * @param cst
         *            将要关闭的数据库存储过程调用对象
         * @param rst
         *            将要关闭的数据库记录集对象
         * @throws java.lang.Exception
         *             有可能要抛出的异常
         */
        public void closeAll(Connection conn, Statement st, PreparedStatement pst,
                CallableStatement cst, ResultSet rst) throws DBManagerException {
            try {
                if (rst != null) {
                    rst.close();
                }
                if (st != null) {
                    st.close();
                }
                if (pst != null) {
                    pst.close();
                }
                if (cst != null) {
                    cst.close();
                }
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                throw new DBManagerException("数据库对象关闭出错!"+e.getMessage(),e);
            }
        }
    }
      

  4.   

    哇哦!还有“懒汉”“饿汉”模式哦,没听过这名次呢“懒汉”模式还不用担心线程安全(不用显示使用synchronized)那什么时候用懒汉,什么时候用饿汉呢?我咋瞅着懒汉舒服点
      

  5.   


    还是这个是入门级的。。  
    lip009别把楼主吓了。
      

  6.   

    lip009
    说错了吧懒汉模式是第一次使用的时候才构建唯一实例
    而饿汉模式再类加载时就生成了实例
    所谓懒汉模式就是Lazy initialization
    从你的程序都能可看出来你的结论和代码是矛盾的。应该是你写错的吧
    不过代码有点长,要吓走一群人哦