好玩Spring之FactoryBean

BeanFactory与FactoryBean，容易混淆，两者的区别，其实还是蛮大的，本文不详细展开。

实例演示FactoryBean的作用

// 这里是普通的pojo，没有任何注解
public class Alpha {
}

@Component
public class AlphaFactoryBean implements FactoryBean<Alpha> {
	@Override
	public Alpha getObject() throws Exception {
		return new Alpha();
	}

	@Override
	public Class<?> getObjectType() {
		return Alpha.class;
	}

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

@ComponentScan
public class MainTest {

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainTest.class);
		Object bean = context.getBean("alphaFactoryBean");
		System.out.println(bean);
		bean = context.getBean(Alpha.class);
		System.out.println(bean);
	}
}

输出结果

com.factorybean.chapter4.Alpha@6328d34a
com.factorybean.chapter4.Alpha@6328d34a

从结果可以看出，输出的结果完全一样，有2点有意思的地方：

1. Alpha类中没有注解（也就是说我们没有显式的把这个类让Spring管理起来），居然也能取到Alpha的实例

2. 获取alphaFactoryBean与获取Alpha.class，居然得到了一样的结果（连bean的实例id都一样）

如果想获取AlphaFactoryBean的实例，该咋办呢？先不急给出答案。

FactoryBean的源码分析

public interface FactoryBean<T> {
	
	@Nullable
	T getObject() throws Exception;
	
	@Nullable
	Class<?> getObjectType();
	
	default boolean isSingleton() {
		return true;
	}

}

这个类的代码非常的少，采用了我们熟知的工厂设计模式，只要实现了这个接口，就是告诉Spring, 我这个是工厂Bean，不是用来创造自身的，而是用来给其他的类创建Bean的。

我们分为2个阶段来具体分析：

1. 容器加载阶段

跟踪代码，我们发现在容器启动，调用refresh()方法（这个方法老生常谈了），在refresh()调用了finishBeanFactoryInitialization()这个方法，这个方法又调用了beanFactory.preInstantiateSingletons()方法

@Override
	public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					// 如果是一个工厂Bean，则在此处进行工厂Bean本身的实例化
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					getBean(beanName);
				}
			}
		}

		// 省略代码
        // ...
	}

并且在getBean()的过程中，通过DefaultSingletonBeanRegistry类的getSingleton()方法，将AlphaFactoryBean的实例加入到singletonObjects中去。

2. getBean阶段

2.1 Object bean = context.getBean("alphaFactoryBean");的执行

AbstractBeanFactory类的doGetBean()，进而走到bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);步步跟踪，找到了FactoryBeanRegistrySupport类中的doGetObjectFromFactoryBean()这个方法

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((PrivilegedExceptionAction<Object>) factory::getObject, acc);
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
                // 直接调用我们重写的factory.getObject()方法，返回new Alpha();
				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) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(
						beanName, "FactoryBean which is currently in creation returned null from getObject");
			}
			object = new NullBean();
		}
		return object;
	}

难怪context.getBean("alphaFactoryBean")返回了Alpha的实例，原来是调用了AlphaFactoryBean的getObject()方法，扫噶！

2.2 Object bean = context.getBean(Alpha.class);的执行

Spring并没有管理Alpha这个类，又是如何打印出结果的呢？

跟踪getBean()方法，会进入DefaultListableBeanFactory类的resolveNamedBean()方法，

private <T> NamedBeanHolder<T> resolveNamedBean(
			ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) throws BeansException {

		Assert.notNull(requiredType, "Required type must not be null");
		Class<?> clazz = requiredType.getRawClass();
		Assert.notNull(clazz, "Required type must have a raw Class");
		// 如果requiredType被FactoryBean管理了，candidateNames为factoryBean的name
		String[] candidateNames = getBeanNamesForType(requiredType);

		if (candidateNames.length > 1) {
			// 省略代码
		}

		if (candidateNames.length == 1) {
            // beanName为FactoryBean的id
			String beanName = candidateNames[0];
			return new NamedBeanHolder<>(beanName, (T) getBean(beanName, clazz, args));
		}
		else if (candidateNames.length > 1) {
			// 省略代码
		}

		return null;
	}

执行return new NamedBeanHolder<>(beanName, (T) getBean(beanName, clazz, args));

此时便进入了跟之前分析Object bean = context.getBean("alphaFactoryBean");一样的流程，最终调用了AlphaFactoryBean的getObject()方法，所以也返回了Alpha的实例。

那为何返回的Alpha的实例id也是一样的呢？看下边的源码就知道了。

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		// factory.isSingleton()即 自己编写的factorybean中的isSingleton()方法
		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 (containsSingleton(beanName)) {
							// 把beanName和对应的实例放入cache，
							// 下次直接从这取，所以isSingleton()为true时，取到的实例是一样的
							this.factoryBeanObjectCache.put(beanName, object);
						}
					}
				}
				return object;
			}
		}
		else {
			// factorybean中的isSingleton()如果为false，则取到的实例不一样
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			if (shouldPostProcess) {
				try {
					object = postProcessObjectFromFactoryBean(object, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
				}
			}
			return object;
		}
	}

2.3 Object bean = context.getBean("&alphaFactoryBean");的执行

在容器加载阶段，我们讲到beanFactory.preInstantiateSingletons()方法，其又调用了getBean()方法，在这个方法中，

会把AlphaFactoryBean的实例缓存到singletonObjects中。

而context.getBean("&alphaFactoryBean")执行时，直接从Object singletonObject = this.singletonObjects.get(beanName);取出缓存好的AlphaFactoryBean的实例

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

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

		// Eagerly check singleton cache for manually registered singletons.
        // 从singletonObjects直接取出缓存好的AlphaFactoryBean的实例
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isTraceEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		// 省略代码
        // ...    		
		return (T) bean;
	}