用Factory Bean让Spring配置动起来

不少朋友讨论spring配置时认为spring配置中只能静态的设置一些参数(典型情况如数据库配置, 定时器配置等)导致不方便, 其实spring已经提供了非常便利的方式来实现动态spring配置, 我们要做的只是实现一个自己的 Factory Bean , 来看一下 Factory Bean 接口的定义

1. /**//**  
2. * Interface to be implemented by objects used within a BeanFactory  
3. * that are themselves factories. If a bean implements this interface,  
4. * it is used as a factory, not directly as a bean.  
5. *  
6. * ＜p＞＜b＞NB: A bean that implements this interface cannot be used  
7. * as a normal bean.＜/b＞ A FactoryBean is defined in a bean style,  
8. * but the object exposed for bean references is always the object  
9. * that it creates.   
10. * ＜p＞FactoryBeans can support singletons and prototypes, and can  
11. * either create objects lazily on demand or eagerly on startup.  
12. *  
13. * ＜p＞This interface is heavily used within the framework, for  
14. * example for the AOP ProxyFactoryBean or JndiObjectFactoryBean.  
15. * It can be used for application components, but this is not common  
16. * outside of infrastructure code.  
17. *  
18. * @author Rod Johnson  
19. * @author Juergen Hoeller  
20. * @since 08.03.2003  
21. * @see org.springframework.beans.factory.BeanFactory  
22. * @see org.springframework.aop.framework.ProxyFactoryBean  
23. * @see org.springframework.jndi.JndiObjectFactoryBean  
24. */  
25. public interface FactoryBean ...{    
26. 　/**//**  
27. 　* Return an instance (possibly shared or independent) of the object  
28. 　* managed by this factory. As with a BeanFactory, this allows  
29. 　* support for both the Singleton and Prototype design pattern.  
30. 　* ＜p＞If this method returns ＜code＞null＜/code＞, the factory will consider  
31. 　* the FactoryBean as not fully initialized and throw a corresponding  
32. 　* FactoryBeanNotInitializedException.  
33. 　* @return an instance of the bean (should not be ＜code＞null＜/code＞;  
34. 　* a ＜code＞null＜/code＞ value will be considered as an indication of  
35. 　* incomplete initialization)  
36. 　* @throws Exception in case of creation errors  
37. 　* @see FactoryBeanNotInitializedException  
38. 　*/  
39. 　Object getObject() throws Exception;    
40. 　/**//**  
41. 　* Return the type of object that this FactoryBean creates, or ＜code＞null＜/code＞  
42. 　* if not known in advance. This allows to check for specific types  
43. 　* of beans without instantiating objects, for example on autowiring.  
44. 　* ＜p＞For a singleton, this should try to avoid singleton creation  
45. 　* as far as possible; it should rather estimate the type in advance.  
46. 　* For prototypes, returning a meaningful type here is advisable too.  
47. 　* ＜p＞This method can be called ＜i＞before＜/i＞ this FactoryBean has  
48. 　* been fully initialized. It must not rely on state created during  
49. 　* initialization; of course, it can still use such state if available.  
50. 　* ＜p＞＜b＞NOTE:＜/b＞ Autowiring will simply ignore FactoryBeans that return  
51. 　* ＜code＞null＜/code＞ here. Therefore it is highly recommended to implement  
52. 　* this method properly, using the current state of the FactoryBean.  
53. 　* @return the type of object that this FactoryBean creates,  
54. 　* or ＜code＞null＜/code＞ if not known at the time of the call  
55. 　* @see ListableBeanFactory#getBeansOfType  
56. 　*/  
57. 　Class getObjectType();    
58. 　/**//**  
59. 　* Is the bean managed by this factory a singleton or a prototype?  
60. 　* That is, will ＜code＞getObject()＜/code＞ always return the same object  
61. 　* (a reference that can be cached)?  
62. 　* ＜p＞＜b＞NOTE:＜/b＞ If a FactoryBean indicates to hold a singleton object,  
63. 　* the object returned from ＜code＞getObject()＜/code＞ might get cached  
64. 　* by the owning BeanFactory. Hence, do not return ＜code＞true＜/code＞  
65. 　* unless the FactoryBean always exposes the same reference.  
66. 　* ＜p＞The singleton status of the FactoryBean itself will generally  
67. 　* be provided by the owning BeanFactory; usually, it has to be  
68. 　* defined as singleton there.  
69. 　* @return if this bean is a singleton  
70. 　* @see #getObject()  
71. 　*/  
72. 　boolean isSingleton();  
73. }  

看了以后发现, Factory Bean 用于在spring容器中创建其他的Bean, 我们平时用得最多的 JndiObjectFactory Bean, hibernate 的 LocalSessionFactory Bean 都是 Factory Bean 的具体实现, 既然如此, 读取动态配置就变得易如反掌了, 假如我们要实现动态读取数据库配置的功能, 拿使用率***的 BasicDatasource 为例, 简单的实现一个 BasicDatasource Factory Bean 如下即可

1. public class BasicDataSourceFactoryBean implements FactoryBean ...{    
2.   public Object getObject() throws Exception ...{　　  
3.    BasicDataSource dataSource = new BasicDataSource();  
4. 　　// 读取外部配置, 设置到 dataSource 中 ...    
5. 　　return dataSource;    
6. 　}    
7.     
8. 　public Class getObjectType() ...{    
9. 　　return BasicDataSource.class;   
10. 　}    
11. 　public boolean isSingleton() ...{   
12. 　　return true;   
13. 　}   
14. }   

然后在 spring 中如此声明

1. ＜bean id="dataSource" class="BasicDataSourceFactoryBean "＞  
2. ... 你的配置来源  
3. ＜/bean＞  

【编辑推荐】

1. Spring Batch 2.0的新特性
2. 简单介绍Spring osgi
3. Spring OSGi的整合
4. 在Spring中配置Glassfish JPA
5. 解决Spring2.0向spring2.5迁移的问题