org.kaizen4j.common.property.PropertyConfigurer Maven / Gradle / Ivy

Go to download
package org.kaizen4j.common.property;

import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import org.apache.commons.io.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URISyntaxException;
import java.text.MessageFormat;
import java.util.Collection;
import java.util.Map;
import java.util.Properties;

import static org.kaizen4j.common.base.Symbols.SLASH;

/**
 * 属性配置加载类，在初始化时将读取类路径下所有属性文件的值
 *
 * @author John
 * @since 1.8
 */
public final class PropertyConfigurer {

    private static final Logger logger = LoggerFactory.getLogger(PropertyConfigurer.class);

    /**
     * 保存键值对的不可变集合 Map
     */
    private static final ImmutableMap propertiesMap = initialize();

    private PropertyConfigurer() {}

    /**
     * 获取配置文件中的 String 类型的值
     *
     * @param name 属性名称
     * @return 属性值
     *
     * @throws NullPointerException
     */
    public static String stringValue(String name) {
        String value = propertiesMap.get(name);
        Preconditions.checkNotNull(value, "Property name: [" + name + "] not has mapping value");
        return value;
    }

    /**
     * 获取配置文件中的 String 类型的值，并以指定参数填充。
     *
     * @param name 属性名称
     * @param params 填充参数数组
     * @return 以参数填充后的属性值
     *
     * @throws NullPointerException
     */
    public static String stringValue(String name, Object[] params) {
        String value = stringValue(name);
        return MessageFormat.format(value, params);
    }

    /**
     * 获取配置文件中的 Integer 类型的值
     *
     * @param name 属性名称
     * @return 属性值
     */
    public static int intValue(String name) {
        return Integer.valueOf(stringValue(name)).intValue();
    }

    /**
     * 获取配置文件中的 Double 类型的值
     *
     * @param name 属性名称
     * @return 属性值
     */
    public static double doubleValue(String name) {
        return Double.valueOf(stringValue(name)).doubleValue();
    }

    /**
     * 获取配置文件中的 Boolean 类型的值
     *
     * @param name 属性名称
     * @return 属性值
     */
    public static boolean booleanValue(String name) {
        return Boolean.valueOf(stringValue(name)).booleanValue();
    }

    /**
     * 类被加载器初始化时，将扫描类路径下的所有属性文件，并将文件中包含的键值对读入内存中。
     *
     * @return 包含键值对的不可变集合 Map
     *
     * @throws URISyntaxException
     * @throws IOException
     * @throws IllegalArgumentException
     */
    private static ImmutableMap initialize() {
        final Map defaultsMap = Maps.newHashMap();

        try {
            File rootPath = new File(PropertyConfigurer.class.getResource(SLASH).toURI());
            Collection propertyFiles = FileUtils.listFiles(rootPath, new String[] {"properties"}, true);

            for (File file : propertyFiles) {
                Properties properties = new Properties();

                properties.load(new FileInputStream(file));
                logger.info("Loaded property file [{}]", file.getAbsoluteFile());

                properties.stringPropertyNames().forEach(name -> {
                    if (defaultsMap.containsKey(name)) {
                        throw new IllegalArgumentException("Property file contains duplicate key [" + name + "]");
                    }
                    defaultsMap.put(name, properties.getProperty(name));
                });
            }

            return ImmutableMap.builder().putAll(defaultsMap).build();
        } catch (URISyntaxException | IOException e) {
            logger.error("Load property file failed", e);
            throw new RuntimeException(e);
        }
    }

}