配置bean的三种方式 及例子

Spring基础15——通过工厂方法来配置bean

1、什么是工厂方法

       这里的工厂方法指的是创建指定bean的方法。工厂方法又分为静态工厂方法和实例工厂方法。

2、静态工厂方法配置bean

       调用静态工厂方法创建Bean是将对象创建的过程封装到静态方法中，不需要创建工厂实例就可以返回工厂创建的对象，就叫做静态工厂，当客户端需要对象时，只需要简单的调用静态方法，而不需要关心创建对象的细节。要声明通过静态方法创建的Bean，需要在Bean的class属性指定拥有该工厂的方法的类，同时在factory-method属性里指定工厂方法的名称，最后使用<constrctor-arg>元素为该方法传递方法参数。

       首先创建一个提供静态工厂方法的类：

 1 public class StaticCarFactory {
 2     private static Map<String, Car> cars = new HashMap<String, Car>();
 3     static {
 4         cars.put("audi", new Car("audi", 300000));
 5         cars.put("ford", new Car("audi", 400000));
 6     }
 7     //静态工厂方法，根据名字获取car对象
 8     public static Car getCar(String name) {
 9         return cars.get(name);
10     }
11 }

 spring配置文件

1 <!--通过静态工厂方法来配置bean，注意不是配置静态工厂方法实例，而是配置bean实例-->
2 <!--
3     class属性：指向静态工厂的全类名
4     fatory-method：指向静态工厂方法的名字
5     constructor-arg:如果工厂方法需要传入参数，则使用constructor-arg来配置参数
6  -->
7 <bean id="car1" class="com.wzy.factory.StaticCarFactory" factory-method="getCar">
8     <constructor-arg name="name" value="audi"/>
9 </bean>

编写Main测试类

1 public class Main {
2     public static void main(String[] args) {
3         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");
4 
5         Car car1 = (Car) ctx.getBean("car1");
6 
7         System.out.println(car1);
8     }
9 }

输出结果：我们可以看到通过静态工厂成功创建了一个对象。

3、实例工厂方法配置bean

       使用实例工厂方法配置bean首先需要创建一个实例工厂的bean，通过调用实例工厂bean的非静态方法创建目标的bean对象，同时在factory-bean属性里指定工厂bean的id，最后使用<constrctor-arg>元素为该方法传递方法参数。

       首先创建一个实例工厂的bean：

 1 public class InstanceCarFactory {
 2     private Map<String, Car> cars = null;
 3 
 4     public InstanceCarFactory() {
 5         cars = new HashMap<String, Car>();
 6         cars.put("audi", new Car("audi", 300000));
 7         cars.put("ford", new Car("ford", 400000));
 8     }
 9 
10     public Car getCar(String name){
11         return cars.get(name);
12     }
13 
14 }

配置Spring配置文件

 1 <!--实例工厂的实例-->
 2 <!--
 3     factory-bean：指向实例工厂方法的bean
 4     fatory-method：指向实例工厂方法的名字
 5     constructor-arg:如果工厂方法需要传入参数，则使用constructor-arg来配置参数
 6  -->
 7 <bean id="instanceCarFactory" class="com.wzy.factory.InstanceCarFactory"/>
 8 <!--通过实例工厂来配置bean-->
 9 <bean id="car2" factory-bean="instanceCarFactory" factory-method="getCar">
10     <constructor-arg name="name" value="ford"/>
11 </bean>

修改Main测试类：

1 public class Main {
2     public static void main(String[] args) {
3         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");
4         
5         Car car2 = (Car) ctx.getBean("car2");
6 
7         System.out.println(car2);
8     }
9 }

输出结果：

 

Spring基础16——使用FactoryBean来创建

1.配置bean的方式

配置bean有三种方式：通过全类名（class反射）、通过工厂方法（静态工厂&实例工厂）、通过FactoryBean。前面我们已经一起学习过全类名方式和工厂方法方式，下面通过这篇文章来学习一下FactroyBean.

2.FactoryBean配置bean

FactoryBean是Spring给我们提供的一个接口，我们来看一下这个接口的源码：

 1 public interface FactoryBean<T> {
 2     @Nullable
 3     T getObject() throws Exception;
 4 
 5     @Nullable
 6     Class<?> getObjectType();
 7 
 8     default boolean isSingleton() {
 9         return true;
10     }
11 }

这个接口中为我们提供了三个方法：

getObject()：返回bean本身

getObjectType()：返回FactoryBean创建Bean的类型。 

isSingleton()：返回bean是否是单例的

我们有全类名配置，也有工厂方法配置，为什么我们还要用这种FactoryBean来配置Bean呢？因为我们在配置一个bean的时候需要用到另一个bean的时候，使用FactoryBean在合适不过了
下面来具体操作一下：

首先我们创建一个Car的FactoryBean去实现FactoryBean接口：

 1 public class CarFactoryBean implements FactoryBean {
 2     private String brand;
 3 
 4     public void setBrand(String brand) {
 5         this.brand = brand;
 6     }
 7 
 8     @Nullable
 9     public Object getObject() throws Exception {
10         return new Car("BMW", 5000000);
11     }
12 
13     @Nullable
14     public Class<?> getObjectType() {
15         return Car.class;
16     }
17 
18     public boolean isSingleton() {
19         return true;
20     }
21 }

Spring配置文件：

1 <!--通过factorybean来配置bean的实例，通过class来指向factorybean的全类名，property指的factory的属性-->
2 <!--，但实际返回的的是，getObject方法返回的实例。-->
3 <!--我们在配置bean的时候经常需要用的ioc容器里的其他bean，在factorybean中处理你传入的其他bean以达到目的-->
4 <bean id="car1" class="com.wzy.factorybean.CarFactoryBean">
5     <property name="brand" value="audi"/>
6 </bean>

编写Main测试类：

1 public class Main {
2     public static void main(String[] args) {
3         ApplicationContext ctx = new ClassPathXmlApplicationContext("bean-factorybean.xml");
4 
5         Car car1 = (Car) ctx.getBean("car1");
6 
7         System.out.println(car1);
8     }
9 }

输出结果：

3.FactoryBean总结

通过Factorybean来配置bean的实例，通过class来指向factorybean的全类名，property指的factory的属性，我们在配置bean的时候经常需要用的ioc容器里的其他bean，在factorybean中处理你传入的其他bean以达到目的。但实际返回的的是，getObject方法返回的实例。

 

Spring基础15——通过工厂方法来配置bean

1、什么是工厂方法

       这里的工厂方法指的是创建指定bean的方法。工厂方法又分为静态工厂方法和实例工厂方法。

2、静态工厂方法配置bean

       调用静态工厂方法创建Bean是将对象创建的过程封装到静态方法中，不需要创建工厂实例就可以返回工厂创建的对象，就叫做静态工厂，当客户端需要对象时，只需要简单的调用静态方法，而不需要关心创建对象的细节。要声明通过静态方法创建的Bean，需要在Bean的class属性指定拥有该工厂的方法的类，同时在factory-method属性里指定工厂方法的名称，最后使用<constrctor-arg>元素为该方法传递方法参数。

       首先创建一个提供静态工厂方法的类：

 1 public class StaticCarFactory {
 2     private static Map<String, Car> cars = new HashMap<String, Car>();
 3     static {
 4         cars.put("audi", new Car("audi", 300000));
 5         cars.put("ford", new Car("audi", 400000));
 6     }
 7     //静态工厂方法，根据名字获取car对象
 8     public static Car getCar(String name) {
 9         return cars.get(name);
10     }
11 }

 spring配置文件

1 <!--通过静态工厂方法来配置bean，注意不是配置静态工厂方法实例，而是配置bean实例-->
2 <!--
3     class属性：指向静态工厂的全类名
4     fatory-method：指向静态工厂方法的名字
5     constructor-arg:如果工厂方法需要传入参数，则使用constructor-arg来配置参数
6  -->
7 <bean id="car1" class="com.wzy.factory.StaticCarFactory" factory-method="getCar">
8     <constructor-arg name="name" value="audi"/>
9 </bean>

编写Main测试类

1 public class Main {
2     public static void main(String[] args) {
3         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");
4 
5         Car car1 = (Car) ctx.getBean("car1");
6 
7         System.out.println(car1);
8     }
9 }

输出结果：我们可以看到通过静态工厂成功创建了一个对象。

3、实例工厂方法配置bean

       使用实例工厂方法配置bean首先需要创建一个实例工厂的bean，通过调用实例工厂bean的非静态方法创建目标的bean对象，同时在factory-bean属性里指定工厂bean的id，最后使用<constrctor-arg>元素为该方法传递方法参数。

       首先创建一个实例工厂的bean：

 1 public class InstanceCarFactory {
 2     private Map<String, Car> cars = null;
 3 
 4     public InstanceCarFactory() {
 5         cars = new HashMap<String, Car>();
 6         cars.put("audi", new Car("audi", 300000));
 7         cars.put("ford", new Car("ford", 400000));
 8     }
 9 
10     public Car getCar(String name){
11         return cars.get(name);
12     }
13 
14 }

配置Spring配置文件

 1 <!--实例工厂的实例-->
 2 <!--
 3     factory-bean：指向实例工厂方法的bean
 4     fatory-method：指向实例工厂方法的名字
 5     constructor-arg:如果工厂方法需要传入参数，则使用constructor-arg来配置参数
 6  -->
 7 <bean id="instanceCarFactory" class="com.wzy.factory.InstanceCarFactory"/>
 8 <!--通过实例工厂来配置bean-->
 9 <bean id="car2" factory-bean="instanceCarFactory" factory-method="getCar">
10     <constructor-arg name="name" value="ford"/>
11 </bean>

修改Main测试类：

1 public class Main {
2     public static void main(String[] args) {
3         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");
4         
5         Car car2 = (Car) ctx.getBean("car2");
6 
7         System.out.println(car2);
8     }
9 }

输出结果：

 

 

FactoryBean的作用

2018年07月23日 14:24:16 liuhmmjj 阅读数 7318更多

分类专栏： Spring

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/u014082714/article/details/81166648

Spring 中有两种类型的Bean，一种是普通Bean，另一种是工厂Bean 即 FactoryBean。FactoryBean跟普通Bean不同，其返回的对象不是指定类的一个实例，而是该FactoryBean的getObject方法所返回的对象。创建出来的对象是否属于单例由isSingleton中的返回决定。

一般情况下，Spring通过反射机制利用<bean>的class属性指定实现类实例化Bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在<bean>中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。它们隐藏了实例化一些复杂Bean的细节，给上层应用带来了便利。从Spring3.0开始，FactoryBean开始支持泛型，即接口声明改为FactoryBean<T>的形式

以Bean结尾，表示它是一个Bean，不同于普通Bean的是：它是实现了FactoryBean<T>接口的Bean，根据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象，而不是FactoryBean本身，如果要获取FactoryBean对象，请在id前面加一个&符号来获取。

FactoryBean接口定义

1. package org.springframework.beans.factory;

2.  

3. public interface FactoryBean<T> {

4. T getObject() throws Exception;

5.  

6. Class<?> getObjectType();

7.  

8. boolean isSingleton();

9. }

应用场景

FactoryBean 通常是用来创建比较复杂的bean，一般的bean 直接用xml配置即可，但如果一个bean的创建过程中涉及到很多其他的bean 和复杂的逻辑，用xml配置比较困难，这时可以考虑用FactoryBean。

很多开源项目在集成Spring 时都使用到FactoryBean，比如 MyBatis3 提供 mybatis-spring项目中的 org.mybatis.spring.SqlSessionFactoryBean：

1. <!-- spring和MyBatis整合，不需要mybatis的配置映射文件 -->

2. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

3. <property name="dataSource" ref="dataSource"/>

4. <!-- 自动扫描mapping.xml文件 -->

5. <property name="mapperLocations" value="classpath:mapper/*.xml"></property>

6. </bean>

1. public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {

2. private static final Log LOGGER = LogFactory.getLog(SqlSessionFactoryBean.class);

3. ...

4. public SqlSessionFactory getObject() throws Exception {

5. if (this.sqlSessionFactory == null) {

6. this.afterPropertiesSet();

7. }

8.  

9. return this.sqlSessionFactory;

10. }

11. ...

12. }

 下面看一下具体的源码：

AbstractBeanFactory通过getBean向IoC容器获取被管理的Bean：

AbstractBeanFactory的getBean相关方法的源码如下：

1. protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {

2. final String beanName = this.transformedBeanName(name);

3. Object sharedInstance = this.getSingleton(beanName);

4. Object bean;

5. if (sharedInstance != null && args == null) {

6. if (this.logger.isDebugEnabled()) {

7. if (this.isSingletonCurrentlyInCreation(beanName)) {

8. this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");

9. } else {

10. this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");

11. }

12. }

13.  

14. bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);

15. } else {

16. if (this.isPrototypeCurrentlyInCreation(beanName)) {

17. throw new BeanCurrentlyInCreationException(beanName);

18. }

19.  

20. BeanFactory parentBeanFactory = this.getParentBeanFactory();

21. if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {

22. String nameToLookup = this.originalBeanName(name);

23. if (args != null) {

24. return parentBeanFactory.getBean(nameToLookup, args);

25. }

26.  

27. return parentBeanFactory.getBean(nameToLookup, requiredType);

28. }

29.  

30. if (!typeCheckOnly) {

31. this.markBeanAsCreated(beanName);

32. }

33.  

34. try {

35. final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);

36. this.checkMergedBeanDefinition(mbd, beanName, args);

37. String[] dependsOn = mbd.getDependsOn();

38. String[] var11;

39. if (dependsOn != null) {

40. var11 = dependsOn;

41. int var12 = dependsOn.length;

42.  

43. for(int var13 = 0; var13 < var12; ++var13) {

44. String dependsOnBean = var11[var13];

45. if (this.isDependent(beanName, dependsOnBean)) {

46. throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");

47. }

48.  

49. this.registerDependentBean(dependsOnBean, beanName);

50. this.getBean(dependsOnBean);

51. }

52. }

53.  

54. if (mbd.isSingleton()) {

55. sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {

56. public Object getObject() throws BeansException {

57. try {

58. return AbstractBeanFactory.this.createBean(beanName, mbd, args);

59. } catch (BeansException var2) {

60. AbstractBeanFactory.this.destroySingleton(beanName);

61. throw var2;

62. }

63. }

64. });

65. bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

66. } else if (mbd.isPrototype()) {

67. var11 = null;

68.  

69. Object prototypeInstance;

70. try {

71. this.beforePrototypeCreation(beanName);

72. prototypeInstance = this.createBean(beanName, mbd, args);

73. } finally {

74. this.afterPrototypeCreation(beanName);

75. }

76.  

77. bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

78. } else {

79. String scopeName = mbd.getScope();

80. Scope scope = (Scope)this.scopes.get(scopeName);

81. if (scope == null) {

82. throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");

83. }

84.  

85. try {

86. Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {

87. public Object getObject() throws BeansException {

88. AbstractBeanFactory.this.beforePrototypeCreation(beanName);

89.  

90. Object var1;

91. try {

92. var1 = AbstractBeanFactory.this.createBean(beanName, mbd, args);

93. } finally {

94. AbstractBeanFactory.this.afterPrototypeCreation(beanName);

95. }

96.  

97. return var1;

98. }

99. });

100. bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);

101. } catch (IllegalStateException var21) {

102. throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton", var21);

103. }

104. }

105. } catch (BeansException var23) {

106. this.cleanupAfterBeanCreationFailure(beanName);

107. throw var23;

108. }

109. }

110.  

111. if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {

112. try {

113. return this.getTypeConverter().convertIfNecessary(bean, requiredType);

114. } catch (TypeMismatchException var22) {

115. if (this.logger.isDebugEnabled()) {

116. this.logger.debug("Failed to convert bean '" + name + "' to required type [" + ClassUtils.getQualifiedName(requiredType) + "]", var22);

117. }

118.  

119. throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

120. }

121. } else {

122. return bean;

123. }

124. }

 我们可以看到，无论是直接取单例的bean，还是创建单例、多例、自定义生命周期的bean，都会经过bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);这个方法，我们现在就来看看这里到底是做了什么。

1. protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

2. if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {

3. throw new BeanIsNotAFactoryException(this.transformedBeanName(name), beanInstance.getClass());

4. } else if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {

5. Object object = null;

6. if (mbd == null) {

7. object = this.getCachedObjectForFactoryBean(beanName);

8. }

9.  

10. if (object == null) {

11. FactoryBean<?> factory = (FactoryBean)beanInstance;

12. if (mbd == null && this.containsBeanDefinition(beanName)) {

13. mbd = this.getMergedLocalBeanDefinition(beanName);

14. }

15.  

16. boolean synthetic = mbd != null && mbd.isSynthetic();

17. object = this.getObjectFromFactoryBean(factory, beanName, !synthetic);

18. }

19.  

20. return object;

21. } else {

22. return beanInstance;

23. }

24. }

这里有必要单独说一下解引用：

Dereference(解引用)：一个在C/C++中应用的比较多术语，在C++中，“*”是解引用符号，“&”是引用符号。

解引用：变量所指向的是所引用对象的本身数据，而不是对象的内存地址。

上面的代码可以看到，对于大多数bean的getBean，一般走到第二步就返回了，也就是说我们创建的Bean对象就是想要的bean，但对于FactoryBean的创建，如果是对内存地址的引用，那么取到的是它生产的bean，而不是它本身。所以我们继续看怎么取到生产的对象的：

FactoryBeanRegistrySupport类的getObjectFromFactoryBean方法

1. protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {

2. if (factory.isSingleton() && this.containsSingleton(beanName)) {

3. synchronized(this.getSingletonMutex()) {

4. Object object = this.factoryBeanObjectCache.get(beanName);

5. if (object == null) {

6. object = this.doGetObjectFromFactoryBean(factory, beanName);

7. Object alreadyThere = this.factoryBeanObjectCache.get(beanName);

8. if (alreadyThere != null) {

9. object = alreadyThere;

10. } else {

11. if (object != null && shouldPostProcess) {

12. try {

13. object = this.postProcessObjectFromFactoryBean(object, beanName);

14. } catch (Throwable var9) {

15. throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", var9);

16. }

17. }

18.  

19. this.factoryBeanObjectCache.put(beanName, object != null ? object : NULL_OBJECT);

20. }

21. }

22.  

23. return object != NULL_OBJECT ? object : null;

24. }

25. } else {

26. Object object = this.doGetObjectFromFactoryBean(factory, beanName);

27. if (object != null && shouldPostProcess) {

28. try {

29. object = this.postProcessObjectFromFactoryBean(object, beanName);

30. } catch (Throwable var11) {

31. throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", var11);

32. }

33. }

34.  

35. return object;

36. }

37. }

doGetObjectFromFactoryBean：

1. private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, String beanName) throws BeanCreationException {

2. Object object;

3. try {

4. if (System.getSecurityManager() != null) {

5. AccessControlContext acc = this.getAccessControlContext();

6.  

7. try {

8. object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {

9. public Object run() throws Exception {

10. return factory.getObject();

11. }

12. }, acc);

13. } catch (PrivilegedActionException var6) {

14. throw var6.getException();

15. }

16. } else {

17. object = factory.getObject();

18. }

19. } catch (FactoryBeanNotInitializedException var7) {

20. throw new BeanCurrentlyInCreationException(beanName, var7.toString());

21. } catch (Throwable var8) {

22. throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", var8);

23. }

24.  

25. if (object == null && this.isSingletonCurrentlyInCreation(beanName)) {

26. throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");

27. } else {

28. return object;

29. }

30. }

第一个方法就是区分单例还是多例，第二个方法是真真的调用getObject的方法获得FactoryBean生产的对象。从代码中可以看到，具体产生Bean的地方时这个getObject方法，Spring为这个FactoryBean提供了70多个实现，比如Poxy、JDNI、RMI等等。