SpringApplication上下文刷新第十一步finishBeanFactoryInitialization

在该步SpringApplication完成了 非单例 非懒加载(通过FactoryBean定义的Bean,并且是懒加载的如果没人使用，就先不会实例化。只会到使用的时候才实例化) Bean的加载工作.并在加载前提前加入了为AOP功能切入点织入通知的类以及设置标志位告知应用不许修改BeanDefinition

这里会跑回到AbstractAutowireCapableBeanFactory.doCreateBean方法上.又复习了一次Bean生命周期

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// 加载初始化类型转换Bean.这里未加载
	// 已经在run方法prepareContext步加载过了(postProcessApplicationContext方法中)
	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.
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// 实例化LoadTimeWeaverAware接口的bean，用于ApsectJ的类加载期织入的处理,提前加载是为了AOP功能,能为切入点织入通知.创建动态代理类
	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
	for (String weaverAwareName : weaverAwareNames) {
		getBean(weaverAwareName);
	}

	// 临时加载器置空,前期用临时加载器进行类型匹配工作
	beanFactory.setTempClassLoader(null);

	// beanDefinition冻结标志位设置为True.保存beanDefinition名称快照,因为马上要加载Bean了不希望这些beanDefinition被修改
	beanFactory.freezeConfiguration();

	// 实例化所有非懒加载单例Bean
	beanFactory.preInstantiateSingletons();
}

1. DefaultListableBeanFactory.preInstantiateSingletons

获取所有的Bean名称,对单例、非懒加载的Bean进行加载(通过AbstractBeanFactory.getBean()方法).其中特别对实现SmartFactoryBean的工厂Bean做了特殊校验,如果该工厂Bean要加载的Bean是非懒加载的则立即加载出来.

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

	// 获取所有Bean名称,迭代进行Bean加载.原来的作为缓存
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// Bean加载步骤
	for (String beanName : beanNames) {
	   // 获取该Bean的Bean定义,只能是单例、非懒加载的Bean能被加载
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
		    // 如果是工厂Bean是SmartFactoryBean类型判断该工厂要创建的单例Bean是否是懒加载
		    // 不是懒加载则立即加载出来.否则等需要时再加载
			if (isFactoryBean(beanName)) {
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
					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 {
			    // 如果不是工厂Bean则直接加载
				getBean(beanName);
			}
		}
	}

	// 执行SmartInitializingSingleton类型单例Bean的回调.类似于ContextRefreshedEvent事件监听器.但实现方便
	// 所有单例非懒加载Bean加载完后调用执行.
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		if (singletonInstance instanceof SmartInitializingSingleton) {
			StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
					.tag("beanName", beanName);
			SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			}
			else {
			    
				smartSingleton.afterSingletonsInstantiated();
			}
			smartInitialize.end();
		}
	}
}

2. AbstractBeanFactory.getBean()方法

该方法在工厂中负责获取容器中的Bean以及当Bean不存在时去加载Bean到容器中.这里getSingleton又涉及到了循环依赖,三级缓存相关知识.

public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}


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

    // 获取Bean原始名称,比如工厂Bean哪里加了&则会去除,多层别名则会获取最原始的名称
	String beanName = transformedBeanName(name);
	Object beanInstance;

	// 这里从容器缓存中找是否已经创建过/正在创建中(循环依赖),没有创建过则从else中执行重载方法进行对象创建.
	Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null && args == null) {
		if (logger.isTraceEnabled()) {
		    // 日志说明: 如果在singletonsCurrentlyInCreation容器中找到了则表示是未完全初始化的Bean,它只是循环引用的结果
			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对象,如果不是FactoryBean则会返回本身.否则则通过工厂Bean创建Bean
		// 执行PostProcessorsAfterInitialization方法
		beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}
    // 如果在上面缓存中没有,也没有该它的BeanFactory,就自行创建
	else {
		// 原型对象不允许循环创建,检查下是否是原型对象并且正在创建,是则抛出异常
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}

		// 检查是否该BeanDefinition存在于父容器中/如果父级容器存在则交由父级容器尝试加载
		// 这步就是套娃检查,父容器能加载就让父容器加载了
		BeanFactory parentBeanFactory = getParentBeanFactory();
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			// Not found -> check parent.
			String nameToLookup = originalBeanName(name);
			if (parentBeanFactory instanceof AbstractBeanFactory) {
				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
						nameToLookup, requiredType, args, typeCheckOnly);
			}
			else if (args != null) {
				// Delegation to parent with explicit args.
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			else if (requiredType != null) {
				// No args -> delegate to standard getBean method.
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
			else {
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}
        
        // 仅类型检查标志位被修改过后,则标记下该Bean已经被创建过了
		if (!typeCheckOnly) {
			markBeanAsCreated(beanName);
		}

		StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
				.tag("beanName", name);
		try {
			if (requiredType != null) {
				beanCreation.tag("beanType", requiredType::toString);
			}
			// 获取BeanDefinition.准备自己创建
			RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			// 查看该类是否是抽象类,是的话就抛出异常
			checkMergedBeanDefinition(mbd, beanName, args);

			// 处理预先加载@DependsOn标记的依赖Bean,如果在这里有循环依赖则直接抛出异常
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) {
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
					registerDependentBean(dep, beanName);
					try {
						getBean(dep);
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
					}
				}
			}

			// 创建单例Bean,这里lambda表达式中createBean是调用到AbstractAutowireCapableBeanFactory.doCreateBean方法.执行Bean创建的生命周期
			// AbstractBeanFactory是它的父类.所以直接使用createBean没有毛病.本身就是它自己定义的方法.执行时也是子类在执行
			// 判断该Bean是单例还是多例,单例则执行doCreateBean方法.获取单例Bean并进行Bean工厂注册
			// 如果是多例则调用beforePrototypeCreation和afterPrototypeCreation来记录在创建的状态,防止循环引用
			if (mbd.isSingleton()) {
				sharedInstance = getSingleton(beanName, () -> {
					try {
						return createBean(beanName, mbd, args);
					}
					catch (BeansException ex) {
						// Explicitly remove instance from singleton cache: It might have been put there
						// eagerly by the creation process, to allow for circular reference resolution.
						// Also remove any beans that received a temporary reference to the bean.
						destroySingleton(beanName);
						throw ex;
					}
				});
				beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}

			else if (mbd.isPrototype()) {
				// It's a prototype -> create a new instance.
				Object prototypeInstance = null;
				try {
					beforePrototypeCreation(beanName);
					prototypeInstance = createBean(beanName, mbd, args);
				}
				finally {
					afterPrototypeCreation(beanName);
				}
				beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
			}

			else {
				String scopeName = mbd.getScope();
				if (!StringUtils.hasLength(scopeName)) {
					throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
				}
				Scope scope = this.scopes.get(scopeName);
				if (scope == null) {
					throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
				}
				try {
					Object scopedInstance = scope.get(beanName, () -> {
						beforePrototypeCreation(beanName);
						try {
							return createBean(beanName, mbd, args);
						}
						finally {
							afterPrototypeCreation(beanName);
						}
					});
					beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
				}
				catch (IllegalStateException ex) {
					throw new ScopeNotActiveException(beanName, scopeName, ex);
				}
			}
		}
		catch (BeansException ex) {
			beanCreation.tag("exception", ex.getClass().toString());
			beanCreation.tag("message", String.valueOf(ex.getMessage()));
			cleanupAfterBeanCreationFailure(beanName);
			throw ex;
		}
		finally {
			beanCreation.end();
		}
	}
    
    // 最后对Bean类型做一个适配,不符合的类型则做一下转换.
	return adaptBeanInstance(name, beanInstance, requiredType);
}

getMergedLocalBeanDefinition(String beanName)方法

Bean定义公共的抽象类是AbstractBeanDefinition，普通的Bean在Spring加载Bean定义的时候，实例化出来的是GenericBeanDefinition，而Spring上下文包括实例化所有Bean用的AbstractBeanDefinition是RootBeanDefinition，这时候就使用getMergedLocalBeanDefinition方法做了一次转化，将非RootBeanDefinition转换为RootBeanDefinition以供后续操作
getMergedLocalBeanDefinition方法的作用就是获取缓存的BeanDefinition对象并合并其父类和本身的属性

3. DefaultSingletonBeanRegistry.getSingleton

该方法主要是做了bean创建的重复校验,Bean添加到容器中前后都判断是否重复创建了,如果有重复创建则抛出异常beforeSingletonCreation(beanName);,afterSingletonCreation(beanName);.如果容器中还是没有则进行创建该Bean的操作(Bean生命周期),创建完后加入容器中.上面lambda函数就是singletonFactory.getObject();方法

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	Assert.notNull(beanName, "Bean name must not be null");
	synchronized (this.singletonObjects) {
	    // 从缓存中获取（上面获取过一次的，这里是双从判定）
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null) {
			if (this.singletonsCurrentlyInDestruction) {
				throw new BeanCreationNotAllowedException(beanName,
						"Singleton bean creation not allowed while singletons of this factory are in destruction " +
						"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
			}
			beforeSingletonCreation(beanName);
			boolean newSingleton = false;
			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
			if (recordSuppressedExceptions) {
				this.suppressedExceptions = new LinkedHashSet<>();
			}
			try {
			    // 把这个实例生成出来，并且标志位设为true. 上面lambda表达式就是实现的这个方法.
				singletonObject = singletonFactory.getObject();
				newSingleton = true;
			}
			catch (IllegalStateException ex) {
				// 创建异常了则判断是否已经有人加入过该Bean了
				singletonObject = this.singletonObjects.get(beanName);
				if (singletonObject == null) {
					throw ex;
				}
			}
			catch (BeanCreationException ex) {
				if (recordSuppressedExceptions) {
					for (Exception suppressedException : this.suppressedExceptions) {
						ex.addRelatedCause(suppressedException);
					}
				}
				throw ex;
			}
			finally {
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = null;
				}
				afterSingletonCreation(beanName);
			}
			// !最后将这个已经创建好的Bean加入一级缓存容器中,删除二三级缓存中对该Bean的缓存
			if (newSingleton) {
				addSingleton(beanName, singletonObject);
			}
		}
		return singletonObject;
	}
}

AbstractAutowireCapableBeanFactory.createBean

他会去调用doCreateBean方法,来实现整个Bean的实例化、初始化的生命周期流程
.所以这里可以跳过.直接看doCreateBean

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {

	RootBeanDefinition mbdToUse = mbd;

	// 确认对应bean的Class已经加载解析过了
	// 做一份副本用来进行类动态解析
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		mbdToUse = new RootBeanDefinition(mbd);
		mbdToUse.setBeanClass(resolvedClass);
	}

	// Prepare method overrides.
	try {
	    // 可不看,通过配置文件进行方法重写,实现注入
		mbdToUse.prepareMethodOverrides();
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
				beanName, "Validation of method overrides failed", ex);
	}

	try {
		// 通过BeanPostProcessors来创建Bean的代理对象
		// 该步执行InstantiationAwareBeanPostProcessor接口的Bean实例化前方法
		// 具体逻辑是判断当前Spring容器是否注册了实现了InstantiationAwareBeanPostProcessor接口的后置处理器如果有
		// 则依次调用其中的applyBeanPostProcessorsBeforeInstantiation方法
		// 如果中间任意一个方法返回不为null,直接结束调用
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		// 如果不为空，说明提前生成了实例，直接返回
		if (bean != null) {
			return bean;
		}
	}
	catch (Throwable ex) {
		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
				"BeanPostProcessor before instantiation of bean failed", ex);
	}

	try {
	    // Bean创建以及生命周期在这个方法中.新开一个文章介绍
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isTraceEnabled()) {
			logger.trace("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}
	catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
		// A previously detected exception with proper bean creation context already,
		// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
		throw ex;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
	}
}

参考

spring 源码探索-- 静态AOP代理
AbstractApplicationContext.refresh方法
AbstractBeanFactory#getBean()、doGetBean完成Bean的初始化、实例化，以及BeanPostProcessor后置处理器
AbstractApplicationContext之refresh
【小家Spring】Spring IOC容器启动流程 AbstractApplicationContext#refresh()方法源码分析（二），Spring容器启动/刷新的完整总结