主要讲解getObjectForInstance方法，对FactoryBean验证，并获取需要的Bean实例。
无论是从缓存中获得bean还是根据不同的scope策略加载bean，都需要在得到bean实例后调用getObjectForInstance方法来检测一下正确性；即检测当前bean是否是FactoryBean类型的bean，如果是，那么需要调用该bean对应的FactoryBean实例中的getObject()方法作为返回值。
无论是从缓存中获取的bean还是通过不同scope策略加载的bean都只是原始的bean状态，并不一定是我们最终想要的bean，举个例子，假如我们需要对工厂bean进行处理，那么这里得到的其实是工厂bean的初始状态，但是我们真正需要的是工厂bean中定义的factory-method方法中返回的bean，而getObjectForInstance方法就是完成这个工作的。
主要步骤：
- 对FactoryBean正确性的验证
beanName含有 &前缀，但是又不是FactoryBean，则验证不通过并抛出异常。
- 对非FactoryBean或者beanName含有&前缀的FactoryBean则不做任何处理，直接返回。
- 如果是beanName不含有&前缀的FactoryBean，则先尝试从factoryBeanObjectCache中获取由Factory创建的bean。
factoryBeanObjectCache用于存放被FactoryBean创建的单例bean对象，保存的映射为 FactoryBean -> object。
- factoryBeanObjectCache中不存在，则将FactoryBean中获取bean的工作委托给getObjectFormFactoryBean方法（主要是调用FactoryBean.getObject()方法）。
FactoryBean检测与获取Bean
beans.factory.support.AbstractBeanFactory(XmlBeanFactory 继承自这个类，拥有这个方法)
/**
* Get the object for the given bean instance, either the bean
* instance itself or its created object in case of a FactoryBean.
* @param beanInstance the shared bean instance
* @param name name that may include factory dereference prefix
* @param beanName the canonical bean name
* @param mbd the merged bean definition
* @return the object to expose for the bean
*/
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
//1. Don't let calling code try to dereference the factory if the bean isn't a factory.
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
//2. Now we have the bean instance, which may be a normal bean or a FactoryBean.
// If it's a FactoryBean, we use it to create a bean instance, unless the
// caller actually wants a reference to the factory.
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
// 3.
Object object = null;
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 4.
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
接下来主要看一下第四步是如何操作的？
beans.factory.support.FactoryBeanRegistrySupport(XmlBeanFactory 继承自这个类，拥有这个方法)
/**
* Obtain an object to expose from the given FactoryBean.
* @param factory the FactoryBean instance
* @param beanName the name of the bean
* @param shouldPostProcess whether the bean is subject to post-processing
* @return the object obtained from the FactoryBean
* @throws BeanCreationException if FactoryBean object creation failed
* @see org.springframework.beans.factory.FactoryBean#getObject()
*/
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
object = doGetObjectFromFactoryBean(factory, beanName);
// Only post-process and store if not put there already during getObject() call above
// (e.g. because of circular reference processing triggered by custom getBean calls)
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
if (object != null && shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
}
this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
}
}
return (object != NULL_OBJECT ? object : null);
}
}
else {
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (object != null && shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
/**
* Obtain an object to expose from the given FactoryBean.
* @param factory the FactoryBean instance
* @param beanName the name of the bean
* @return the object obtained from the FactoryBean
* @throws BeanCreationException if FactoryBean object creation failed
* @see org.springframework.beans.factory.FactoryBean#getObject()
*/
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
try {
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
return factory.getObject();
}
}, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null && isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
return object;
}
getObjectFromFactoryBean方法内获取单例独占锁，是为了保证单例在容器中的全局唯一性，避免重复创建，使用缓存提高性能，也就是已经加载过则记录复用，下次从factoryBeanObjectCache缓存中获取，否则的话就调用getObject直接获取了。
doGetObjectFromFactoryBean中最核心的是调用FactoryBean的getObject方法获取bean。
getObjectFromFactoryBean方法内，并没有直接返回获取的bean，而是更根据情况做了一些后处理操作。
下面来看一下从FactoryBean中获取Bean对象的后处理方法：
初始化后处理(XmlBeanFactory 继承自这个类，拥有这个方法)
beans.factory.support.AbstractAutowireCapableBeanFactory
/**
* Applies the {@code postProcessAfterInitialization} callback of all
* registered BeanPostProcessors, giving them a chance to post-process the
* object obtained from FactoryBeans (for example, to auto-proxy them).
* @see #applyBeanPostProcessorsAfterInitialization
*/
@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
result = beanProcessor.postProcessAfterInitialization(result, beanName);
if (result == null) {
return result;
}
}
return result;
}
通过迭代获取所有BeanPostProcessor后处理器，对获取的对象进行后处理。注意这里调用的是后处理器的postProcessAfterInitialization方法，即初始化后处理方法。
FactoryBean是什么，有什么用处？
<bean>标签 的class属性如果配置为FactoryBean时，通过getBean()方法返回的不是FactoryBean本身，而是FactoryBean#getObject()方法返回的对象，这主要是Spring通过反射机制检查配置的class属性配置的类是否实现了FactoryBean接口，如果实现了这个接口则Spring就会调用其getObject方法。
如果希望返回FactoryBean实现类本身，则需要在getBean(beanName)中的beanName前显示的加上"&"前缀，比如getBean("&aBeanName")
FactoryBean的妙用
在自定义Bean的类定义中继承FactoryBean接口，然后实现getObject接口方法，可以实现自定义的Bean的配置，比如在bean配置文件中,多个<property>子标签配置bean的属性值，可以在getObject方法中通过csv的字符串格式（对属性分隔表示）来配置创建出来的Bean的属性。
和普通Bean的区别
普通Bean在BeanFactory中是通过getBean方法获取的，而FactoryBean则是BeanFactory#getBean获取FactoryBean，如果想获取FactoryBean工厂方法返回的Bean，则需调用FactoryBean的getObject方法创。
