单例模式-（读取配置文件举例）

Panda072

已于 2023-07-08 13:42:30 修改

阅读量243

点赞数

分类专栏：设计模式文章标签：单例模式 java 开发语言

于 2023-07-08 13:40:10 首次发布

本文链接：https://blog.csdn.net/qq_42668072/article/details/131610153

版权

设计模式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

简介

全局只有一个实例，并对外提供一个访问接口。

分类

饿汉式： 类加载直接创建该单实例对象
懒汉式： 类加载不会直接创建该单实例对象，而是首次使用时才会创建该对象

示例

1、饿汉式
注：通过静态变量方式直接创建对象，但是无论该改对象是否被应用都回被创建，会存在内存浪费的情况。

public class DatebaseProperties extends Properties {
    private static final long serialVersionUID = 3112249424567705007L;

    private DatebaseProperties(){

    }
    private static DatebaseProperties instance = new DatebaseProperties();
}

2、懒汉式
注：当对象第一次被应用时才会被创建，但会存在线程不安全的情况。

public class DatebaseProperties extends Properties {
    private static final long serialVersionUID = 3112249424567705007L;

    private DatebaseProperties(){

    }
    private static DatebaseProperties instance;
	public static DatebaseProperties getDatebaseProperties(){
        if(instance == null){
            instance = new DatebaseProperties();
        }
        return instance;
    }
}

3、懒汉式+线程安全
因为只有在第一次应用到对象的时候，才会创建对象，后续都只是读操作，读操作是线程安全的，所以只需要在第一次创建时增加线程锁。

public class DatebaseProperties extends Properties {
    private static final long serialVersionUID = 3112249424567705007L;

    private DatebaseProperties(){

    }
    private static DatebaseProperties instance;
	public static DatebaseProperties getDatebaseProperties(){
		//首先判断是否为第一次应用到对象
        if(instance == null){
        	//增加线程锁
        	synchronized (DatebaseProperties.class) {
        		//线程安全后再次判断对象是否被创建
        		if(instance == null){
					instance = new DatebaseProperties();
				}
			}
        }
        return instance;
    }
}

举例

本次举例为读取数据库配置文件，所以数据库配置参数对象会被应用，不会存在内存浪费情况，故本次采用饿汉模式。

public class Properties implements Serializable {

    private static final long serialVersionUID = 1897310412557143542L;
    private String key;
    private String value;

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

}

/**
 * 对象类
 */
public class DatebaseProperties extends Properties {
    private static final long serialVersionUID = 3112249424567705007L;

    private DatebaseProperties(){

    }
    private static String source = "panda-jdbc.properties";
    private static DatebaseProperties instance;
    public static DatebaseProperties getDatebaseProperties(){
        if(instance == null){
            instance = createDatebaseProperties();
        }
        return instance;
    }
    private static DatebaseProperties createDatebaseProperties(){
        instance = new DatebaseProperties();
        Map<String, Object> map = PropertiesUtils.readProperties(source);
        instance.setDriver(map.get("jdbc.driver").toString());
        instance.setUrl(map.get("jdbc.url").toString());
        instance.setUserName(map.get("jdbc.userName").toString());
        instance.setPassword(map.get("jdbc.password").toString());
        instance.setMaxConn(map.get("jdbc.maxConn").toString());
        instance.setMaxIdle(map.get("jdbc.maxIdle").toString());
        instance.setInitConn(map.get("jdbc.initConn").toString());
        instance.setMinIdle(map.get("jdbc.minIdle").toString());
        instance.setMaxWaitTimeOut(map.get("jdbc.maxWaitTimeOut").toString());
        instance.setTimeBetweenEvictionRunsMillis(map.get("jdbc.timeBetweenEvictionRunsMillis").toString());
        instance.setMinEvictableIdleTimeMillis(map.get("jdbc.minEvictableIdleTimeMillis").toString());
        instance.setValidationQuery(map.get("jdbc.validationQuery").toString());
        instance.setTestWhileIdle(map.get("jdbc.testWhileIdle").toString());
        instance.setTestOnBorrow(map.get("jdbc.testOnBorrow").toString());
        instance.setTestOnReturn(map.get("jdbc.testOnReturn").toString());
        instance.setPoolPreparedStatements(map.get("jdbc.poolPreparedStatements").toString());
        instance.setMaxPoolPreparedStatementPerConnectionSize(map.get("jdbc.maxPoolPreparedStatementPerConnectionSize").toString());
        return instance;
    }
    private static String  driver;
    private static String  url;
    private static String  userName;
    private static String  password;
    private static String  maxConn;
    private static String  maxIdle;
    private static String  initConn;
    private static String  minIdle;
    private static String  maxWaitTimeOut;
    private static String  timeBetweenEvictionRunsMillis;
    private static String  minEvictableIdleTimeMillis;
    private static String  validationQuery;
    private static String  testWhileIdle;
    private static String  testOnBorrow;
    private static String  testOnReturn;
    private static String  poolPreparedStatements;
    private static String  maxPoolPreparedStatementPerConnectionSize;

    public static String getDriver() {
        return driver;
    }

    public static void setDriver(String driver) {
        DatebaseProperties.driver = driver;
    }

    public static String getUrl() {
        return url;
    }

    public static void setUrl(String url) {
        DatebaseProperties.url = url;
    }

    public static String getUserName() {
        return userName;
    }

    public static void setUserName(String userName) {
        DatebaseProperties.userName = userName;
    }

    public static String getPassword() {
        return password;
    }

    public static void setPassword(String password) {
        DatebaseProperties.password = password;
    }

    public static String getMaxConn() {
        return maxConn;
    }

    public static void setMaxConn(String maxConn) {
        DatebaseProperties.maxConn = maxConn;
    }

    public static String getMaxIdle() {
        return maxIdle;
    }

    public static void setMaxIdle(String maxIdle) {
        DatebaseProperties.maxIdle = maxIdle;
    }

    public static String getInitConn() {
        return initConn;
    }

    public static void setInitConn(String initConn) {
        DatebaseProperties.initConn = initConn;
    }

    public static String getMinIdle() {
        return minIdle;
    }

    public static void setMinIdle(String minIdle) {
        DatebaseProperties.minIdle = minIdle;
    }

    public static String getMaxWaitTimeOut() {
        return maxWaitTimeOut;
    }

    public static void setMaxWaitTimeOut(String maxWaitTimeOut) {
        DatebaseProperties.maxWaitTimeOut = maxWaitTimeOut;
    }

    public static String getTimeBetweenEvictionRunsMillis() {
        return timeBetweenEvictionRunsMillis;
    }

    public static void setTimeBetweenEvictionRunsMillis(String timeBetweenEvictionRunsMillis) {
        DatebaseProperties.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }

    public static String getMinEvictableIdleTimeMillis() {
        return minEvictableIdleTimeMillis;
    }

    public static void setMinEvictableIdleTimeMillis(String minEvictableIdleTimeMillis) {
        DatebaseProperties.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }

    public static String getValidationQuery() {
        return validationQuery;
    }

    public static void setValidationQuery(String validationQuery) {
        DatebaseProperties.validationQuery = validationQuery;
    }

    public static String getTestWhileIdle() {
        return testWhileIdle;
    }

    public static void setTestWhileIdle(String testWhileIdle) {
        DatebaseProperties.testWhileIdle = testWhileIdle;
    }

    public static String getTestOnBorrow() {
        return testOnBorrow;
    }

    public static void setTestOnBorrow(String testOnBorrow) {
        DatebaseProperties.testOnBorrow = testOnBorrow;
    }

    public static String getTestOnReturn() {
        return testOnReturn;
    }

    public static void setTestOnReturn(String testOnReturn) {
        DatebaseProperties.testOnReturn = testOnReturn;
    }

    public static String getPoolPreparedStatements() {
        return poolPreparedStatements;
    }

    public static void setPoolPreparedStatements(String poolPreparedStatements) {
        DatebaseProperties.poolPreparedStatements = poolPreparedStatements;
    }

    public static String getMaxPoolPreparedStatementPerConnectionSize() {
        return maxPoolPreparedStatementPerConnectionSize;
    }

    public static void setMaxPoolPreparedStatementPerConnectionSize(String maxPoolPreparedStatementPerConnectionSize) {
        DatebaseProperties.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
    }

    @Override
    public String toString() {
        return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
                .append("driver", getDriver())
                .append("url", getUrl())
                .append("userName", getUserName())
                .append("password", getPassword())
                .append("maxConn", getMaxConn())
                .append("maxIdle", getMaxIdle())
                .append("initConn", getInitConn())
                .append("minIdle", getMinIdle())
                .append("maxWaitTimeOut", getMaxWaitTimeOut())
                .append("timeBetweenEvictionRunsMillis", getTimeBetweenEvictionRunsMillis())
                .append("minEvictableIdleTimeMillis", getMinEvictableIdleTimeMillis())
                .append("validationQuery", getValidationQuery())
                .append("testWhileIdle", getTestWhileIdle())
                .append("testOnBorrow", getTestOnBorrow())
                .append("testOnReturn", getTestOnReturn())
                .append("poolPreparedStatements", getPoolPreparedStatements())
                .append("maxPoolPreparedStatementPerConnectionSize", getMaxPoolPreparedStatementPerConnectionSize())
                .toString();
    }

}

/**
 *读取本地配置文件工具类
 */
public class PropertiesUtils {
    public static Logger log = LoggerFactory.getLogger(PropertiesUtils.class);
    private static String PROPERTIES_SOURCE = "/config/";

    public static Map<String, Object> readProperties(String source) {
        Properties properties = new Properties();
        ClassPathResource resource = new ClassPathResource(PROPERTIES_SOURCE+source);
        Map<String, Object> map = new HashMap<>();
        try {
            InputStream in = resource.getInputStream();
            BufferedReader bf = new BufferedReader(new InputStreamReader(in,"UTF-8"));
            properties.load(bf);
            Set<Object> keys = properties.keySet();
            for (Object key : keys) {
                Object obj = properties.getProperty(key.toString());
                map.put(key.toString(), obj);
            }
        } catch (IOException e) {
            log.error("加载配置文件失败！-"+PROPERTIES_SOURCE);
            throw new RuntimeException(e);
        }
        return map;
    }

}


/**
 *测试类
 */
public class mainTest {
    public static void main(String[] args) {
        DatebaseProperties datebase = DatebaseProperties.getDatebaseProperties();
        System.out.println(datebase.toString());
    }
}