Spring技术内幕笔记（十一）------FactoryBean的实现

FactoryBean

一般情况下，Spring通过反射机制利用bean的Class属性指定实现类来实例化bean。而FactoryBean是一种特殊的bean，是一个工厂bean，可以自己创建bean实例，如果一个类实现了Factorybean接口，则该类可以自己定义创建实例对象的方法，只需要实现getObject方法就好
为了区分FactoryBean和FactoryBean创建的bean实例，Spring使用了&前缀作为FactoryBean的标识名name

首先让我们看一下Spring是在什么地方，什么时刻生成FactoryBean的。

在Spring中，如果我们需要FactoryBean来帮助我们生成复杂对象，那么首先要向Spring中注册一个Factory bean，下面的调用过程就是初始化BeanFactory的过程

从上图我们可以看到，实例化一个FactoryBean的过程是什么样的，那么接下来就让我们分析一下，FactoryBean的实例化过程。

1. refresh（）

	/**
	 * 刷新IOC容器
	 * @throws BeansException
	 * @throws IllegalStateException
	 */
	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			//准备上下文以进行刷新
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			//告诉子类重启bean工厂，Resource定位过程
			//BeanDefinition的载入
			//向IoC容器注册这些BeanDefinition的过程
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			// 准备bean工厂以再次上下文中使用
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				//允许在上下文子类中对bean工厂进行后处理，允许在子类重写
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				//在环境中调用已经注册好的beanFactory的后置处理器
				//用于处理 BeanFactoryPostProcessor 接口
				//Spring IoC 容器允许 BeanFactoryPostProcessor 在容器实例化任何 Bean 之前读取Bean 的定义，并可以修改它。
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				// 注册拦截bean创建的bean处理器，主要是用来处理beanPostProcessor
				registerBeanPostProcessors(beanFactory);

				/**
				 * BeanPostProcessors：针对于beanFactory的扩展，主要用在Bean实例化之前，读取bean的定义，并可以修改它
				 * BeanFactoryPostProcessor：针对于bean的扩展，主要用在Bean实例化之后，执行初始化方法前后，允许开发者对Bean实例进行修改
				 */

				// Initialize message source for this context.
				// 初始化此上下文的消息源
				initMessageSource();

				// Initialize event multicaster for this context.
				//初始化此上下文的事件多播器
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				// 在特定的上下文子类中初始化其他特殊bean
				onRefresh();

				// Check for listener beans and register them.
				// 检查监听器bean并注册他们
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				// 实例化所有剩余（非懒加载的）单例对象
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				//最后一步发布相应的时间
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

refresh（）方法的作用主要是重启Spring环境，由于我们今天只关心FactoryBean相关的知识，所以我们将目光方法finishBeanFactoryInitialization（）这个方法上

2. finishBeanFactoryInitialization
   这个方法也是AbstractApplicationContext为我们提供的一个protected方法，主要是为实例化Bean做一些准备工作

	/**
	 * Finish the initialization of this context's bean factory,
	 * initializing all remaining singleton beans.
	 * 完成此上下文的bean工厂的初始化，初始化所有剩余的单例bean
	 */
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		//初始化上下文的转换服务
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// Register a default embedded value resolver if no bean post-processor
		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		// 2.如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注解属性值的解析。
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		// 3.初始化LoadTimeWeaverAware Bean实例对象
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		// 4.冻结所有bean定义，注册的bean定义不会被修改或进一步后处理，因为马上要创建 Bean 实例对象了
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
		// 5.实例化所有剩余（非懒加载）单例对象
		beanFactory.preInstantiateSingletons();
	}

我们直接看方法的最后一行beanFactory.preInstantiateSingletons（），方法是ConfigurableListableBeanFactory为我们提供的一个接口方法，具体实现是在DefaultListableBeanFactory中实现的，主要是为了确保所有的非懒加载的Bean能够实例化，同时也会兼顾FactoryBean相关的实现，这就是我们今天所关心的。

3. 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.
		// 1.创建beanDefinitionNames的副本beanNames用于后续的遍历，以允许init等方法注册新的bean定义
		List beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		// 2.遍历beanNames，触发所有非懒加载单例bean的初始化
		for (String beanName : beanNames) {
			// 3.获取beanName对应的合并的BeanDefinition对象
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// 4.bd对应的Bean实例：不是抽象类 && 是单例 && 不是懒加载
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				// 5.如果beanName对应的bean是FactoryBean
				if (isFactoryBean(beanName)) {
					//拿到当前beanName对应的对象
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					//判断此对象是否是FactoryBean
					if (bean instanceof FactoryBean) {
						//将当前对象转换成FactoryBean
						final FactoryBean factory = (FactoryBean) bean;
						//判断这个bean是否需要急切的初始化
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction)
											((SmartFactoryBean) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean) factory).isEagerInit());
						}
						if (isEagerInit) {
							// 5.3 通过beanName获取bean实例
							getBean(beanName);
						}
					}
				}
				else {
					// 6.如果beanName对应的bean不是FactoryBean，只是普通Bean，通过beanName获取bean实例
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		//用于创建完成bean之后
		// 7.遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调
		for (String beanName : beanNames) {
			// 8.拿到beanName对应的bean实例
			Object singletonInstance = getSingleton(beanName);
			// 9.判断singletonInstance是否实现了SmartInitializingSingleton接口
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				// 10.调用SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction