单列模式-编写类ConfigManager读取属性文件

SmiLe_蜻蜓

浏览: 75351 次

最近访客更多访客>>

ikikik2002

yangphere

摇啊摇

xiaolei419

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

JDBC笔记

database.properties ：--->

jdbc.driver_class=com.mysql.jdbc.Driver

jdbc.connection.url=jdbc:mysql://127.0.0.1:3306/news?useUnicode=true$characterEncoding=utf8-8

jdbc.connection.username=root

jdbc.connection.password=1234

========单例模式=========：运行期间有且仅有一个实例

关键点：

一个类只有一个实例---最基本的--（只提供私有的构造器）
它必须自行创建这个实例--（定义了静态的该类的私有对象）
它必须自行向整个系统提供这个实例--（提供一个静态的公有的方法，返回创建或者获取本身的静态私有对象）

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

懒汉模式：（线程不安全，在并发环境下，很有可能会出现多个configManager实列------

-----------需要考虑同步 1、方法体加同步 synchronized 2、双重校验锁）

在类加载的时候，不创建实例，运行调用的时候创建。

优点：类加载快

缺点：效率低，在运行时获取对象速度慢

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

饿汉模式：（线程安全）

在类加载的时候，就完成初始化。

所以类加载慢，但是在运行时获取对象快

1.如这种写法

private static ConfigManager configManager2 = new ConfigManager();

2. 或者这样写

private static ConfigManager configManager;
static(){
    configManager = new ConfigManager();
}

3.如果有要求需要实现延迟加载，通过静态内部类；

保证类加载的速度

--（外部调用 test（）方法时，静态内部类实现了延时加载）

public class Singleton {
	//静态内部类 lazy loading
	private static Singleton singleton;
	
	private Singleton(){}
	
	private static class SingletonHelper{
		private static final Singleton INSTANCE = new Singleton();
	}
	
	public static Singleton getInstance(){
		return SingletonHelper.INSTANCE;
	}
	
	public static void test(){
		System.out.println("test===" + singleton.toString());
	}
	
}

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

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

 

package cn.news.util;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

//读取配置文件的工具类--单例模式
public class ConfigManager {
	//读取配置文件properties.load(inputstream);
	private static ConfigManager configManager;
	private static Properties properties;
	private ConfigManager(){
		String configFile="database.properties";
		properties = new Properties();
		InputStream is = ConfigManager.class.getClassLoader().getResourceAsStream(configFile);
		try {
			properties.load(is);
			is.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public static ConfigManager getInstance(){
		if(configManager==null){
			configManager = new ConfigManager();
		}
		return configManager ;
	}
	
	//取得key对应的value；
	public String getString(String key){
		return properties.getProperty(key);
	}
}

================================================================================

=================================================================================

package com.news.util;
import java.io.InputStream;
import java.util.Properties;
/**
 * 
 * *读取配置文件的工具类---单列模式---懒汉模式--延迟加载
 * 
 * 步骤：
 *
 * 1.创建私有的构造器，进行配置文件的读取
 * 2.创建全局访问点，通过单列模式设置实列化的个数，返回configManager实列
 * 3.通过key获得对应的value
 */
public class ConfigManager {

    private static ConfigManager configManager;
    private static Properties properties;//Properties用来操作properties文件
    
    //私有的构造器，进行配置文件的读取
    private ConfigManager(){
        String configFile="jdbc.properties";
        properties=new Properties();
        
    try {
        //通过classpath找资源
        //在当前类所在包的根目录下找到相应的configFile文件
        //getClassLoader()返回类加载器
        //getResourceAsStream(configFile)返回InputStream对象
        InputStream is=ConfigManager.class.getClassLoader().getResourceAsStream(configFile);
        properties.load(is);//读取配置文件
        is.close();
    } catch (Exception e) {
        // TODO: handle exception
    }
    }
    
    /*
     *线程不安全，在并发环境下，很有可能会出现多个configManager实列
     *需要考虑同步 ， 可以加同步锁 synchronized
     * 懒汉模式   （线程不安全--解决办法1.方法体加同步锁synchronized 2.双重校验锁）
     * 在类加载的时候不创建实列，运行的时候创建。
     * 优点：类加载快
     * 缺点：效率低，在运行时获取对象速度慢
     * 
     *
     */
    //全局访问点
    //通过单列模式设置实列化的个数
    public static synchronized ConfigManager getInstance(){
        if (configManager==null) {
            configManager=new ConfigManager();
        }
        return configManager;
    }
    //通过key获得对应的value
    public String getValue(String key){
        return properties.getProperty(key);
    }
        
    
    /*//双重校验锁
     public static ConfigManager getInstance(){
            if (cManager==null) {
                synchronized(ConfigManager.class){
                    if (cManager==null) {
                        cManager=new ConfigManager();
                    }
                }
            }
            return cManager;
        }*/
}

===================================================================================================

package com.news.util;
import java.io.InputStream;
import java.util.Properties;
/**
 * 单列模式---饿汉模式：（线程安全）
在类加载的时候，就完成初始化。所以类加载慢，但在运行时获取对象快
 */
public class ConfigManager2 {  
    //类加载的时候，自动进行初始化
    private static ConfigManager2 configManager2=new ConfigManager2();
    private static Properties properties;  
    //私有的构造器
    private ConfigManager2(){
        String configFile="database.properties";
        properties=new Properties();     
    try {
        //通过classpath找资源
        //在当前类所在包的根目录下找到相应的configFile文件
        InputStream is=ConfigManager.class.getClassLoader().getResourceAsStream(configFile);
        properties.load(is);
        is.close();
    } catch (Exception e) {
    }   
    }

    //全局访问点
    public static ConfigManager2 getInstance(){
        return configManager2;
    }
    
    public String getValue(String key){
        return properties.getProperty(key);
    }    
}

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

上面的工具类用在JDBC连接数据库时，工具类创建configManager实列，通过configManager实列获取数据库连接。

import java.sql.Connection;

import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.util.ConfigManager;

/*
 * 操作数据库的基类---静态类
 * 
 * 方法：
 * 1.获取数据库连接：public static Connection getConnection()
 *             步骤：
 *                     获取porperties文件，的value值
 *                     加载类的驱动
 *                     获取连接
 *                     返回连接
 * 
 * 2.查询操作：public static ResultSet execute(Connection connection,PreparedStatement preparedStatement,ResultSet resultSet,String sql,Object[] params) 
            throws SQLException
                    步骤：
                        执行SQL
                        接收结果集
                        返回结果集
    3.更新操作：    public static int execute(Connection connection,PreparedStatement preparedStatement,String sql,Object[] params)
            throws Exception
                    步骤：
                        执行SQL
                        接收影响的行数
                        返回影响的行数
    4.关闭资源：public static boolean closeResource(Connection connection,PreparedStatement preparedStatement,ResultSet resultSet)
 *             步骤：
 *                     关闭资源
 *                     GC回收
 *                     返回falg
 */
public class BaseDao {

    //获取数据库连接
    public static Connection getConnection(){
        String driver=ConfigManager.getInstance().getValue("driver");
        String url=ConfigManager.getInstance().getValue("url");
        String username=ConfigManager.getInstance().getValue("username");
        String password=ConfigManager.getInstance().getValue("password");

        Connection connection=null;

        //类加载

        try {
            Class.forName(driver);
            connection=DriverManager.getConnection(url,username,password);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return connection;

    }


    //关闭资源
    public static boolean closeResource(Connection connection,PreparedStatement preparedStatement,ResultSet resultSet){
        boolean flag=true;
        if (resultSet!=null) {
            try {
                resultSet.close();
                resultSet=null;//GC回收
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                flag=false;
            }
        }

        if (preparedStatement!=null) {
            if (preparedStatement!=null) {
                try {
                    preparedStatement.close();
                    preparedStatement=null;//GC回收
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    flag=false;
                }
            }

            if (connection!=null) {
                try {
                    connection.close();
                    connection=null;//GC回收
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    flag=false;
                }
            }


        }
        return flag;
    }
    
    
    //查询操作
    public static ResultSet execute(Connection connection,PreparedStatement preparedStatement,ResultSet resultSet,String sql,Object[] params) 
            throws SQLException{//dao层的异常要抛出，在service层接收
        
        preparedStatement=connection.prepareStatement(sql);
        for (int i = 0; i < params.length; i++) {
            preparedStatement.setObject(i+1, params[i]);
        }
        resultSet=preparedStatement.executeQuery();
        return resultSet;
    }
    
    //更新操作
    public static int execute(Connection connection,PreparedStatement preparedStatement,String sql,Object[] params)
            throws Exception{
        
        int updateRows=0;
        preparedStatement=connection.prepareStatement(sql);
        for (int i = 0; i < params.length; i++) {
            preparedStatement.setObject(i+1, params[i]);
        }
        updateRows=preparedStatement.executeUpdate();
        return updateRows;
    }
}