`
玉德思密达
  • 浏览: 7812 次
社区版块
存档分类
最新评论

spring读properties

springproperty 
阅读更多

首先在配置文件中配置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);
    }

}

分享到：
| Spring Mvc模块化配置思考
评论
1 楼 futurep_p 2014-04-15  
CentralConfiguration 在哪整的
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring读取properties

    本文将深入解析如何在Spring环境中读取Properties文件，包括配置步骤、代码示例以及注意事项，帮助读者理解和掌握这一核心功能。 ### Spring读取Properties文件的核心知识点 #### 1. **引入...

    Spring 读取properties文件key+value方式.rar

    本教程将深入探讨如何在Spring中以不同的方式读取properties文件，以便更好地理解和应用这些配置。 首先，我们需要一个`application.properties`或`application.yml`文件，其中包含键值对。例如： ```properties ...

    读取properties文件返回map

    本篇将详细讲解如何在Java中读取`properties`文件并将其内容转换为`Map`对象。 1. **properties文件结构** `properties`文件的结构非常简单，每行代表一个键值对，键和值之间用等号`=`或冒号`:`分隔。例如： ``` ...

    Spring用代码来读取properties文件实例解析

    Spring读取Properties文件实例解析 Spring框架中，读取Properties文件是一个非常重要的步骤，Properties文件中存储着应用程序的配置信息，如数据库连接信息、Server配置信息等。在Spring应用程序中，我们可以使用@...

    spring无法读取properties文件数据问题详解

    Spring 无法读取 properties 文件数据问题详解 Spring 框架在读取 properties 文件数据时可能会遇到一些问题，本文将对这些问题进行详细的解释和解决。 问题一：Controller 中无法读取 properties 文件数据 在 ...

    spring中properties加密

    本文将深入探讨如何在Spring项目中实现properties文件的加密。 1. **理解Properties文件** Spring框架广泛使用`properties`文件来存储配置信息。这些文件通常是纯文本格式，容易被读取，从而增加了安全性风险。...

    详解spring boot 使用application.properties 进行外部配置

    使用application.properties 进行外部配置的 Spring Boot 知识点详解 Spring Boot 框架提供了多种方式来进行外部配置，今天我们将详细讲解使用 application.properties 文件来进行外部配置的方法。application....

    spring-demo09-读取properties配置文件内容.zip

    在`spring-demo09-读取properties配置文件内容`这个示例中，我们可能有一个名为`application.properties`或`config.properties`的文件，存放在项目的`src/main/resources`目录下。这个文件通常包含以下格式的键值对...

    sftp直接以url模式读取-----------包括servlet如何借用springproperties取文件

    标题 "sftp直接以url模式读取-----------包括servlet如何借用springproperties取文件" 提到的是在Java开发中，如何通过SFTP（Secure File Transfer Protocol）协议以URL模式读取远程文件，并结合SpringProperties来...

    spring读取jar中的配置文件

    当我们的应用程序被打包成JAR文件后，有时我们需要从JAR内部读取配置文件，例如application.properties或application.yml。本文将深入探讨如何在Spring框架中实现这一功能。 首先，理解Spring的资源配置。Spring...

    java读取properties配置文件

    本文将详细介绍如何在Java中读取`properties`配置文件。 首先，我们需要了解`properties`文件的格式。一个标准的`.properties`文件通常包含多个行，每行由一个键和一个值组成，它们之间用等号（`=`）或冒号（`:`）...

    谈谈Spring 注入properties文件总结

    这里，`@Value`注解直接在字段上，从properties文件中读取指定的属性值。 2. 使用`@ConfigurationProperties`注解： ```java @Configuration @ConfigurationProperties(prefix = "ds1.jdbc") public class ...

    spring读取配置文件

    本篇文章将深入探讨如何在Spring中读取不同目录下的配置文件，以及使用`ClassPathXmlApplicationContext`和`FileSystemXmlApplicationContext`这两种不同的上下文环境来加载它们。 首先，让我们了解`...

    SSM 读取properties文件

    在Spring框架中，读取properties文件主要通过两种方式：`PropertyPlaceholderConfigurer` 和 `@Value` 注解。 1. **PropertyPlaceholderConfigurer**： 这是一个Spring的bean定义类，它允许我们从properties文件中...

    JAVA读取properties文件的值

    本篇文章将详细探讨如何在Java中读取`properties`文件的值。 ### 1. `java.util.Properties` 类 Java提供了一个内置类 `java.util.Properties`，专门用于处理`.properties`文件。这个类继承了`HashTable`，并提供...

    java实现properties文件读取

    在Java代码中，我们首先创建一个`Properties`对象，它是读取Properties文件的核心工具。 ```java Properties prop = new Properties(); ``` 2. **加载Properties文件**： 使用`InputStream`来读取Properties...

    Spring Boot的properties配置文件读取

    总的来说，Spring Boot的properties配置文件读取过程是一个多层次、灵活且可扩展的机制。它不仅包含了将配置文件加载到Spring Environment中的功能，还提供了各种扩展点，允许用户根据自己的需求来定制配置加载的...

    Spring中Properties的配置方式

    Spring 中 Properties 的配置方式是指在 Spring 框架中使用 Properties 文件来存储和读取配置信息的方式。Properties 文件是一种简单的文本文件，用于存储应用程序的配置信息，例如数据库连接信息、服务器配置信息等...

    多种方式读取Properties代码示例

    本文将详细介绍多种读取Properties文件的方法，并提供相关的代码示例。 1. **使用Properties类加载文件** 最常用的方式是通过`java.util.Properties`类来读取`.properties`文件。以下是一个简单的示例： ```java ...

    读properties和事务demo

    标题 "读properties和事务demo" 描述的是一个Java应用程序示例，主要涵盖了两个核心主题：读取properties配置文件以及事务管理。在这个demo中，开发者展示了如何处理OSGi（Open Service Gateway Initiative）环境下...

Magicbox
Global site tag (gtag.js) - Google Analytics