利用Java註解特性加載屬性文件(properties)的值到Java類

在此之前我都是寫個PropertyUtil類來加載配置文件,然後通過get方法,把key對應的值取出來.

Spring提供一個PropertyPlaceholderConfigurer類,可以讀取配置文件,然後在Spring配置文件通過${hibernate.dialect}這種方式注入到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. packagecom.test.annotation;
3. importjava.lang.reflect.Method;
5. importorg.springframework.beans.BeansException;
6. importorg.springframework.beans.factory.InitializingBean;
7. importorg.springframework.beans.factory.config.BeanPostProcessor;
8. importorg.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
9. importorg.springframework.util.ReflectionUtils;
11. publicclassAnnotationBeanPostProcessorextendsPropertyPlaceholderConfigurerimplementsBeanPostProcessor,InitializingBean{
13. privatejava.util.Propertiespros;
15. @Override
16. publicObjectpostProcessAfterInitialization(Objectbean,StringbeanName)
17. throwsBeansException{
18. //TODOAuto-generatedmethodstub
19. returnbean;
20. }
22. @Override
23. publicObjectpostProcessBeforeInitialization(Objectbean,StringbeanName)
24. throwsBeansException{
25. if(bean.getClass().getAnnotation(Property.class)!=null){
26. Method[]methods=bean.getClass().getDeclaredMethods();
27. for(Methodmethod:methods){
28. Propertyp=method.getAnnotation(Property.class);
29. if(p!=null){
30. //這裏進行參數類型轉換
31. Objectpara=pros.getProperty(p.name());
32. if((method.getParameterTypes()[0]).getName().equals("java.lang.Integer")){
33. para=newInteger(para.toString());
34. }
35. ReflectionUtils.invokeMethod(method,bean,newObject[]{para});
36. }
37. }
38. }
39. returnbean;
40. }
42. @Override
43. publicvoidafterPropertiesSet()throwsException{
44. pros=mergeProperties();
46. }
48. }

1. packagecom.test.annotation;
3. importjava.lang.annotation.Retention;
4. importjava.lang.annotation.RetentionPolicy;
5. importjava.lang.annotation.Target;
6. importjava.lang.annotation.ElementType;
8. @Retention(RetentionPolicy.RUNTIME)
9. @Target({ElementType.TYPE,ElementType.METHOD})
10. public@interfaceProperty{
11. Stringname()default"";
13. }

1. packagecom.test;
3. importcom.test.annotation.Property;
4. @Property
5. publicclassBean{
6. privateStringname;
7. privateIntegerage;
8. privateStringaddress;
10. publicStringgetName(){
11. returnname;
12. }
13. publicvoidsetName(Stringname){
14. this.name=name;
15. }
17. publicStringgetAddress(){
18. returnaddress;
19. }
20. @Property(name="com.test.Bean.address")
21. publicvoidsetAddress(Stringaddress){
22. this.address=address;
23. }
24. publicIntegergetAge(){
25. returnage;
26. }
27. @Property(name="com.test.Bean.age")
28. publicvoidsetAge(Integerage){
29. this.age=age;
30. }
32. }

1. packagecom.test;
3. importcom.test.annotation.Property;
5. @Property
6. publicclassJavaBean{
9. privateStringname;
11. privateStringaddress;
14. publicStringgetName(){
15. returnname;
16. }
17. @Property(name="com.test.JavaBean.name")
18. publicvoidsetName(Stringname){
19. this.name=name;
20. }
22. publicStringgetAddress(){
23. returnaddress;
24. }
25. publicvoidsetAddress(Stringaddress){
26. this.address=address;
27. }
29. }

1. packagecom.test;
3. importorg.springframework.context.ApplicationContext;
4. importorg.springframework.context.support.ClassPathXmlApplicationContext;
7. publicclassTest{
9. /**
10. *@paramargs
11. */
12. publicstaticvoidmain(String[]args){
14. ApplicationContextcontext=
15. newClassPathXmlApplicationContext("spring.xml");
16. System.out.println("加載配置文件結束");
17. System.out.println("--------------------------------------------");
18. JavaBeanjavaBean=(JavaBean)context.getBean("javaBean");
19. System.out.println(javaBean.getName());
20. System.out.println(javaBean.getAddress());
21. System.out.println("--------------------------------------------");
22. Beanbean=(Bean)context.getBean("bean");
23. System.out.println(bean.getName());
24. System.out.println(bean.getAddress());
25. System.out.println(bean.getAge());
26. System.out.println("--------------------------------------------");
28. }
30. }

1. <?xmlversion="1.0"encoding="UTF-8"?>
2. <!DOCTYPEbeansPUBLIC"-//SPRING//DTDBEAN//EN""http://www.springframework.org/dtd/spring-beans.dtd">
3. <beans>
4. <beanid="propertyConfigurer"class="com.test.annotation.AnnotationBeanPostProcessor">
5. <propertyname="locations">
6. <list>
7. <value>classpath*:system.properties</value>
8. </list>
9. </property>
10. </bean>
11. <beanid="javaBean"class="com.test.JavaBean">
12. <propertyname="address"value="${com.test.JavaBean.address}"></property>
13. </bean>
14. <beanid="bean"class="com.test.Bean">
15. <propertyname="name"value="${com.test.Bean.name}"></property>
16. </bean>
17. </beans>

ps:之所以要繼承PropertyPlaceholderConfigurer類,還有一個原因就是,原來通過${}注入值的方式還可以用

BeanPostProcessor有兩個方法,爲什麼要寫在postProcessBeforeInitialization裏面,而不是postProcessAfterInitialization裏面,原因在於postProcessBeforeInitialization方法是在Bean的init方法之前執行,在init方法裏面可能會用到類的屬性,所以必須在init方法執行之前先賦值好.