spring3中使用@value注解获取属性值

  在spring 3.0中，可以通过使用@value，对一些如xxx.properties文件中的文件，进行键值对的注入，例子如下：

1.首先在applicationContext.xml中加入： 

Xml代码  

1. <beans xmlns="http://www.springframework.org/schema/beans"  
2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3.         xsi:schemaLocation="http://www.springframework.org/schema/beans   
4.          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  

 的命名空间，然后

2.

Xml代码  

1. <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">    
2.     <property name="locations">    
3.         <list>    
4.             <value>classpath:test.properties</value>    
5.         </list>                
6.     </property>                                
7. </bean>  

3.创建test.properties 
   abc=123 

4.

Java代码  

1. import org.springframework.beans.factory.annotation.Value;     
2. import org.springframework.stereotype.Controller;     
3. import org.springframework.web.bind.annotation.RequestMapping;     
4.     
5. @RequestMapping("/admin/images")     
6. @Controller     
7. public class ImageAdminController {     
8.     
9.     private String imageDir;     
10.       
11.     @Value("${abc}")   
12.     public void setImageDir(String val) {     
13.         this.imageDir = val;     
14.     }  
15. }  

        这样就将test.abc的值注入了imageDir中了。

 

资料来源： http://jackyrong.iteye.com/blog/1330946

 

有时候需要从properties文件中加载配置，以前的方式是这样的：

 

	<bean id="jdbcProperties" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath*:/spring/jdbc.properties</value>
			</list>
		</property>
	</bean>

最近发现这样也可以，代码更整洁：

 

	<context:property-placeholder location="classpath:spring/jdbc.properties" />

在bean定义中依然可以通过“${}”这种方式来去值：

 

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<property name="initialSize" value="${jdbc.initialSize}" />
		<property name="maxActive" value="${jdbc.maxActive}" />
		<property name="maxIdle" value="${jdbc.maxIdle}" />
		<property name="minIdle" value="${jdbc.minIdle}" />
	</bean>

<context:property-placeholder ... /> is the XML equivalent to the PropertyPlaceholderConfigurer. So, prefer that. The <util:properties/> simply factories a java.util.Properties instance that you can inject.

In Spring 3.1 (not 3.0...) you can do something like this:

@Configuration
@PropertySource("/foo/bar/services.properties")
public class ServiceConfiguration { 

    @Autowired Environment environment; 

    @Bean public javax.sql.DataSource dataSource( ){ 
        String user = this.environment.getProperty("ds.user");
        ...
    } 
}

In Spring 3.0, you can "access" properties defined using the PropertyPlaceHolderConfigurer mechanism using the SpEl annotations:

@Value("${ds.user}") private String user;

If you want to remove the XML all together, simply register the PropertyPlaceholderConfigurer manually using Java configuration. I prefer the 3.1 approach. But, if youre using the Spring 3.0 approach (since 3.1's not GA yet...), you can now define the above XML like this:

@Configuration 
public class MySpring3Configuration {     
        @Bean 
        public static PropertyPlaceholderConfigurer configurer() { 
             PropertyPlaceholderConfigurer ppc = ...
             ppc.setLocations(...);
             return ppc; 
        } 

        @Bean 
        public class DataSource dataSource(
                @Value("${ds.user}") String user, 
                @Value("${ds.pw}") String pw, 
                ...) { 
            DataSource ds = ...
            ds.setUser(user);
            ds.setPassword(pw);                        
            ...
            return ds;
        }
}

Note that the PPC is defined using a static bean definition method. This is required to make sure the bean is registered early, because the PPC is a BeanFactoryPostProcessor - it can influence the registration of the beans themselves in the context, so it necessarily has to be registered before everything else.