Spring中的BeanFactory和FactoryBean的差別

1、 BeanFactory

    BeanFactory定義了 IOC 容器的最基本形式，并提供了 IOC 容器應遵守的的最基本的接口，也就是Spring IOC 所遵守的最底層和最基本的程式設計規範。在  Spring 代碼中， BeanFactory 隻是個接口，并不是 IOC容器的具體實作，但是 Spring 容器給出了很多種實作，如 DefaultListableBeanFactory 、 XmlBeanFactory 、ApplicationContext 等，都是附加了某種功能的實作。

Java代碼  

1. package org.springframework.beans.factory;  
2. import org.springframework.beans.BeansException;  
3. public interface BeanFactory {  
4.     String FACTORY_BEAN_PREFIX = "&";  
5.     Object getBean(String name) throws BeansException;  
6.     <T> T getBean(String name, Class<T> requiredType) throws BeansException;  
7.     <T> T getBean(Class<T> requiredType) throws BeansException;  
8.     Object getBean(String name, Object... args) throws BeansException;  
9.     boolean containsBean(String name);  
10.     boolean isSingleton(String name) throws NoSuchBeanDefinitionException;  
11.     boolean isPrototype(String name) throws NoSuchBeanDefinitionException;  
12.     boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;  
13.     Class<?> getType(String name) throws NoSuchBeanDefinitionException;  
14.     String[] getAliases(String name);  
15. }   

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.     public   void  setCarInfo ( String carInfo )   {  
24.         this . carInfo  = carInfo;  
25.     }  
26. }   

有了這個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是個 Factory ，也就是 IOC 容器或對象工廠， FactoryBean 是個 Bean 。在 Spring 中，所有的 Bean 都是由 BeanFactory( 也就是 IOC 容器 ) 來進行管理的。但對 FactoryBean 而言，這個 Bean 不是簡單的 Bean ，而是一個能生産或者修飾對象生成的工廠 Bean, 它的實作與設計模式中的工廠模式和修飾器模式類似。