區別：BeanFactory是個Factory，也就是IOC容器或物件工廠，FactoryBean是個Bean。在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)來進行管理的。但對FactoryBean而言，這個Bean不是簡單的Bean，而是一個能生產或者修飾物件生成的工廠Bean,它的實現與設計模式中的工廠模式和修飾器模式類似

1、 BeanFactory

    BeanFactory定義了IOC容器的最基本形式，並提供了IOC容器應遵守的的最基本的介面，也就是Spring IOC所遵守的最底層和最基本的程式設計規範。在Spring程式碼中，BeanFactory

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的細節，給上層應用帶來了便利。從Spring3.0開始，FactoryBean開始支援泛型，即介面宣告改為FactoryBean<T>的形式

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

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. }   

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. }   

3、區別
BeanFactory是個Factory，也就是IOC容器或物件工廠，FactoryBean是個Bean。在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)來進行管理的。但對FactoryBean而言，這個Bean不是簡單的Bean，而是一個能生產或者修飾物件生成的工廠Bean,它的實現與設計模式中的工廠模式和修飾器模式類似。