这个问题在面试中间经常会被问到，别看这两个名字很像，但是是完全不同的两个东西。
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"/>
