spring中bean，factorybean与beanfactory

1 普通Bean的创建

    spring 中的普通bean的创建是通过读取配置文件，将所有配置文件信息保存到beandefinition中，在使用getbean的时候通过反射创建实例，然后再将属性值填充。

 

1.1  普通bean的注入方式

 

 1)   使用构造器注入

 

Java代码  

1. <span style="font-size: 16px;"><bean id="person" class="framework.spring.test.Person">  
2.     <constructor-arg index="0" value="1"/>  
3.     <constructor-arg index="1" value="name"/>  
4. </bean>  
5. </span>  

 

2)   使用setter方法注入

 

给属性添加set方法注入的时候使用如下方式：

 

Java代码  

1. <span style="font-size: 16px;"><bean id="user" class="framework.spring.test.User">  
2.     <property name="id" value="1"/>  
3.     <property name="name" value="name"/>  
4.     <property name="person" ref="person"/>  
5. </bean>  
6. </span>  

 3)   使用注解方式注入

 

Java代码  

1. <span style="font-size: 16px;">@Autowired  
2.   
3. private Person person;</span>  

 

注解可以加在属性上，也可以加在set方法上

2、 FactoryBean

    一般情况下，Spring 通过反射机制利用 <bean> 的 class 属性指定实现类实例化 Bean ，在某些情况下，实例化 Bean 过程比较复杂，如果按照传统的方式，则需要在 <bean> 中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。 Spring 为此提供了一个org.springframework.bean.factory.FactoryBean 的工厂类接口，用户可以通过实现该接口定制实例化 Bean 的逻辑。

FactoryBean接口对于 Spring 框架来说占用重要的地位， Spring 自身就提供了 70 多个 FactoryBean 的实现。它们隐藏了实例化一些复杂 Bean 的细节，给上层应用带来了便利。从 Spring 3.0 开始， FactoryBean 开始支持泛型，即接口声明改为 FactoryBean<T> 的形式：

Java代码  

1. package org.springframework.beans.factory;  
2. public interface FactoryBean<T> {  
3.     T getObject() throws Exception;  
4.     Class<?> getObjectType();  
5.     boolean isSingleton();  
6. }   

 

在该接口中还定义了以下3 个方法：

T getObject()：返回由 FactoryBean 创建的 Bean 实例，如果 isSingleton() 返回 true ，则该实例会放到Spring 容器中单实例缓存池中；

boolean isSingleton()：返回由 FactoryBean 创建的 Bean 实例的作用域是 singleton 还是 prototype ；

Class<T> getObjectType()：返回 FactoryBean 创建的 Bean 类型。

当配置文件中<bean> 的 class 属性配置的实现类是 FactoryBean 时，通过 getBean() 方法返回的不是FactoryBean 本身，而是 FactoryBean#getObject() 方法所返回的对象，相当于 FactoryBean#getObject() 代理了getBean() 方法。

例：如果使用传统方式配置下面Car 的 <bean> 时， Car 的每个属性分别对应一个 <property> 元素标签。

Java代码  

1. package  com.baobaotao.factorybean;  
2.     public   class  Car  {  
3.         private   int maxSpeed ;  
4.         private  String brand ;  
5.         private   double price ;  
6.         public   int  getMaxSpeed ()   {  
7.             return   this . maxSpeed ;  
8.         }  
9.         public   void  setMaxSpeed ( int  maxSpeed )   {  
10.             this . maxSpeed  = maxSpeed;  
11.         }  
12.         public  String getBrand ()   {  
13.             return   this . brand ;  
14.         }  
15.         public   void  setBrand ( String brand )   {  
16.             this . brand  = brand;  
17.         }  
18.         public   double  getPrice ()   {  
19.             return   this . price ;  
20.         }  
21.         public   void  setPrice ( double  price )   {  
22.             this . price  = price;  
23.        }  
24. }   

 

如果用FactoryBean 的方式实现就灵活点，下例通过逗号分割符的方式一次性的为 Car 的所有属性指定配置值：

Java代码  

1. package  com.baobaotao.factorybean;  
2. import  org.springframework.beans.factory.FactoryBean;  
3. public   class  CarFactoryBean  implements  FactoryBean<Car>  {  
4.     private  String carInfo ;  
5.     public  Car getObject ()   throws  Exception  {  
6.         Car car =  new  Car () ;  
7.         String []  infos =  carInfo .split ( "," ) ;  
8.         car.setBrand ( infos [ 0 ]) ;  
9.         car.setMaxSpeed ( Integer. valueOf ( infos [ 1 ])) ;  
10.         car.setPrice ( Double. valueOf ( infos [ 2 ])) ;  
11.         return  car;  
12.     }  
13.     public  Class<Car> getObjectType ()   {  
14.         return  Car. class ;  
15.     }  
16.     public   boolean  isSingleton ()   {  
17.         return   false ;  
18.     }  
19.     public  String getCarInfo ()   {  
20.         return   this . carInfo ;  
21.     }  
22.   
23.     // 接受逗号分割符设置属性信息  
24.     public   void  setCarInfo ( String carInfo )   {  
25.         this . carInfo  = carInfo;  
26.     }  
27. }   

 

有了这个CarFactoryBean 后，就可以在配置文件中使用下面这种自定义的配置方式配置 Car Bean 了：

<bean id="car" class="com.baobaotao.factorybean.CarFactoryBean" 

    P:carInfo="法拉利 ,400,2000000"/>

当调用getBean("car") 时， Spring 通过反射机制发现 CarFactoryBean 实现了 FactoryBean 的接口，这时Spring 容器就调用接口方法 CarFactoryBean#getObject() 方法返回。如果希望获取 CarFactoryBean 的实例，则需要在使用 getBean(beanName) 方法时在 beanName 前显示的加上 "&" 前缀：如 getBean("&car");

3、BeanFactory与FactoryBean的区别

BeanFactory是个Factory，也就是IOC容器或对象工厂，FactoryBean是个Bean。在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。但对FactoryBean而言，这个Bean不是简单的Bean，而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似。