Spring源码（十三）finishBeanFactoryInitialization与preInstantiateSingletons方法

此方法是Spring最最最重要的方法，需要把里面细节讨论清楚！！！

finishBeanFactoryInitialization的conversionService与FactoryBean

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.
		// 如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器，主要用于注解属性值的解析
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		// 尽早初始化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.
		// 冻结所有的bean定义，说明注册的bean定义将不被修改或任何进一步的处理
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
		// 实例化剩下的单例对象
		beanFactory.preInstantiateSingletons();
	}

这里ConversionService是用来类型转换的，输入整型int，转换为Integer类型。这里提供了转换服务，比如我们在重写属性编辑器时，有个setAsText方法，参数是String类型，如果传入的是非string类型，那么怎么转换成String类型，这里就可以用到ConversionService方法。

转换器都是spring默认提供好了.

这里有几个父类接口，converter，GenericConverter，ConverterFactory。
converter ------ > 直接s - > T 直接转换
GenericConverter ------> 1个可以转成多个类型
ConverterFactory ------> N对N个

继续往下，如果没有注入解析器，这里是（such as a PropertyPlaceholderConfigurer bean），实际上我们注入了。在invokeBeanFactoryBeanProcessor

继续往下，weaveAwareNames，在prepareBeanFactory，添加了addBeanPostProcessor。

设置了临时加载器进行类型匹配。

冻结configuration，冻结所有bean定义，说明bean定义不能被修改。(实例化开始前，bean不用改了)。

下面个方法是最重要的方法了，完成实例化了preInstantiateSingletons。

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.
		// 将所有BeanDefinition的名字创建一个集合
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		// 触发所有非延迟加载单例bean的初始化，遍历集合的对象
		for (String beanName : beanNames) {
			// 合并父类BeanDefinition
 			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// 条件判断，抽象，单例，非懒加载
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				// 判断是否实现了FactoryBean接口
				if (isFactoryBean(beanName)) {
					// 根据&+beanName来获取具体的对象
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					// 进行类型转换
					if (bean instanceof FactoryBean) {
						FactoryBean<?> factory = (FactoryBean<?>) bean;
						// 判断这个FactoryBean是否希望立即初始化
						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());
						}
						//  如果希望急切的初始化，则通过beanName获取bean实例
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					// 如果beanName对应的bean不是FactoryBean，只是普通的bean，通过beanName获取bean实例
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		// 遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调
		for (String beanName : beanNames) {
			// 获取beanName对应的bean实例
			Object singletonInstance = getSingleton(beanName);
			// 判断singletonInstance是否实现了SmartInitializingSingleton接口
			if (singletonInstance instanceof SmartInitializingSingleton) {
				// 类型转换
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				// 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

getMergedLocalBeanDefinition方法在BFPP时的getNameType，已经增加了。意义：在实例化之前，把所有的基础的beanDefinition，转化为RootBeanDefinition对象，进行缓存，后续在需要马上要实例化的时候，直接获取定义信息，而定义信息中如果包含了父类，那么必须要先创建父类，才能有子类。

继续看下代码，有个判断，会进去，然后会判断是否是isFactoryBean，

当使用factoryBean接口来创建对象的时候，一共创建了2个对象，一个是实现了factoryBean接口的对象，一个是getObject返回的对象。两个对象都是由spring管理的。

然后通过getBean的& + beanName获取具体的对象。
实际上初始化的factoryBean后，并没有对GetObject对象进行初始化。
在getObjectForBeanInstance中调用了getObjectFromFactoryBean，factory.getObject方法，这个就是真正的getOject对象的创建。User不是放在singletonObjects的一级缓存中的，这是放在factoryBeanObjectCache集合中了。把对象独立存储了。虽然是Spring管理，存放对象的缓存集合不同，实现了FactoryBean接口的对象在一级缓存，但是调用getObject获取的对象放在factoryBeanObjectCache。

如果再一次获取User对象，那么直接从factoryBeanObjectCache里面拿了。

如果把是否单例，改为false，那么factoryBeanObjectCache里面取不到了，那么Spring就不会帮我们去管理了。

总结

本章主要介绍了finishBeanFactoryInitialization与preInstantiateSingletons方法。

还介绍了在preInstantiateSingletons方法中进入判断的factoryBean，这里总结一下。
factoryBean主要自己实现三个getObjectType、isSingleton、getObject方法。最后factoryBean会创建两个对象，一个时实现factoryBean对象，一个时getObject返回的对象。我们知道一般而言，创建的对象都会放到一级缓存中，也就是singletonObjects，但是实际上我们发现，只有factoryBean,我们的getobject返回的对象并不存在。实际上，getObject对象，需要自己获取的时候才会创建，而此时创建的对象如果是单例模式，那么完整的对象会放在factoryBeanObjectCache里面。如果是原型的，那么就不由spring管理了，也就是说不会再由factoryBeanObjectCache存储了。

下面继续介绍dogetBean方法。