怎么用FactoryBean让Spring配置动起来

这篇文章主要介绍“怎么用Factory Bean让Spring配置动起来”，在日常操作中，相信很多人在怎么用Factory Bean让Spring配置动起来问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”怎么用Factory Bean让Spring配置动起来”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

创新互联是一家专注于成都网站制作、网站建设与策划设计,正安网站建设哪家好?创新互联做网站,专注于网站建设十多年,网设计领域的专业建站公司;建站业务涵盖:正安等地区。正安做网站价格咨询:18982081108

不少朋友讨论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＞  

到此，关于“怎么用Factory Bean让Spring配置动起来”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注创新互联网站，小编会继续努力为大家带来更多实用的文章！