好玩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的源碼分析

源碼分析分爲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;
	}