怎么用Factory Bean讓Spring配置動起來

這篇文章主要介紹“怎么用Factory Bean讓Spring配置動起來”，在日常操作中，相信很多人在怎么用Factory Bean讓Spring配置動起來問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”怎么用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. }   

15. 
    

然后在 spring 中如此聲明

1. ＜bean id="dataSource" class="BasicDataSourceFactoryBean "＞  

2. ... 你的配置來源  

3. ＜/bean＞  

到此，關于“怎么用Factory Bean讓Spring配置動起來”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！