SPRING FRAMEWORK(3) FactoryBean BeanFactory ObjectFactory

一般情况下， Spring通过反射机制利用bean的class属性指定实现类来实例化bean，在某些情况下，实例化bean过程比较复杂，如果按照传统的方式，则需要在中提供大量的配置信息，配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。

package org.springframework.beans.factory;
public interface FactoryBean<T> {
    T getObject() throws Exception;//返回由FactoryBean创建的targetBean
    Class<?> getObjectType();//返回FactoryBean创建的targetBean类型
    boolean isSingleton();//返回targetBean是否为单例
}

spring中存在两种bean,一种是我们想要的bean简单记为targetBean，一种就是这个factoryBean了，factoryBean就是生产targetBean的bean。从上面的描述可以知道在spring中存在大量的factoryBean。
如果通过spring获取一个factoryBean呢？

public class CarFactoryBean implements FactoryBean<Car>{
    private String carInfo;
    public Car getObject() throws Exceptino {
        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; 
    }
}

<bean id="car" class="com.test.factorybean.CarFactoryBean" carInfo="超级跑车,400,2000000" />

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

beanFactory.getBean("car");
-->beanFactory.getBean("&car").getObject()

//返回对应的实例
//有时候返回ObjectFactory的指定方法用于生成实例
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);

在getBean方法中，getObjectForBeanInstance是个高频率使用的方法，无论是从缓存中获得bean还是根据不同的scope策略加载bean。总之，得到bean的实例后要做的第一步就是调用这个方法来检测一下正确性，其实就是用于检测当前bean是否是FactoryBean类型的bean，如果是，那么需要调用该bean对应的FactoryBean实例中的getObject()作为返回值。

protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
    //如果指定的name是工厂相关(以&为前缀)且beanInstance又不是FactoryBean类型则验证不通过
    if(BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
        throw new BeanIsNotAFactoryException(this.transformedBeanName(name), beanInstance.getClass());
    } else if(beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
        //加载FactoryBean
        //尝试从缓存中加载bean
        Object object = this.getCachedObjectForFactoryBean(beanName);
        //到这里已经明确知道beanInstance一定是FactoryBean类型
        if(object == null) {
            FactoryBean factory = (FactoryBean)beanInstance;
            object = this.getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
        return object;
    } else {
        //对非FactoryBean不做任何处理
        return beanInstance;
    }
}


protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean shouldPostProcess) {
    if(factory.isSingleton() && this.containsSingleton(beanName)) {
        //如果是单例模式
        synchronized(this.getSingletonMutex()) {
            Object object = this.factoryBeanObjectCache.get(beanName);
            if(object == null) {
                object = this.doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
                this.factoryBeanObjectCache.put(beanName, object != null?object:NULL_OBJECT);
            }

            return object != NULL_OBJECT?object:null;
        }
    } else {
        return this.doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
    }
}

private Object doGetObjectFromFactoryBean(final FactoryBean factory, String beanName, boolean shouldPostProcess) throws BeanCreationException {
    Object object = factory.getObject();
    if(object != null && shouldPostProcess) {
       //调用ObjectFactory的后处理器
        object = this.postProcessObjectFromFactoryBean(object, beanName);
     }
    return object;
}

doGetObjectFromFactoryBean实现了从FactoryBean中对应的getObject方法得到bean，但是得到后并没有立即返回，而是做了些后处理的操作

public Object postProcessObjectFromFactoryBean(Object existingBean, String beanName) throws BeansException {
    Object result = existingBean;
    Iterator var5 = this.getBeanPostProcessors().iterator();
    while(var5.hasNext()) {
        BeanPostProcessor beanProcessor = (BeanPostProcessor)var5.next();
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
    }
    return result;
}