BeanFactory 和 FactoryBean 的区别

这个问题在面试中间经常会被问到，别看这两个名字很像，但是是完全不同的两个东西。

BeanFactory

BeanFactory 以 factory 结尾，所以是个工厂类（接口），是生产管理 bean 的工厂。在Spring中，BeanFactory 是 IOC 容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。BeanFactory 只是个接口，并不是 IOC 容器的具体实现，但是 Spring 容器给出了很多种实现，如
DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext 等，其中 XmlBeanFactory 就是常用的一个，该实现将以 XML 方式描述组成应用的对象及对象间的依赖关系。XmlBeanFactory 类将持有此 XML 配置元数据，并用它来构建一个完全可配置的系统或应用。

DefaultListableBeanFactory,XmlBeanFactory,ApplicationContext 等具体的容器都是实现了 BeanFactory，再在其基础之上附加了其他的功能。

BeanFactory 和 ApplicationContext 就是spring框架的两个 IOC 容器，现在一般使用ApplicationnContext，其不但包含了 BeanFactory 的作用，同时还进行更多的扩展。

BeanFacotry 是 spring 中比较原始的 Factory。如 XMLBeanFactory 就是一种典型的 BeanFactory。
原始的 BeanFactory 无法支持 spring 的许多插件，如 AOP 功能、Web 应用等。 ApplicationContext 接口,它由 BeanFactory 接口派生而来，

ApplicationContext 包含 BeanFactory 的所有功能，通常建议比 BeanFactory 优先

ApplicationContext 以一种更向面向框架的方式工作以及对上下文进行分层和实现继承，ApplicationContext 包还提供了以下的功能：
• MessageSource, 提供国际化的消息访问
• 资源访问，如 URL 和文件
• 事件传播
• 载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的 web 层;

在不使用 spring 框架之前，我们的 service 层中要使用 dao 层的对象，不得不在 service 层中 new 一个对象。存在的问题：层与层之间的依赖。

service 层要用 dao 层对象需要配置到 xml 配置文件中，至于对象是怎么创建的，关系是怎么组合的都交给了 spring 框架去实现。

下面是 BeanFactory 接口具体实现：

package org.springframework.beans.factory;  
import org.springframework.beans.BeansException;  
public interface BeanFactory {  
    String FACTORY_BEAN_PREFIX = "&";  
    Object getBean(String name) throws BeansException;  
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;  
    <T> T getBean(Class<T> requiredType) throws BeansException;  
    Object getBean(String name, Object... args) throws BeansException;  
    boolean containsBean(String name);  
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;  
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;  
    boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;  
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;  
    String[] getAliases(String name);  
}  

-boolean containsBean(String beanName) 判断工厂中是否包含给定名称的 bean 定义，若有则返回 true；

-Object getBean(String) 返回给定名称注册的 bean 实例。根据bean的配置情况，如果是 singleton 模式将返回一个共享实例，否则将返回一个新建的实例，如果没有找到指定 bean,该方法可能会抛出异常；

-Object getBean(String, Class) 返回以给定名称注册的 bean 实例，并转换为给定 class 类型；

-Class getType(String name) 返回给定名称的 bean 的 Class,如果没有找到指定的 bean 实例，则排除 NoSuchBeanDefinitionException 异常；

-boolean isSingleton(String) 判断给定名称的 bean 定义是否为单例模式；

-String[] getAliases(String name) 返回给定 bean 名称的所有别名。

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> 的形式

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

源码具体实现：

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

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

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

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

当配置文件中 <bean> 的 class 属性配置的实现类是 FactoryBean 时，通过 getBean() 方法返回的不是 FactoryBean 本身，而是 FactoryBean#getObject() 方法所返回的对象，相当于 FactoryBean#getObject() 代理了 getBean() 方法。
例：如果使用传统方式配置下面 Car 的 <bean> 时，Car 的每个属性分别对应一个 <property> 元素标签。

package  com.theodore.factorybean;  
    public   class  Car  {  
        private   int maxSpeed ;  
        private  String brand ;  
        private   double price ;  
        public   int  getMaxSpeed ()   {  
            return   this . maxSpeed ;  
        }  
        public   void  setMaxSpeed ( int  maxSpeed )   {  
            this . maxSpeed  = maxSpeed;  
        }  
        public  String getBrand ()   {  
            return   this . brand ;  
        }  
        public   void  setBrand ( String brand )   {  
            this . brand  = brand;  
        }  
        public   double  getPrice ()   {  
            return   this . price ;  
        }  
        public   void  setPrice ( double  price )   {  
            this . price  = price;  
       }  
}   

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

package  com.theodore.factorybean;  
import  org.springframework.beans.factory.FactoryBean;  
public   class  CarFactoryBean  implements  FactoryBean<Car>  {  
    private  String carInfo ;  
    public  Car getObject ()   throws  Exception  {  
        Car car =  new  Car () ;  
        String []  infos =  carInfo .split ( "," ) ;  
        car.setBrand ( infos [ 0 ]) ;  
        car.setMaxSpeed ( Integer. valueOf ( infos [ 1 ])) ;  
        car.setPrice ( Double. valueOf ( infos [ 2 ])) ;  
        return  car;  
    }  
    public  Class<Car> getObjectType ()   {  
        return  Car. class ;  
    }  
    public   boolean  isSingleton ()   {  
        return   false ;  
    }  
    public  String getCarInfo ()   {  
        return   this . carInfo ;  
    }  
  
    // 接受逗号分割符设置属性信息  
    public   void  setCarInfo ( String carInfo )   {  
        this . carInfo  = carInfo;  
    }  
}   

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

<bean d="car"class="com.theodore.factorybean.CarFactoryBean"
P:carInfo="阿斯顿马丁,500,5000000"/>