spring读properties

首先在配置文件中配置PropertyPlaceholderConfigurer

单个配置文件：
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
  <property name="locations" value="classpath:jdbc.properties"/> 
</bean> 
多个配置文件：
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="locations">
    <list>           
        <value>classpath:jdbc.properties</value>
        <value>classpath:config.properties</value>
   </list>
</property>
</bean>

 

package xxx.common.config;

import java.util.Properties;

import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;

/**
 * 功能描述：全局配置的placeholder
 * @author winker
 * time : 2012-10-21 下午01:12:04
 */
public class GlobalConfigPropertyPlaceholderConfigurer extends PropertyPlaceholderConfigurer {

    @Override
    protected String resolvePlaceholder(String placeholder, Properties props) {
        String result = GlobalConfig.getString(placeholder);
        if (result == null) {
            return super.resolvePlaceholder(placeholder, props);
        } else {
            return result;
        }
    }

}

 

 

package xxx.common.config;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;

import org.apache.commons.configuration.CombinedConfiguration;
import org.apache.commons.configuration.Configuration;
import org.apache.commons.configuration.ConfigurationConverter;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.FileConfiguration;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.apache.commons.configuration.SystemConfiguration;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 功能描述：获得全局的配置
 *
 * @author winker time : 2012-10-25
 */
public class GlobalConfig {
    private static Logger logger = LoggerFactory.getLogger(GlobalConfig.class);

    private static CombinedConfiguration globalConfig;
    private static GlobalConfig _self = new GlobalConfig();

    private final static String APP_CONFIG_FILE_NAME = "application.properties";
    private final static String PROPERTY_FILE_EXTENSION = "properties";
    private final static String DEFAULT_CONFIG_DIR = "/opt/config";

    private boolean hasError = false;
    private String errMsg = "GlobalConfig is not initialized";
    private final String FS = File.separator;

    public GlobalConfig() {
        // //////////////////////////////////载入应用配置////////////////////////////////////
        InputStream appConfigInputStream = GlobalConfig.class
                .getResourceAsStream("/" + APP_CONFIG_FILE_NAME);
        Properties appProperties = new Properties();

        if (appConfigInputStream == null) {
            hasError = true;
            errMsg = "can't find application.properties in classpath";
            return;
        }
        try {
            appProperties.load(appConfigInputStream);
        } catch (IOException e) {
            hasError = true;
            errMsg = e.getMessage();
            logger.error(e.getMessage(), e);
            return;
        }

        String configPath = appProperties.getProperty("CONFIG_PATH");
        String appCode = appProperties.getProperty("APPLICATION_CODE");
        // 检查参数
        if (!hasError && StringUtils.isBlank(appCode)) {
            hasError = true;
            errMsg = "APP_CODE can't be empty";
            return;
        }

        // 指定目录
        String configDir = System.getProperty("config.dir");
        if (StringUtils.isBlank(configDir)) {
            logger.info("not assign ${config.dir}");
            configDir = DEFAULT_CONFIG_DIR;
            logger.info("finding configFile in " + configDir);
            if (!new File(configDir).exists()) {
                logger.info(configDir + " is not exist ");
                configDir = System.getProperty("user.home") + "/autoconfig";
                logger.info("finding configFile in " + configDir);
                if (!new File(configDir).exists()) {
                    if (!new File(configDir).mkdir()) {
                        logger.info(configDir + " is not exist ");
                        hasError = true;
                        errMsg = "not found any config dir ["
                                + DEFAULT_CONFIG_DIR + ","
                                + System.getProperty("user.home")
                                + "/autoconfig" + "]";
                        return;
                    }
                }
            }
        }

        // 没找到全局配置，创建默认值
        if (!hasError && globalConfig == null) {
            logger.info("create default configration");
            globalConfig = new CombinedConfiguration();
            globalConfig.addConfiguration(new SystemConfiguration());
        }

        // //////////////////////////////////集中配置////////////////////////////////////
        loadCentralConfig(configPath, appCode);

        // //////////////////////////////////属性文件////////////////////////////////////
        loadFromFile(configPath, appCode, configDir);

        if (hasError) {
            logger.error("GlobalConfig init failed . " + errMsg);
            return;
        }

        doAfter(configPath, appCode, configDir);
        logger.info("GlobalConfig init complete . ");

    }

    private void loadCentralConfig(String configPath, String appCode) {
       
        String serviceUrl = System.getProperty("config.central.url");
        if (!hasError && StringUtils.isNotBlank(serviceUrl)) {
            String stage = System.getProperty("config.stage");
            if (StringUtils.isBlank(stage)) {
                hasError = true;
                errMsg = "central configuration init failed , ${config.stage} can't be empty ";
                return;
            }
            try {
                CentralConfiguration centralConfiguration = new CentralConfiguration(
                        serviceUrl, stage, configPath, appCode);
                globalConfig.addConfiguration(centralConfiguration);
            } catch (Exception e) {
                hasError = true;
                errMsg = "central configuration load failed ," + e.getMessage();
                logger.error(
                        "central configuration load failed ," + e.getMessage(),
                        e);
                return;
            }

        }
    }

    private void loadFromFile(String configPath, String appCode,
            String configDir) {
      
        if (!hasError) {
            // 配置根目录
            File configDirFile = new File(configDir);

            // 查找ZF号目录
            if (StringUtils.isNotBlank(appCode)) {
                File zfdir = new File(configDirFile, appCode);
                if (zfdir.exists() && zfdir.isDirectory()) {
                    loadPropertiesFromDir(zfdir);
                }
            }

            // 查找config号目录
            if (StringUtils.isNotBlank(configPath)) {
                File configCodeDir = new File(configDirFile, configPath);
                if (configCodeDir.exists() && configCodeDir.isDirectory()) {
                    loadPropertiesFromDir(configCodeDir);
                }
            }
        }
    }

    private void doAfter(String configPath, String appCode, String configDir) {
        // //////////////////////////////////检查被覆盖的属性////////////////////////////////////
        List<Configuration> existConfigurations = new ArrayList<Configuration>();
        for (int i = 0; i < globalConfig.getNumberOfConfigurations(); i++) {
            Configuration configuration = globalConfig.getConfiguration(i);
            checkOverwrite(configuration, existConfigurations);
            existConfigurations.add(configuration);
        }
        if (globalConfig.getNumberOfConfigurations() == 1
                && globalConfig.getConfiguration(0) instanceof SystemConfiguration) {
            StringBuilder sb = new StringBuilder();

            String findDir = configDir;
            findDir = new File(findDir).getAbsolutePath();
            sb.append("find in " + findDir + FS + appCode).append("\n");

            if (StringUtils.isNotBlank(configPath)) {
                sb.append("find in " + findDir + FS + configPath).append("\n");
            }

            logger.warn("not found any properties file and central config . \n"
                    + sb);
        }
    }

    private void loadPropertiesFromDir(File configDirFile) {
        if (configDirFile.exists() && configDirFile.isDirectory()) {
            // 查找属性文件,不查找子目录
            Collection<File> propertiesFiles = FileUtils.listFiles(
                    configDirFile, new String[] { PROPERTY_FILE_EXTENSION },
                    false);
            for (File file : propertiesFiles) {
                loadProperties(file);
            }
        } else {
            logger.warn("config.dir[{}] not exist",
                    configDirFile.getAbsolutePath());
        }
    }

    private static void checkOverwrite(Configuration configuration,
            List<Configuration> existConfigurations) {
        Iterator<String> keys = configuration.getKeys();
        while (keys.hasNext()) {
            String key = keys.next();
            Configuration existConfiguration = getExistConfiguration(key,
                    existConfigurations);
            if (existConfiguration != null) {
                StringBuilder sb = new StringBuilder();
                sb.append("Overwrite property[" + key + "][")
                        .append(getConfigurationTitle(configuration))
                        .append("]");
                sb.append(" overwrite by ").append("[")
                        .append(getConfigurationTitle(existConfiguration))
                        .append("]");
                logger.warn(sb.toString());
            }
        }
    }

    private static String getConfigurationTitle(Configuration configuration) {
        if (configuration instanceof FileConfiguration) {
            return ((FileConfiguration) configuration).getFile().getName();
        } else if (configuration instanceof SystemConfiguration) {
            return "System Properties";
        } else {
            return configuration.toString();
        }
    }

    private static Configuration getExistConfiguration(String key,
            List<Configuration> existConfigurations) {
        for (Configuration configuration : existConfigurations) {
            if (configuration.containsKey(key)) {
                return configuration;
            }
        }
        return null;
    }

    private void loadProperties(File propertiesFile) {
        try {
            // 检查是否已加载
            for (int i = 0; i < globalConfig.getNumberOfConfigurations(); i++) {
                Configuration configuration = globalConfig.getConfiguration(i);
                if (configuration instanceof FileConfiguration) {
                    File loadedFile = ((FileConfiguration) configuration)
                            .getFile();
                    if (loadedFile.equals(propertiesFile)) {
                        logger.warn("Skip already loaded File[{}]",
                                propertiesFile.getAbsolutePath());
                        return;
                    }
                }
            }
            logger.warn("load properties file {}",
                    propertiesFile.getAbsolutePath());
            globalConfig.addConfiguration(new PropertiesConfiguration(
                    propertiesFile));
        } catch (ConfigurationException e) {
            hasError = true;
            errMsg = e.getMessage();
            logger.error(e.getMessage(), e);
        }
    }

    private static void checkError() throws IllegalStateException {
        if (_self.hasError) {
            throw new IllegalStateException(_self.errMsg);
        }
    }

    @SuppressWarnings("unchecked")
    public static Iterator<String> getKeys() {
        checkError();
        return globalConfig.getKeys();
    }

    public Properties getProperties() {
        checkError();
        return ConfigurationConverter.getProperties(globalConfig);
    }

    public static boolean containsKey(String key) {
        checkError();
        return globalConfig.containsKey(key);
    }

    public static String getString(String key) {
        checkError();
        return globalConfig.getString(key);
    }

    public static Boolean getBoolean(String key) {
        checkError();
        return globalConfig.getBoolean(key, null);
    }

    public static Byte getByte(String key) {
        checkError();
        return globalConfig.getByte(key, null);
    }

    public static Short getShort(String key) {
        checkError();
        return globalConfig.getShort(key, null);
    }

    public static Integer getInt(String key) {
        checkError();
        return globalConfig.getInteger(key, null);
    }

    public static Long getLong(String key) {
        checkError();
        return globalConfig.getLong(key, null);
    }

    public static Float getFloat(String key) {
        checkError();
        return globalConfig.getFloat(key, null);
    }

    public static Double getDouble(String key) {
        checkError();
        return globalConfig.getDouble(key, null);
    }

    public static BigDecimal getBigDecimal(String key) {
        checkError();
        return globalConfig.getBigDecimal(key);
    }

    public BigInteger getBigInteger(String key) {
        checkError();
        return globalConfig.getBigInteger(key);
    }

}

评论

1 楼 futurep_p 2014-04-15  

CentralConfiguration 在哪整的