Spring基于注解的Ioc容器源码分析02

「本文已参与好文召集令活动，点击查看：后端、大前端双赛道投稿，2万元奖池等你挑战！」

Spring源码系列所有的源码都可以在我个人的Github仓库下载。

上篇分析了容器的初始化和包扫描过程，接下来继续分析容器的刷新过程。
从org.springframework.context.support.AbstractApplicationContext#refresh开始。

@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.
			/**
			 * 	01 委托实现类刷新beanFactory，这里是模板方法设计模式
			 */
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			/**
			 * 02 设置BeanFactory的类加载器，初始化一个标准的容器
			 * 实例化 2个 BeanPostProcessor到成员变量
			 * 手动注册几个特殊的bean
			 */
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				// 03 拓展点：留给子类去实现扩展 比如Web容器注册ServletContextAwareProcessor
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				//04 实例化 BeanFactoryPostProcessor，并且调用后处理方法。是对BeanFactory拓展
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				/**
				 * 05 先实例化 ****BeanPostProcessor对象（之前scan扫描到的BeanDefinition），因为后面实例化普通bean的时候需要调用后处理方法。
				 * 再把实例化后的processor对象放入 beanPostProcessors 成员变量:
				 * @link org.springframework.beans.factory.support.AbstractBeanFactory#beanPostProcessors
				 */
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				// 国际化
				initMessageSource();

				// Initialize event multicaster for this context.
				//初始化事件广播器
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				/**
				 * 06 扩展点:允许子类在指定上下问中来实例化指定的bean
				 * 模板方法设计模式，发生在特殊Bean实例化之后，单例Bean实例化之前
				 * web服务中，tomcat就是利用这个拓展点来初始化的。
				 */
				onRefresh();

				// Check for listener beans and register them.
				// 07 注册事件监听器（实现了ApplicationListener接口的类）
				registerListeners();

				/**
				 * 08 实例化bean
				 */
				// 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();
			}
		}
	}
复制代码

1. 获取BeanFactory容器

基于注解的容器，在最开始的init()方法中，调用了父类的构造函数new出了一个DefaultListableBeanFactory，所以这里无需重复创建。

protected ConfigurableListableBeanFactory  obtainFreshBeanFactory() {
		/**
		 * 对于AnnotationConfigApplication->GenericApplicationContext，这里已经不需要再扫描bean的定义。因为在前面 02调用了scan()方法
		 * 对于其他容器，ClassPathXmlApplicationContext->AbstractRefreshableApplicationContext，有自己的实现，会完成beanDefinition的解析。
		 */
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}
复制代码

2. 容器的标准初始化

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		beanFactory.setBeanClassLoader(getClassLoader());
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		/**
		 *	注册 beanPostProcessors 到成员变量
		 *	用于把ApplicationContext上下文传递给实现了 {@link EnvironmentAware}, {@link EmbeddedValueResolverAware},
		 *  {@link ResourceLoaderAware}, {@link ApplicationEventPublisherAware},{@link MessageSourceAware} and/or {@link ApplicationContextAware} 接口的对象
		 *  【编码中注入Spring容器上下文就是这么干的】
 		 */
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		// 依赖注入的时候忽略这些Spring内置的bean，应该是不能直接拿来注入的。
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		// 注册到ioc依赖注入
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// Register early post-processor for detecting inner beans as ApplicationListeners.
		/**
		 * 注册 用于发现实现了ApplicationListener接口的bean
		 * 【发现Spring内部消息的监听者】
		 */
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// Set a temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// Register default environment beans.
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}
复制代码

• 实例化ApplicationContextAwareProcessor，用于传递ApplicationContext上下文容器
• 实例化ApplicationListenerDetector，用于扫描实现ApplicationListener的监听器
• 实例化LoadTimeWeaverAwareProcessor，用于发现运行时织入的组件。（动态代理）

3. 是一个拓展点，留给子类去实现用来处理BeanFactory，发生在标准的初始化之后。

4. 实例化默认的BeanFactoryPostProcessor，并且调用后处理方法。也是对BeanFactory拓展。

BeanFactoryPostProcessor用来扩展处理容器里面的Bean，postProcessBeanFactory()允许在实例化Bean之前覆盖或者增加bean的属性。与BeanPostProcessor不同的是，它只能后处理容器里面的BeanDefinition(还没有实例化之前)。

4.1 实例化硬编码的Postprocessor对象

/**
			 * 4.1 实例化硬编码注册的后置处理器
			 */
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}
复制代码

4.2 扫描配置的BeanFactoryPostProcessor

/**
			 * 4.2 实例化配置的后处理器
			 */
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
复制代码

4.3 实例化所有的PostProcessor类型

List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}
复制代码

4.4 调用PostProcessor 的处理方法

sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// Finally, invoke all other BeanFactoryPostProcessors.
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
复制代码

5. 实例化init()方法中扫描到***BeanPostProcessor类型的BeanDefinition，并且添加到工厂的beanPostProcessors属性。

BeanPostProcessor也是Spring容器非常重要的扩展属性之一。

BeanPostProcessor是责任链模式，所有的BeanPostProcessor挂在一条链上。
基本初始化流程和4中BeanFactory流程差不多，不同的是这个步骤只是完成了实例化，但是并没有调用post处理方法。

/**
public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
                        .........省略代码
                        /**
		 * 5.3 拆分排序的和未实现排序的
		 */
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 实例化实现了PriorityOrdered接口的PostProcessor
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}
		 /** 5.4 注册 【实现了PriorityOrdered接口的PostProcessor对象】在5.3中实例化 放入BeanFactory工厂
		 */
		// First, register the BeanPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		/**
		 * 5.5 实例化  【实现了Order接口的PostProcessor】
		 */
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// Now, register all regular BeanPostProcessors.
		// 5.6 实例化常规的bean,注册所有无序的BeanPostProcessor
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// Finally, re-register all internal BeanPostProcessors.
		/**
		 * 5.7 再次注册所有内部的BeanPostProcessors  ?? 这里为什么要重复注册,好像就是替换了BeanPostProcessor的顺序。
		 * 没有重复注册  是注册MergedBeanDefinitionPostProcessor类型的PostProcessor
		 *
		 * 所以小结一下，BeanPostProcessor的顺序为： PriorityOrdered  ->  Order  ->  regular  ->  MergedBeanDefinitionPostProcessor类型
 		 */
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// Re-register post-processor for detecting inner beans as ApplicationListeners,
		// moving it to the end of the processor chain (for picking up proxies etc).
		// 5.8 再次注册发现事件监听器的post-processor，摆在最后面（责任链模式，所有的PostProcessor放在一条链上，顺序）
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}
复制代码

大致步骤就是:

• 先从BeanFactory中获取BeanPostProcessor类型的BeanDefinition
• 开始按照PriorityOrdered -> Order -> regular 拆分和排序
• 实例化BeanDefinition并且放入List beanPostProcessors成员变量

6. 扩展点留给子类的一个模板方法，可以按需实现。

7. 注册事件监听器

protected void registerListeners() {
		// Register statically specified listeners first.
		/**
		 * 7.1 获取硬编码的Set<ApplicationListener<?>> applicationListeners
		 */
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let post-processors apply to them!
		/**
		 * 7.2 获取扫描到的ApplicationListener类型的监听器
		 */
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// Publish early application events now that we finally have a multicaster...
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}
复制代码

8. 实例化Bean

开始实例化所有非懒加载的Bean

public void preInstantiateSingletons() throws BeansException {
		if (logger.isDebugEnabled()) {
			logger.debug("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.
		// 8.1 在前面的扫描过程中，this.beanDefinitionNames保存了所有的beanDefinition的名字
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		// 循环初始化bean
		for (String beanName : beanNames) {
			// 合并父类（若存在）中的属性
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// 非抽象的，单例的，非懒加载的。
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				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 {
					// 8.2 【重要】开始bean的初始化入口
					getBean(beanName);
				}
			}
		}
复制代码

getBean() -> doGetBean()

主要包括几下几个步骤

• 先判断单例工厂是否存在，存在直接返回，不存在则提前暴露当前要实例化beanName，放入Map<String, Object> earlySingletonObjects(初始化容器的时候走不存在流程)
• 判断父工厂里面是否存在
• 都不存在开始创建，首先递归实例化目标Bean所依赖的所有Bean。
• 按照不同Scope类型创建bean createBean() -> doCreateBean()
• 检查Bean的类型，类型一致就直接返回Bean

有几个方法简单说明下：

getObjectForBeanInstance()

如果是普通 Bean 的话，直接返回 sharedInstance，如果是 FactoryBean 的话，返回它创建的那个实例对象

protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		/**
		 * 调用这个方法来检测一下正确性，其实就是用于检测当前bean是否是FactoryBean类型的bean，
		 * 如果是，那么需要调用该bean对应的FactoryBean实例中的getObject()作为返回值，不是
		 */
		// Don't let calling code try to dereference the factory if the bean isn't a factory.
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
			}
		}

		// Now we have the bean instance, which may be a normal bean or a FactoryBean.
		// If it's a FactoryBean, we use it to create a bean instance, unless the
		// caller actually wants a reference to the factory.
		// 非工厂bean，则直接返回
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		// 加载FactoryBean
		Object object = null;
		if (mbd == null) {
			// 在前面单例判断那里有可能直接被对象工厂初始化了
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			// Return bean instance from factory.
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			boolean synthetic = (mbd != null && mbd.isSynthetic());

			// 重点：真正从FactoryBean中获取bean实例，将从Factory中解析bean的工作委托给getObjectFromFactoryBean
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}
复制代码

无论是从缓存中获取到的bean还是通过不同的scope策略加载的bean都只是最原始的bean状态,我们真正需要的是工厂bean中定义的factory-method方法中返回的bean,BeanPostProcessor 的后置处理器在这里实现。

createBean(): 创建bean之前的准备工作
doCreateBean方法是真正实例化Bean的地方，在实例化Bean之前在Create()方法中做了一些准备工作

• 方法覆写
• aop的处理，如果采用了增强，则直接在这里返回Bean对象。InstantiationAwareBeanPostProcessors类型的扩展处理器处理初始化之前的aop。

doCreateBean() ：开始创建Bean

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

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 【重要】 01 反射调用构造函数 创建bean实例
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		/**
		 * 02 后处理bean 循环处理 实现 MergedBeanDefinitionPostProcessor的处理方法
		 * 只处理这一种类型的PostProcessor，其他类型的在下面处理。
		 */
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		// 03 提前暴露解决循环依赖问题
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		// 04填充bean属性（包括@Autowire）
		Object exposedObject = bean;
		try {
			/**
			 * 【重要】 05 填充bean的属性
			 * 这一步也是非常关键的，这一步负责属性装配，因为前面的实例只是实例化了，并没有设值，这里就是设值
			 *
 			 */
			populateBean(beanName, mbd, instanceWrapper);
			/**
			 * 【重要】 06 还记得 init-method 吗？还有 InitializingBean 接口？还有 BeanPostProcessor 接口？
			 * 这里就是处理 bean 初始化完成后的各种回调
			 * 调用PostProcessor的前置和后置处理方法
			 * PostBeforeInit() -> init() -> PostAfterInit()
			 */
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}

		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		/**
		 * 05 拓展点：登记一下这个Bean在容器关闭的时候是否需要调用销毁的方法。  如果需要 放在 Map<String, Object> disposableBeans 变量中
		 * Spring中不但提供了对于初始化方法的扩展入口，同样也提供了销毁方法的扩展入口
 		 */
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		// 返回Bean
		return exposedObject;
	}
复制代码

• 调用构造函数创建Bean的实例
• 处理MergedBeanDefinitionPostProcessor类型的后置处理扩展方法
• 提前暴露Bean
• 填充Bean的属性
• 开始处理Bean初始化之后的各种回调接口，包括init，postProcessor等

createBeanInstance()：

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

		// 检查类的访问权限
		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		boolean resolved = false;
		//??
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				//无参构造器
				return instantiateBean(beanName, mbd);
			}
		}

		// Candidate constructors for autowiring?
		//判断是否采用有参构造函数
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// No special handling: simply use no-arg constructor.
		// 没有指定具体的构造器时，调用无参的构造函数初始化对象
		return instantiateBean(beanName, mbd);
	}
复制代码

initializeBean()

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			// 01 BeanPostProcessor 的 postProcessBeforeInitialization 回调
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			// 02 调用初始化方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			//03 BeanPostProcessor 的 postProcessAfterInitialization 回调
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}
复制代码

走到这里，一个Bean的初始化流程才算完成了，同时，大多数的BeanPostProcessor也是在这里实现了扩展Bean。

小结
基于注解的IOC容器的启动流程主要包括3部分
1.初始化Bean容器，资源路径扫描器等
2.根据Resource扫描BeanDefinition，根据TypeFilter选出需要装配的Bean。
3.整个容器的刷新(实例化Bean，各种Bean的扩展机制BeanPostProcessor，容器的回调，Bean的生命周期等)
4.Spring的扩展机制非常灵活，包括初始化一堆实现BeanPostProcessor接口的类，在容器不同生命周期的阶段，去挑选出来做回调处理。还运用了大量的模板方法模式，供子类去实现并且回调。
5.Spring的业务方法组织 一个大方法里包含很多小的逻辑单元，并且真正干活的方法以do…开头命名。其余的方法是做前期的准备工作。

还有一些比较细节的流程需要再接下来的文章中去探讨

1.Spring的单例或者原型模式的缓存工厂的具体实现流程?
2.Spring如何处理@Component，@Autowire这些常见注解?
3.SpringBoot是如何利用Spring的扩展机制来实现自动装配?