`

spring 加载配置文件 xml 和properties

    博客分类：
  • SSIH
 
阅读更多
Spring配置文件是集成了Spring框架的项目的核心，引擎从哪里开始，中间都执行了哪些操作，小谈一下它的执行流程。

加载xml情况
容器先是加载web.xml

接着是applicationContext.xml在web.xml里的注册

一种方法是加入ContextLoaderServlet这个servlet

1 <context-param> 
2         <param-name>contextConfigLocation</param-name> 
3         <param-value>/WEB-INF/applicationContext.xml</param-value> 
4     </context-param> 
5      <servlet> 
6         <servlet-name>context</servlet-name> 
7         <servlet-class> 
8             org.springframework.web.context.ContextLoaderServlet  
9         </servlet-class> 
10         <load-on-startup>0</load-on-startup> 
11     </servlet> 
复制代码


还有一种是添加ContextLoaderListener这个监听器


1 <context-param> 
2     <param-name>contextConfigLocation</param-name> 
3     <param-value>/WEB-INF/applicationContext.xml</param-value> 
4 </context-param> 
5  
6 <listener> 
7     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
8 </listener> 


ContextLoaderServlet和ContextLoaderListener都是先创建ContextLoader的一个对象，然后调用它的initWebApplicationContex方法初始化WebApplicationContext获得一个对象；


spring加载多个配置文件，在web.xml中

1 <context-param>
2         <param-name>contextConfigLocation</param-name>
3         <param-value>classpath*:spring/*.xml</param-value>
4 </context-param>
5
6 <servlet>
7         <servlet-name>SpringContextServlet</servlet-name>
8         <servlet-class>
9             org.springframework.web.context.ContextLoaderServlet
10         </servlet-class>
11         <load-on-startup>3</load-on-startup>
12 </servlet>

加载Properties

一个系统中通常会存在如下一些以Properties形式存在的配置文件
1.数据库配置文件demo-db.properties：
Properties代码  收藏代码
database.url=jdbc:mysql://localhost/smaple 
database.driver=com.mysql.jdbc.Driver 
database.user=root 
database.password=123 

2.消息服务配置文件demo-mq.properties:
Properties代码  收藏代码
#congfig of ActiveMQ 
mq.java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory 
mq.java.naming.provider.url=failover:(tcp://localhost:61616?soTimeout=30000&connectionTimeout=30000)?jms.useAsyncSend=true&timeout=30000 
mq.java.naming.security.principal= 
mq.java.naming.security.credentials= 
jms.MailNotifyQueue.consumer=5 

3.远程调用的配置文件demo-remote.properties：
Properties代码  收藏代码
remote.ip=localhost 
remote.port=16800 
remote.serviceName=test 

一、系统中需要加载多个Properties配置文件
应用场景：Properties配置文件不止一个，需要在系统启动时同时加载多个Properties文件。
配置方式：
Xml代码  收藏代码
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation=" 
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 
     
    <!-- 将多个配置文件读取到容器中，交给Spring管理 --> 
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
        <property name="locations"> 
           <list> 
              <!-- 这里支持多种寻址方式：classpath和file --> 
              <value>classpath:/opt/demo/config/demo-db.properties</value> 
              <!-- 推荐使用file的方式引入，这样可以将配置和代码分离 --> 
              <value>file:/opt/demo/config/demo-mq.properties</value> 
              <value>file:/opt/demo/config/demo-remote.properties</value> 
            </list> 
        </property> 
    </bean> 
     
    <!-- 使用MQ中的配置 --> 
    <bean id="MQJndiTemplate" class="org.springframework.jndi.JndiTemplate"> 
        <property name="environment"> 
            <props> 
                <prop key="java.naming.factory.initial">${mq.java.naming.factory.initial}</prop> 
                <prop key="java.naming.provider.url">${mq.java.naming.provider.url}</prop> 
                <prop key="java.naming.security.principal">${mq.java.naming.security.principal}</prop> 
                <prop key="java.naming.security.credentials">${mq.java.naming.security.credentials}</prop> 
                <prop key="userName">${mq.java.naming.security.principal}</prop> 
                <prop key="password">${mq.java.naming.security.credentials}</prop> 
            </props> 
        </property> 
    </bean> 
</beans> 
我们也可以将配置中的List抽取出来:

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation=" 
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 
     
    <!-- 将多个配置文件位置放到列表中 --> 
    <bean id="propertyResources" class="java.util.ArrayList"> 
        <constructor-arg> 
            <list> 
              <!-- 这里支持多种寻址方式：classpath和file --> 
              <value>classpath:/opt/demo/config/demo-db.properties</value> 
              <!-- 推荐使用file的方式引入，这样可以将配置和代码分离 --> 
              <value>file:/opt/demo/config/demo-mq.properties</value> 
              <value>file:/opt/demo/config/demo-remote.properties</value> 
            </list> 
        </constructor-arg> 
    </bean> 
     
    <!-- 将配置文件读取到容器中，交给Spring管理 --> 
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
        <property name="locations" ref="propertyResources" /> 
    </bean> 
     
    <!-- 使用MQ中的配置 --> 
    <bean id="MQJndiTemplate" class="org.springframework.jndi.JndiTemplate"> 
        <property name="environment"> 
            <props> 
                <prop key="java.naming.factory.initial">${mq.java.naming.factory.initial}</prop> 
                <prop key="java.naming.provider.url">${mq.java.naming.provider.url}</prop> 
                <prop key="java.naming.security.principal">${mq.java.naming.security.principal}</prop> 
                <prop key="java.naming.security.credentials">${mq.java.naming.security.credentials}</prop> 
                <prop key="userName">${mq.java.naming.security.principal}</prop> 
                <prop key="password">${mq.java.naming.security.credentials}</prop> 
            </props> 
        </property> 
    </bean> 
</beans> 

二、整合多工程下的多个分散的Properties
应用场景：工程组中有多个配置文件，但是这些配置文件在多个地方使用，所以需要分别加载。
配置如下：
Xml代码  收藏代码
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p" 
    xsi:schemaLocation=" 
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 
     
    <!-- 将DB属性配置文件位置放到列表中 --> 
    <bean id="dbResources" class="java.util.ArrayList"> 
        <constructor-arg> 
        <list> 
            <value>file:/opt/demo/config/demo-db.properties</value> 
        </list> 
        </constructor-arg> 
    </bean> 
 
    <!-- 将MQ属性配置文件位置放到列表中 --> 
    <bean id="mqResources" class="java.util.ArrayList"> 
        <constructor-arg> 
        <list> 
            <value>file:/opt/demo/config/demo-mq.properties</value> 
        </list> 
        </constructor-arg> 
    </bean> 
     
    <!-- 用Spring加载和管理DB属性配置文件 --> 
    <bean id="dbPropertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
        <property name="order" value="1" /> 
        <property name="ignoreUnresolvablePlaceholders" value="true" />  
        <property name="locations" ref="dbResources" /> 
    </bean> 
     
    <!-- 用Spring加载和管理MQ属性配置文件 --> 
    <bean id="mqPropertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
        <property name="order" value="2" /> 
        <property name="ignoreUnresolvablePlaceholders" value="true" />  
        <property name="locations" ref="mqResources" /> 
    </bean> 
     
    <!-- 使用DB中的配置属性 --> 
    <bean id="rmsDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"  
        p:driverClassName="${demo.db.driver}" p:url="${demo.db.url}" p:username="${demo.db.username}"  
        p:password="${demo.db.password}" pp:maxActive="${demo.db.maxactive}"p:maxWait="${demo.db.maxwait}"  
        p:poolPreparedStatements="true" p:defaultAutoCommit="false"> 
    </bean> 
     
    <!-- 使用MQ中的配置 --> 
    <bean id="MQJndiTemplate" class="org.springframework.jndi.JndiTemplate"> 
        <property name="environment"> 
            <props> 
                <prop key="java.naming.factory.initial">${mq.java.naming.factory.initial}</prop> 
                <prop key="java.naming.provider.url">${mq.java.naming.provider.url}</prop> 
                <prop key="java.naming.security.principal">${mq.java.naming.security.principal}</prop> 
                <prop key="java.naming.security.credentials">${mq.java.naming.security.credentials}</prop> 
                <prop key="userName">${mq.java.naming.security.principal}</prop> 
                <prop key="password">${mq.java.naming.security.credentials}</prop> 
            </props> 
        </property> 
    </bean> 
</beans> 
注意：其中order属性代表其加载顺序，而ignoreUnresolvablePlaceholders为是否忽略不可解析的 Placeholder，如配置了多个PropertyPlaceholderConfigurer，则需设置为true。这里一定需要按照这种方式设置这两个参数。

三、Bean中直接注入Properties配置文件中的值
应用场景：Bean中需要直接注入Properties配置文件中的值 。例如下面的代码中需要获取上述demo-remote.properties中的值：
Java代码  收藏代码
public class Client() { 
    private String ip; 
    private String port; 
    private String service; 
} 
配置如下：
Xml代码  收藏代码
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="<a href="http://www.springframework.org/schema/beans">http://www.springframework.org/schema/beans</a>" 
xmlns:xsi="<a href="http://www.w3.org/2001/XMLSchema-instance">http://www.w3.org/2001/XMLSchema-instance</a>" 
xmlns:util="<a href="http://www.springframework.org/schema/util">http://www.springframework.org/schema/util</a>" 
xsi:schemaLocation=" 
<a href="http://www.springframework.org/schema/beans">http://www.springframework.org/schema/beans</a> <a href="http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">http://www.springframework.org/schema/beans/spring-beans-3.0.xsd</a> 
<a href="http://www.springframework.org/schema/util">http://www.springframework.org/schema/util</a> <a href="http://www.springframework.org/schema/util/spring-util-3.0.xsd">http://www.springframework.org/schema/util/spring-util-3.0.xsd</a>"> 
  
<!-- 这种加载方式可以在代码中通过@Value注解进行注入,  
可以将配置整体赋给Properties类型的类变量，也可以取出其中的一项赋值给String类型的类变量 --> 
<!-- <util:properties/> 标签只能加载一个文件，当多个属性文件需要被加载的时候，可以使用多个该标签 --> 
<util:properties id="remoteSettings" location="file:/opt/demo/config/demo-remote.properties" />  
  
<!-- <util:properties/> 标签的实现类是PropertiesFactoryBean， 
直接使用该类的bean配置，设置其locations属性可以达到一个和上面一样加载多个配置文件的目的 --> 
<bean id="settings"  
   class="org.springframework.beans.factory.config.PropertiesFactoryBean"> 
   <property name="locations"> 
  <list> 
    <value>file:/opt/rms/config/rms-mq.properties</value> 
    <value>file:/opt/rms/config/rms-env.properties</value> 
  </list> 
   </property> 
</bean> 
</beans> 
Client类中使用Annotation如下：
Java代码  收藏代码
import org.springframework.beans.factory.annotation.Value; 
 
public class Client() { 
    @Value("#{remoteSettings['remote.ip']}") 
    private String ip; 
    @Value("#{remoteSettings['remote.port']}") 
    private String port; 
    @Value("#{remoteSettings['remote.serviceName']}") 
    private String service; 
} 

四、Bean中存在Properties类型的类变量
应用场景：当Bean中存在Properties类型的类变量需要以注入的方式初始化
1. 配置方式：我们可以用（三）中的配置方式，只是代码中注解修改如下
Java代码  收藏代码
import org.springframework.beans.factory.annotation.Value; 
import org.springframework.beans.factory.annotation.Autowired; 
 
public class Client() { 
    @Value("#{remoteSettings}") 
    private Properties remoteSettings; 
} 

2. 配置方式：也可以使用xml中声明Bean并且注入
Xml代码  收藏代码
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation=" 
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 
     
    <!-- 可以使用如下的方式声明Properties类型的FactoryBean来加载配置文件，这种方式就只能当做Properties属性注入，而不能获其中具体的值 --> 
    <bean id="remoteConfigs" class="org.springframework.beans.factory.config.PropertiesFactoryBean"> 
        <property name="locations"> 
            <list> 
                <value>file:/opt/demo/config/demo-remote.properties</value> 
            </list> 
        </property> 
    </bean> 
     
    <!-- 远端调用客户端类 --> 
    <bean id="client" class="com.demo.remote.Client"> 
        <property name="properties" ref="remoteConfigs" /> 
    </bean> 
</beans> 
代码如下：
Java代码  收藏代码
import org.springframework.beans.factory.annotation.Autowired; 
 
public class Client() { 
    //@Autowired也可以使用 
    private Properties remoteSettings; 
     
    //getter setter 
} 

上述的各个场景在项目群中特别有用，需要灵活的使用上述各种配置方式。
分享到：
| jboss web服务器
评论
发表评论

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

相关推荐

    Spring3.0 配置文件中加载Properties文件的小例子

    本篇将详细讲解如何在Spring 3.0的配置文件中加载Properties文件，以便在运行时动态获取和使用这些配置。 首先，我们需要一个Properties文件，例如`application.properties`，它通常放在项目的类路径根目录下。这个...

    项目配置文件( spring-mvc.xml spring-mybatis.xml web.xml log4j.properties)

    这里提到的四个关键配置文件——`spring-mvc.xml`、`spring-mybatis.xml`、`web.xml`以及`log4j.properties`，对于一个基于Java的Web应用来说至关重要，特别是使用Spring MVC和MyBatis框架的时候。接下来，我们将...

    spring加载多个配置文件

    总结来说，Spring支持灵活地加载多个配置文件，无论是XML、Java配置还是基于注解的配置，都能满足项目对不同模块和环境的配置需求。通过理解并熟练运用这些加载机制，开发者可以更好地组织和管理项目中的配置，提高...

    Spring动态加载配置文件

    在Spring框架中，动态加载配置文件是一项重要的...总的来说，Spring动态加载配置文件涉及到IoC容器、属性源、配置加载策略和刷新机制等多个方面。理解和掌握这些知识点，可以帮助我们构建更加灵活和适应性强的应用。

    spring读取配置文件

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

    详解Spring加载Properties配置文件的四种方式

    Spring加载Properties配置文件的四种方式 Spring框架提供了多种方式来加载Properties配置文件，以便于应用程序读取和使用配置信息。下面将详细介绍四种常见的加载Properties配置文件的方式。 方式一: 通过context:...

    Spring Boot多模块配置文件读取

    在Spring Boot应用中，多模块配置文件的读取是一个重要的实践，它有助于提高代码的可维护性和模块化。本文将详细探讨如何在Spring Boot的多模块项目中管理和使用不同的配置文件，以实现低耦合的设计。 首先，了解...

    详解SpringMVC加载配置Properties文件的几种方式

    这是最常用的方式，通过在Spring的配置文件（如`spring.xml`）中引入`context`命名空间，并使用`context:property-placeholder`标签来指定Properties文件的位置。 ```xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; ...

    Spring加载配置和读取多个Properties文件的讲解

    Spring加载配置和读取多个Properties文件的讲解 Spring是一款功能强大且广泛应用的Java框架，它提供了很多实用的功能和工具来帮助开发者快速构建强大且灵活的应用程序。其中一个非常重要的功能就是 Properties ...

    Spring配置文件集合

    4. `spring-mybatis.xml`: 这是Spring与Mybatis集成的配置文件，定义了数据源、SqlSessionFactory以及Mapper扫描器等，使得Spring能够管理Mybatis的生命周期，并实现事务的统一管理。 5. `spring-servlet.xml`: 这...

    加载properties配置文件的几种方法

    首先，在Spring的配置文件（如`applicationContext.xml`）中定义一个bean，然后指定properties文件的位置： ```xml &lt;bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"&gt; ...

    SPRING：bean配置properties

    `PropertyPlaceholderConfigurer`允许我们在Spring的配置文件中引用外部的properties文件，以实现配置信息的灵活管理和动态加载。以下是一个基本的配置示例： ```xml class="org.springframework.beans.factory....

    spring读取jar中的配置文件

    Spring支持多种方式加载配置，包括XML、Java配置类和属性文件。在处理JAR内的配置文件时，通常会使用`@PropertySource`注解来指示Spring从特定资源加载属性。例如： ```java @Configuration @PropertySource(...

    Java 加载配置文件的方式

    在Java编程中，加载配置文件是一项常见的任务，它允许我们动态地设置应用的参数和环境，而无需修改代码。配置文件通常以.properties或.xml格式存储，包含键值对或者结构化数据，使得程序可以根据不同环境或者用户...

    Spring Boot技术知识点：如何读取不同路径里的applicationContext.xml配置文件1

    在Spring Boot应用中，我们通常使用YAML或properties文件来管理配置，但有时也需要与传统的XML配置文件集成，特别是当我们需要处理遗留系统或是利用Spring的一些特定功能时。本篇文章将详细探讨如何在Spring Boot...

    Spring 3.1配置文件示例（备忘）

    首先，`applicationContext.xml` 是 Spring 容器的配置文件，它定义了容器中 Bean 的实例化、装配和管理规则。在 Spring 3.1 中，XML 配置仍然是主流，尽管有基于注解的配置方式逐渐流行。Bean 的定义通常包括 ID...

    spring读取properties

    在Spring框架中，读取和使用...在Spring的配置文件中，首先需要定义一个`PropertyPlaceholderConfigurer` bean，这是Spring用来解析Properties文件并将其值注入到其他bean中的关键组件。如示例所示： ```xml ...

    详解利用Spring加载Properties配置文件

    在本文中，我们将深入探讨如何利用Spring加载Properties配置文件，并了解两种主要的方法：`PropertiesFactoryBean` 和 `PreferencesPlaceholderConfigurer`。 首先，我们需要创建一个Properties配置文件，例如`jdbc...

    spring mvc 读取配置文件

    前者从类路径下加载配置文件，后者则从文件系统中加载。例如，创建一个上下文实例： ```java ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); ``` 在Java配置中，...

    spring boot中配置mybatis热加载相关文件

    创建一个配置类，继承`org.springframework.boot/autoconfigure/mybatis/MybatisAutoConfiguration`，然后重写`mapperLocations`方法，引入上面配置文件中的路径，以实现XML文件的热加载。例如： ```java @...

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