JavaBeanFactoryFactoryBean
**BeanFacotry**是Spring中比较原始的Factory。如XMLBeanFactory就是一种典型的BeanFactory。原始的BeanFactory无法支持Spring的许多插件，如AOP功能、Web应用等。
**ApplicationContext**接口，它由**BeanFactory**接口派生而来。ApplicationContext包含BeanFactory的所有功能，通常建议比BeanFactory优先。

BeanFactory和FactoryBean的区别

BeanFactory是接口，提供了OC容器最基本的形式，给具体的IOC容器的实现提供了规范，
FactoryBean也是接口，为IOC容器中Bean的实现提供了更加灵活的方式，FactoryBean在IOC容器的基础上给Bean的实现加上了一个简单工厂模式和装饰模式(如果想了解装饰模式参考：修饰者模式(装饰者模式，Decoration) 可以在getObject()方法中灵活配置。其实在Spring源码中有很多FactoryBean的实现类.
区别：BeanFactory是个Factory，也就是IOC容器或对象工厂，FactoryBean是个Bean。在Spring中，所有的Bean都是由**BeanFactory**(也就是IOC容器)来进行管理的。
但对**FactoryBean**而言，这个Bean不是简单的Bean，而是一个能生产或者修饰对象生成的工厂Bean，它的实现与设计模式中的工厂模式和修饰器模式类似

1、BeanFactory

BeanFactory，以Factory结尾，表示它是一个工厂类(接口)， 它负责生产和管理bean的一个工厂。在Spring中，**BeanFactory**是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
BeanFactory只是个接口，并不是IOC容器的具体实现，但是Spring容器给出了很多种实现，如 DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等，其中XmlBeanFactory就是常用的一个，该实现将以XML方式描述组成应用的对象及对象间的依赖关系。XmlBeanFactory类将持有此XML配置元数据，并用它来构建一个完全可配置的系统或应用。
都是附加了某种功能的实现。它为其他具体的IOC容器提供了最基本的规范，例如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框架去实现。
方式1、

  1. Resource resource = new FileSystemResource("beans.xml");
  2. BeanFactory factory = new XmlBeanFactory(resource);

方式2、

  1. ClassPathResource resource = new ClassPathResource("beans.xml");
  2. BeanFactory factory = new XmlBeanFactory(resource);

方式3、

  1. ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml", "applicationContext-part2.xml"});
  2. BeanFactory factory = (BeanFactory) context;

基本就是这些了，接着使用getBean(String beanName)方法就可以取得bean的实例；BeanFactory提供的方法及其简单，仅提供了六种方法供客户调用：

  • **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名称的所有别名

    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>**的形式
    以Bean结尾，表示它是一个Bean，不同于普通Bean的是：它是实现了FactoryBean<T>接口的Bean，根据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象，而不是FactoryBean本身，如果要获取FactoryBean对象，请在id前面加一个&符号来获取。
    例如自己实现一个FactoryBean，功能：用来代理一个对象，对该对象的所有方法做一个拦截，在调用前后都输出一行LOG，模仿ProxyFactoryBean的功能。 ```java /**

    • my factory bean

    • 代理一个类，拦截该类的所有方法，在方法的调用前后进行日志的输出 / public class MyFactoryBean implements FactoryBean, InitializingBean, DisposableBean {

      private static final Logger logger = LoggerFactory.getLogger(MyFactoryBean.class);
      private String interfaceName;
      private Object target;
      private Object proxyObj;
      @Override public void destroy() throws Exception {

      1. logger.debug("destroy......");

      } @Override public void afterPropertiesSet() throws Exception {

      1. proxyObj = Proxy.newProxyInstance(
      2.         this.getClass().getClassLoader(), 
      3.         new Class[] { Class.forName(interfaceName) }, 
      4.         new InvocationHandler() {                    
      5.     @Override
      6.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      7.         logger.debug("invoke method......" + method.getName());
      8.         logger.debug("invoke method before......" + System.currentTimeMillis());
      9.         Object result = method.invoke(target, args);
      10.         logger.debug("invoke method after......" + System.currentTimeMillis());
      11.         return result;            }            
      12. });
      13. logger.debug("afterPropertiesSet......");

      }

      @Override public Object getObject() throws Exception {

      1. logger.debug("getObject......");
      2. return proxyObj;

      }

      @Override public Class<?> getObjectType() {

      1. return proxyObj == null ? Object.class : proxyObj.getClass();

      }

      @Override public boolean isSingleton() {

      1. return true;

      }

      public String getInterfaceName() {

      1. return interfaceName;

      }

      public void setInterfaceName(String interfaceName) {

      1. this.interfaceName = interfaceName;

      }

      public Object getTarget() {

      1. return target;

      }

      public void setTarget(Object target) {

      1. this.target = target;

      }

      public Object getProxyObj() {

      1. return proxyObj;

      }

      public void setProxyObj(Object proxyObj) {

      1. this.proxyObj = proxyObj;

      }

      }

      1. XML-Bean配置如下
      2. ```xml
      3. <bean id="fbHelloWorldService" class="com.ebao.xxx.MyFactoryBean">
      4.   <property name="interfaceName" value="com.ebao.xxx.HelloWorldService" />
      5.   <property name="target" ref="helloWorldService" />
      6. </bean>

      Junit Test class

      1. @RunWith(JUnit4ClassRunner.class)
      2. @ContextConfiguration(classes = { MyFactoryBeanConfig.class })
      3. public class MyFactoryBeanTest {
      4.     @Autowired
      5.     private ApplicationContext context;    
      6.     /**
      7.      * 测试验证FactoryBean原理，代理一个servcie在调用其方法的前后，打印日志亦可作其他处理
      8.      * 从ApplicationContext中获取自定义的FactoryBean
      9.      * context.getBean(String beanName) ---> 最终获取到的Object是FactoryBean.getObejct(), 
      10.      * 使用Proxy.newInstance生成service的代理类
      11.      */
      12.     @Test
      13.     public void testFactoryBean() {
      14.         HelloWorldService helloWorldService = (HelloWorldService) context.getBean("fbHelloWorldService");
      15.         helloWorldService.getBeanName();
      16.         helloWorldService.sayHello();
      17.     }
      18. }

      FactoryBean是一个接口，当在IOC容器中的Bean实现了FactoryBean后，通过getBean(String BeanName)获取到的Bean对象并不是FactoryBean的实现类对象，而是这个实现类中的getObject()方法返回的对象。要想获取FactoryBean的实现类，就要getBean(&BeanName)，在BeanName之前加上&。
      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个方法：

      • **TgetObject()**：返回由FactoryBean创建的Bean实例，如果isSingleton()返回true，则该实例会放到Spring容器中单实例缓存池中；
      • **booleanisSingleton()**：返回由FactoryBean创建的Bean实例的作用域是singleton还是prototype；
      • **Class<T>getObjectType()**：返回FactoryBean创建的Bean类型。

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

      1. public class Car {
      2.     private int maxSpeed;
      3.     private String brand;
      4.     private double price;
      6.     public int getMaxSpeed() {
      7.         return this.maxSpeed;
      8.     }
      10.     public void setMaxSpeed(int maxSpeed) {
      11.         this.maxSpeed = maxSpeed;
      12.     }
      14.     public String getBrand() {
      15.         return this.brand;
      16.     }
      18.     public void setBrand(String brand) {
      19.         this.brand = brand;
      20.     }
      22.     public double getPrice() {
      23.         return this.price;
      24.     }
      26.     public void setPrice(double price) {
      27.         this.price = price;
      28.     }
      29. }

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

      1. import org.springframework.beans.factory.FactoryBean;  
      2. public class CarFactoryBean implements FactoryBean<Car> {
      3.     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.     }
      14.     public Class<Car> getObjectType() {
      15.         return Car.class;
      16.     }
      18.     public boolean isSingleton() {
      19.         return false;
      20.     }
      22.     public String getCarInfo() {
      23.         return this.carInfo;
      24.     }
      26.     // 接受逗号分割符设置属性信息  
      27.     public void setCarInfo(String carInfo) {
      28.         this.carInfo = carInfo;
      29.     }
      30. }

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

      1. <bean d="car" class="com.baobaotao.factorybean.CarFactoryBean" P:carInfo="法拉利,400,2000000"/>

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

      1. <beans xmlns="http://www.springframework.org/schema/beans"  
      2.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
      3.        xmlns:context="http://www.springframework.org/schema/context"  
      4.        xmlns:aop="http://www.springframework.org/schema/aop"  
      5.        xmlns:tx="http://www.springframework.org/schema/tx"  
      6.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
      7.                            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
      8.                            http://www.springframework.org/schema/context  
      9.                            http://www.springframework.org/schema/context/spring-context-3.0.xsd  
      10.                            http://www.springframework.org/schema/aop  
      11.                            http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
      12.                            http://www.springframework.org/schema/tx  
      13.                            http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">  
      15.   <bean id="student" class="com.spring.bean.Student">    
      16.     <property name="name" value="zhangsan" />    
      17.   </bean>    
      19.   <bean id="school" class="com.spring.bean.School">    
      20.   </bean>   
      22.   <bean id="factoryBeanPojo" class="com.spring.bean.FactoryBeanPojo">    
      23.     <property name="type" value="student" />  
      24.   </bean>   
      25. </beans>

      FactoryBean的实现类

      1. import org.springframework.beans.factory.FactoryBean;  
      3. public class FactoryBeanPojo implements FactoryBean{  
      4.     private String type;  
      6.     @Override  
      7.     public Object getObject() throws Exception {  
      8.         if("student".equals(type)){  
      9.             return new Student();             
      10.         }else{  
      11.             return new School();  
      12.         }  
      14.     }  
      16.     @Override  
      17.     public Class getObjectType() {  
      18.         return School.class;  
      19.     }  
      21.     @Override  
      22.     public boolean isSingleton() {  
      23.         return true;  
      24.     }  
      26.     public String getType() {  
      27.         return type;  
      28.     }  
      30.     public void setType(String type) {  
      31.         this.type = type;  
      32.     }  
      34. }

      普通的bean

      1. public class School {  
      2.     private String schoolName;  
      3.     private String address;  
      4.     private int studentNumber;  
      5.     public String getSchoolName() {  
      6.         return schoolName;  
      7.     }  
      8.     public void setSchoolName(String schoolName) {  
      9.         this.schoolName = schoolName;  
      10.     }  
      11.     public String getAddress() {  
      12.         return address;  
      13.     }  
      14.     public void setAddress(String address) {  
      15.         this.address = address;  
      16.     }  
      17.     public int getStudentNumber() {  
      18.         return studentNumber;  
      19.     }  
      20.     public void setStudentNumber(int studentNumber) {  
      21.         this.studentNumber = studentNumber;  
      22.     }  
      23.     @Override  
      24.     public String toString() {  
      25.         return "School [schoolName=" + schoolName + ", address=" + address  
      26.                 + ", studentNumber=" + studentNumber + "]";  
      27.     }  
      28. }

      测试类

      1. import org.springframework.context.support.ClassPathXmlApplicationContext;  
      3. import com.spring.bean.FactoryBeanPojo;  
      5. public class FactoryBeanTest {  
      6.     public static void main(String[] args){  
      7.         String url = "com/spring/config/BeanConfig.xml";  
      8.         ClassPathXmlApplicationContext cpxa = new ClassPathXmlApplicationContext(url);  
      9.         Object school=  cpxa.getBean("factoryBeanPojo");  
      10.         FactoryBeanPojo factoryBeanPojo= (FactoryBeanPojo) cpxa.getBean("&factoryBeanPojo");  
      11.         System.out.println(school.getClass().getName());  
      12.         System.out.println(factoryBeanPojo.getClass().getName());  
      13.     }  
      14. }

      输出的结果：

      1. 十一月 16, 2016 10:28:24 上午 org.springframework.context.support.AbstractApplicationContext prepareRefresh  
      2. INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1e8ee5c0: startup date [Wed Nov 16 10:28:24 CST 2016]; root of context hierarchy  
      3. 十一月 16, 2016 10:28:24 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions  
      4. INFO: Loading XML bean definitions from class path resource [com/spring/config/BeanConfig.xml]  
      5. 十一月 16, 2016 10:28:24 上午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons  
      6. INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@35b793ee: defining beans [student,school,factoryBeanPojo]; root of factory hierarchy  
      7. com.spring.bean.Student  
      8. com.spring.bean.FactoryBeanPojo

      从结果上可以看到当从IOC容器中获取FactoryBeanPojo对象的时候，用getBean(String BeanName)获取的确是Student对象，可以看到在FactoryBeanPojo中的type属性设置为student的时候，会在getObject()方法中返回Student对象。
      所以说从IOC容器获取实现了FactoryBean的实现类时，返回的却是实现类中的getObject方法返回的对象，要想获取FactoryBean的实现类，得在getBean(String BeanName)中的BeanName之前加上&，写成getBean(String &BeanName)。