基于netty的tcp框架搭建-多配置文件加载

多配置文件加载

针对项目中使用的配置文件，统一进行加载，并提供热加载的接口

配置说明

1. jvm启动配置文件路径 ，通过jvm启动参数配置需要加载的配置文件路径，此路径用于存放所有自定义配置文件
   例如：-Dconfig.path=D:/develop/src/main/resources
2. 默认加载主配置文件 my.properties ；
3. 配置多配置文件 ；
   my.properties中使用include.multi.files=fileName1，fileName2，fileName3…的方式配置多文件名，
4. 系统 自动加载 各个配置文件配置；
5. 支持重载配置文件 ，当配置文件发生变化时，对外提供api可以重新加载配置；
6. 提供获取配置的方法，分别是指定配置文件，和缺省获取配置（缺省情况下会从全部配置文件中，获取首次加载的配置，重复只会获取一个）；
7. 使用单例控制使用。

代码

package com.core.common.config;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author commuli
 * @date 2019/4/23
 */
public class MultiConfig {
    private static final Logger LOG = LoggerFactory.getLogger(MultiConfig.class);

    private final String includeMultiFilesKey = "include.multi.files";
    private final String configPath = System.getProperty("config.path", null);
    private final String mainPropertiesName = "my.properties";

    private static MultiConfig multiConfig;

    private MultiConfig() {
    }

    /**
     * 创建一个map 用来缓存加载的配置文件
     * key为配置文件名称，包含后缀
     */
    private Map<String, Properties> propertiesMap = new ConcurrentHashMap<>(16);


    private static synchronized void syncInit() {
        if (multiConfig == null) {
            multiConfig = new MultiConfig();
            multiConfig.loadAllConfig();
        }
    }

    public static MultiConfig getInstance() {
        if (multiConfig == null) {
            syncInit();
        }
        return multiConfig;
    }


    /**
     * 指定获取某个配置文件的配置
     *
     * @param propertiesKey
     * @param fieldKey
     * @return java.lang.Object
     * @author commuli
     * @date 2019/4/23
     */
    private Object getProperties(String propertiesKey, String fieldKey) {
        return get(propertiesKey).getProperty(fieldKey);
    }

    /**
     * 缺省获取配置文件配置，如多个配置中有相同的key默认只取一个，
     *
     * @param fieldKey
     * @return java.lang.Object
     * @author commuli
     * @date 2019/4/23
     */
    private Object getProperties(String fieldKey) {
        List<Properties> allProperties = getAllProperties();
        if (allProperties.isEmpty()) {
            return null;
        }
        Object obj = null;
        for (Properties properties : allProperties) {
            if ((obj = properties.getProperty(fieldKey)) == null) {
                continue;
            }
            break;
        }
        return obj;
    }

    /**
     * 初始化加载主配置文件，从主配置文件中获取从配置文件
     *
     * @param
     * @return void
     * @author commuli
     * @date 2019/4/23
     */
    public void loadAllConfig() {
        clear();
        makeProperties(mainPropertiesName);
        Properties mainProperties;
        if ((mainProperties = get(mainPropertiesName)) != null) {
            //获取从文件
            String includeMultiFilesValue = mainProperties.getProperty(includeMultiFilesKey);
            if (StringUtils.isNotBlank(includeMultiFilesValue)) {
                //获取配置文件
                String[] propertiesNames = includeMultiFilesValue.split(",");
                for (String propertiesName : propertiesNames) {
                    //获取key和value
                    makeProperties(propertiesName);
                }
            }
        }
    }

    /**
     * 重新加载配置
     *
     * @param configName
     * @return void
     * @author commuli
     * @date 2019/4/23
     */
    public void loadConfig(String configName) {
        if (StringUtils.isEmpty(configName)) {
            return;
        }
        makeProperties(configName);
    }

    /**
     * 加载多配置信息
     *
     * @param configName
     * @return void
     * @author commuli
     * @date 2019/4/23
     */
    private void makeProperties(String configName) {
        File fileConfig = new File(configPath, configName);
        if (fileConfig.exists()) {
            Properties properties = file2Property(fileConfig);
            if (properties != null) {
                //将主配置缓存
                put(configName, properties);
            }
        }
    }

    /**
     * 获取文件中的配置
     *
     * @param file
     * @return java.util.Properties
     * @author commuli
     * @date 2019/4/23
     */
    private Properties file2Property(File file) {
        final Properties prop = new Properties();
        try (InputStreamReader input = new InputStreamReader(new FileInputStream(file), "utf-8")) {
            prop.load(input);
        } catch (IOException e) {
            LOG.error("file io exception ", e);
//            System.exit(0);
            return null;
        }
        return prop;
    }

    /**
     * 存值
     *
     * @param key
     * @param obj
     * @return void
     * @author commuli
     * @date 2019/1/21
     */
    public void put(String key, Properties obj) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        propertiesMap.put(key, obj);
    }

    /**
     * 删值
     *
     * @param key
     * @return Properties
     * @author commuli
     * @date 2019/1/21
     */
    public void remove(String key) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        propertiesMap.remove(key);

    }


    /**
     * 获取值
     *
     * @param key
     * @return Properties
     * @author commuli
     * @date 2019/1/21
     */
    public Properties get(String key) {
        if (StringUtils.isEmpty(key)) {
            return null;
        }
        return propertiesMap.get(key);
    }

    /**
     * 清空配置文件
     *
     * @param
     * @return void
     * @author commuli
     * @date 2019/4/23
     */
    public void clear() {
        propertiesMap.clear();
    }

    /**
     * 包含值
     *
     * @param key
     * @return boolean
     * @author commuli
     * @date 2019/1/21
     */
    public boolean containsKey(String key) {
        return propertiesMap.containsKey(key);
    }

    /**
     * 获取配置文件个数
     *
     * @param
     * @return int
     * @author commuli
     * @date 2019/4/23
     */
    public int size() {
        return propertiesMap.size();
    }

    /**
     * 获取所有配置缓存
     *
     * @param
     * @return java.util.List<java.util.Properties>
     * @author commuli
     * @date 2019/4/23
     */
    public List<Properties> getAllProperties() {
        List<Properties> lists = new ArrayList<>();
        if (propertiesMap.isEmpty()) {
            return lists;
        }
        Iterator<Map.Entry<String, Properties>> iterator = propertiesMap.entrySet().iterator();
        while (iterator.hasNext()) {
            lists.add(iterator.next().getValue());
        }
        return lists;
    }


}