利用Java注解特性加载属性文件(properties)的值到Java类

在此之前我都是写个PropertyUtil类来加载配置文件,然后通过get方法,把key对应的值取出来.

Spring提供一个PropertyPlaceholderConfigurer类,可以读取配置文件,然后在Spring配置文件通过${}这种方式注入到JavaBean中,有个不好的地方就是,要在代码中取的时候不是很方便.

然后在接触到Java注解特注解技术以后,感觉这个东东很好,hibernate映射,WebService都可以通过注解来完成,方便的很多,然后就在想能不能通过Java注解特性加载属性文件(properties)的值到Java类里面呢?

其实上面一篇写在Spring中JavaBean的初始化顺序就是为现在写这个做准备的,要实现现在说的这个功能,大体方案有如下:

1.定义一个注解类

2.在需要加载属性的JavaBean的属性set方法上写注解,注解的参数就是key

3.在Spring启动的时候,去读取属性文件,然后把值赋给JavaBean

 

我们在上一篇写在Spring中JavaBean的初始化顺序提到了,如果一个JavaBean实现了BeanPostProcessor接口,那么其他Bean初始化以后都会交给这个Bean来处理.这样我们就可以写一个JavaBean实现BeanPostProcessor接口,这个Bean有个属性,它指向属性文件路径,在这个Bean初始化的时候读取属性文件内容,然后在postProcessBeforeInitialization方法里面对写了注解的Bean进行赋值.这样一个实现思路似乎很顺其自然,都是自己觉得不是很好,Spring通过PropertyPlaceholderConfigurer这样类来加载属性文件,而我们有写了另外一个类,这样一是不够统一,二是不够可能会造成多个属性文件.解决办法就是扩展PropertyPlaceholderConfigurer类.写一个类继承PropertyPlaceholderConfigurer类.然后在PropertyPlaceholderConfigurer初始化完成以后,获取加载的属性文件内容,在postProcessBeforeInitialization里面把写过注解的类属性进行赋值.那么怎么确定什么时候PropertyPlaceholderConfigurer加载完成呢,根据Spring中JavaBean的初始化顺序,我们知道一个JavaBean如果实现了InitializingBean接口,那么Spring容器会在这个Bean初始化以后调用afterPropertiesSet方法,现在我写个类继承PropertyPlaceholderConfigurer类,实现BeanPostProcessor, InitializingBean 这个两个接口那么刚刚提到的问题就可以解决了,下面是实现代码

 

1. package ;
3. import ;
5. import ;
6. import ;
7. import ;
8. import ;
9. import ;
11. public class AnnotationBeanPostProcessor extends PropertyPlaceholderConfigurer implements BeanPostProcessor, InitializingBean  {
13.      private  pros;   
15.     @Override
16.     public Object postProcessAfterInitialization(Object bean, String beanName)
17.             throws BeansException {
18.         // TODO Auto-generated method stub
19.         return bean;
20.     }
22.     @Override
23.     public Object postProcessBeforeInitialization(Object bean, String beanName)
24.             throws BeansException {
25.         if(().getAnnotation(Property.class)!=null){
26.             Method[] methods = ().getDeclaredMethods(); 
27.             for (Method method : methods) {   
28.                 Property p = (Property.class);
29.                 if(p!=null){
30. //                  这里进行参数类型转换
31.                     Object para=(());
32.                     if((()[0]).getName().equals("")){
33.                         para= new Integer(());
34.                     }
35.                     (method, bean, new Object[]{para});
36.                 }
37.             }   
38.         }
39.         return bean;
40.     }
42.     @Override
43.     public void afterPropertiesSet() throws Exception {
44.         pros = mergeProperties();   
45.         
46.     }
48. }

1. package ;
3. import ;
4. import ;
5. import ;
6. import ;
8. @Retention()
9. @Target({, })
10. public @interface Property {
11.     String name() default "";
12.     
13. }

1. package ;
3. import ;
4. @Property
5. public class Bean {
6.     private String name;
7.     private Integer age;
8.     private String address;
9.     
10.     public String getName() {
11.         return name;
12.     }
13.     public void setName(String name) {
14.         this.name = name;
15.     }
16.     
17.     public String getAddress() {
18.         return address;
19.     }
20.     @Property(name="")
21.     public void setAddress(String address) {
22.         this.address = address;
23.     }
24.     public Integer getAge() {
25.         return age;
26.     }
27.     @Property(name="")
28.     public void setAge(Integer age) {
29.         this.age = age;
30.     }
31.     
32. }

1. package ;
3. import ;
5. @Property
6. public class JavaBean {
7.     
8.     
9.     private String name;
10.     
11.     private String address;
12.     
13.     
14.     public String getName() {
15.         return name;
16.     }
17.     @Property(name="")
18.     public void setName(String name) {
19.         this.name = name;
20.     }
21.     
22.     public String getAddress() {
23.         return address;
24.     }
25.     public void setAddress(String address) {
26.         this.address = address;
27.     }
28.     
29. }

1. package ;
3. import ;
4. import ;
7. public class Test {
9.     /**
10.      * @param args
11.      */
12.     public static void main(String[] args) {
13.         
14.          ApplicationContext context =  
15.                 new ClassPathXmlApplicationContext(""); 
16.          ("加载配置文件结束");
17.          ("--------------------------------------------");
18.          JavaBean javaBean=(JavaBean)("javaBean");
19.          (());
20.          (());
21.          ("--------------------------------------------");
22.          Bean bean=(Bean)("bean");
23.          (());
24.          (());
25.          (());
26.          ("--------------------------------------------");
27.         
28.     }
30. }

1. <?xml version="1.0" encoding="UTF-8"?> 
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "/dtd/">
3. <beans>
4.     <bean id="propertyConfigurer" class="">
5.         <property name="locations">
6.             <list>
7.                 <value>classpath*:</value>
8.             </list>
9.         </property>
10.     </bean>
11.     <bean id="javaBean" class="">
12.         <property name="address" value="${}"></property>
13.     </bean>
14.     <bean id="bean" class="">
15.         <property name="name" value="${}"></property>
16.     </bean>
17. </beans>

ps:之所以要继承PropertyPlaceholderConfigurer类,还有一个原因就是,原来通过${}注入值的方式还可以用

BeanPostProcessor有两个方法,为什么要写在postProcessBeforeInitialization里面,而不是postProcessAfterInitialization里面,原因在于postProcessBeforeInitialization方法是在Bean的init方法之前执行,在init方法里面可能会用到类的属性,所以必须在init方法执行之前先赋值好.