Spring IOC——FactoryBean

我们还是遵循WWH原则
What
Why
How

FactoryBean是什么

Spring中BeanFactory应该很熟悉了，IOC的最核心容器之一，IOC的根基。说到FactoryBean就有点不理解了。
在这里记起毕业后的入职第一家公司，架构师就有问到这个面试题。

面试题

面试官：请你说一下BeanFactory和FactoryBean的区别
我：BeanFactory是bean工厂，Spring IOC的核心容器；而FactoryBean则是工厂bean。
面试官：FactoryBean究竟是个什么样的工厂bean？
我：这个不太懂。

看源码的好奇心

时过七年，依然不知道FactoryBean究竟是什么样的工厂bean？
由于看Spring IOC源码，就是getBean()加载bean就有判断该bean是否为FactoryBean，这里勾起我面试的回忆，以及自己好奇心，那就去看看吧。

Spring的bean分为两种，一种就是普通的bean，另一种就是工厂bean（FactoryBean）。
FactoryBean跟普通bean区别在于，其返回的对象不是指定类的实例，而是该FactoryBean的getObject方法所返回的对象。

为什么使用FactoryBean

FactoryBean 通常是用来创建比较复杂的bean，一般的bean 直接用xml配置即可，但如果一个bean的创建过程中涉及到很多其他的bean和复杂的逻辑，用xml配置比较困难，这时可以考虑用FactoryBean。

FactoryBean如何实战

简单案例

1.Car实体类

package com.feiniu.springframework.factoryBean;

public class Car {
    private int maxSpeed;
    private String brand;
    private double price;

    public int getMaxSpeed() {
        return maxSpeed;
    }
    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }

}

2.用来获取Car的CarFactoryBean，必须继承FactoryBean接口

package com.feiniu.springframework.factoryBean;

import org.springframework.beans.factory.FactoryBean;

public class CarFactoryBean implements FactoryBean{

    private String carInfo;

    public String getCarInfo() {
        return carInfo;
    }

    public void setCarInfo(String carInfo) {
        this.carInfo = carInfo;
    }

    @Override
    public Car getObject() throws Exception {
        Car car = new Car();
        String[] infos = carInfo.split(","); 
        car.setMaxSpeed(Integer.parseInt(infos[0]));
        car.setBrand(infos[1]);
        car.setPrice(Double.parseDouble(infos[2]));
        return car;
    }

    @Override
    public Class getObjectType() {
        return Car.class;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }

}

3.配置文件

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:task="http://www.springframework.org/schema/task" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.1.xsd"
    default-autowire="byName">

    <bean id="car" class="com.feiniu.springframework.factoryBean.CarFactoryBean" >  
        <property name="carInfo" value="400,兰博基尼,2000000.00" />  
    bean>

beans> 

4.测试类

package com.feiniu.springframework.factoryBean;

import org.junit.Assert;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class TestCar {

    public static void main(String[] args) throws Exception {
        ApplicationContext context = new FileSystemXmlApplicationContext(  
                "applicationContext.xml");  
        Object car = context.getBean("car");
        System.out.println("Car is " + (car instanceof Car));
        System.out.println(((Car)car).getBrand());
        Object carFactoryBean = context.getBean("&car");
        System.out.println("carFactoryBean is " + (carFactoryBean instanceof CarFactoryBean));
        System.out.println(((CarFactoryBean)carFactoryBean).getObject());
    }
}

控制台输出

Car is true
兰博基尼
carFactoryBean is true
com.feiniu.springframework.factoryBean.Car@26a549a8

前面我们在看IOC源码的时候，发现即使我们已经创建出来了对象的实例，还是要走一个方法再去处理下，这里就是对FactoryBean的处理，因为它可以产生对象，所以你getBean的时候取到的不是它本身，而是通过它生成的产品。【如果要取它本身，getBean(&+beanName)】

我们先来回忆下IOC源码中那个处理FactoryBean的简略代码
代码1.1：AbstractBeanFactory类的doGetBean方法

protected  T doGetBean(
        final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {

    final String beanName = transformedBeanName(name);
    Object bean;

    // Eagerly check singleton cache for manually registered singletons.
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        if (logger.isDebugEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                        "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // Check if bean definition exists in this factory.
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }

        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
        checkMergedBeanDefinition(mbd, beanName, args);

        // Guarantee initialization of beans that the current bean depends on.
        String[] dependsOn = mbd.getDependsOn();
        if (dependsOn != null) {
            for (String dependsOnBean : dependsOn) {
                getBean(dependsOnBean);
                registerDependentBean(dependsOnBean, beanName);
            }
        }

        // Create bean instance.
        if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, new ObjectFactory