小白Spring学习记：Spring容器的整个创建流程（with 部分源码）

最新推荐文章于 2023-07-24 00:30:08 发布

千千晩星

最新推荐文章于 2023-07-24 00:30:08 发布

阅读量201

点赞数

分类专栏：笔记 java学习文章标签： java spring ioc bean

本文链接：https://blog.csdn.net/m0_46669243/article/details/111035245

版权

java学习同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

笔记

7 篇文章 0 订阅

订阅专栏

目前来说，Spring框架的重要性无需赘述，它良好的兼容性和适配性使得它经久不衰。本小白今天就来对Spring框架中的容器创建过程进行学习。
作为新手，含泪把整个生命周期流程进行了一番撕咬，终于明了一些。

直接从容器的创建说起：

在context的构造方法里，调用refresh()方法，进行容器的刷新创建的。

// refresh()刷新创建容器
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		this();
		register(componentClasses);
		refresh();

在refresh()方法中，是如下代码：

// refresh（）方法
public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

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

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

下面对各个方法进行大概的说明。

1、prepareRefresh（）：刷新前的预处理工作

//这个方法主要是进行一些属性设置的
	initPropertySources()：初始化一些属性设置
	getEnvironment().validateRequiredProperties()：获取环境信息，校验属性合法性
	this.earlyApplicationEvents = new LinkedHashSet<>()：一个LinkedHashSet记录早期的事件

// 预处理方法
protected void prepareRefresh() {
		// Switch to active.
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);

		if (logger.isDebugEnabled()) {
			if (logger.isTraceEnabled()) {
				logger.trace("Refreshing " + this);
			}
			else {
				logger.debug("Refreshing " + getDisplayName());
			}
		}

		// Initialize any placeholder property sources in the context environment.
		initPropertySources();

		// Validate that all properties marked as required are resolvable:
		// see ConfigurablePropertyResolver#setRequiredProperties
		getEnvironment().validateRequiredProperties();

		// Store pre-refresh ApplicationListeners...
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			// Reset local application listeners to pre-refresh state.
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}

		// Allow for the collection of early ApplicationEvents,
		// to be published once the multicaster is available...
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

2、 obtainFreshBeanFactory()：获取BeanFactory

这个方法是获取bean的：

// 
	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		return getBeanFactory();

refreshBeanFactory()方法：给BeanFactory设置id

// 
	protected final void refreshBeanFactory() throws IllegalStateException {
		if (!this.refreshed.compareAndSet(false, true)) {
			throw new IllegalStateException(
					"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
		}
		this.beanFactory.setSerializationId(getId());
	}

这个bean在类的构造方法中初始化了

// 
public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}

getBeanFactory()则是返回BeanFactory，默认是DefaultListableBeanFactory

// 
public final ConfigurableListableBeanFactory getBeanFactory() {
		return this.beanFactory;

3、 prepareBeanFactory()：Bean的预处理工作

下面展示一些 内联代码片。

给BeanFactory设置各种属性：
类加载器、表达式解析器、部分BeanPostProcessor、忽略注入接口、注册自动装配、添加BeanPostProcessor....

//设置属性
otected 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.
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		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.
		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.
		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());
		}
	}

4、 postProcessBeanFactory（）：Bean准备完成后的后置处理工作

该方法没有方法体，留给子类来重写，在BeanFactory创建并预处理完成之后做进一步处理设置

// 空方法
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	}

以上四步是 bean的创建和预处理工作。

5、 invokeBeanFactoryPostProcessors（）：执行BeanFactoryPostProcessor

该方法如下：

// An highlighted block
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

进入invoke方法：


   		
// 中心方法
public static void invokeBeanFactoryPostProcessors(
   		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

   	// Invoke BeanDefinitionRegistryPostProcessors first, if any.
   	Set<String> processedBeans = new HashSet<>();

   	if (beanFactory instanceof BeanDefinitionRegistry) {
   		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
   		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
   		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

   		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
   			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
   				BeanDefinitionRegistryPostProcessor registryProcessor =
   						(BeanDefinitionRegistryPostProcessor) postProcessor;
   				registryProcessor.postProcessBeanDefinitionRegistry(registry);
   				registryProcessors.add(registryProcessor);
   			}
   			else {
   				regularPostProcessors.add(postProcessor);
   			}
   		}

   		// Do not initialize FactoryBeans here: We need to leave all regular beans
   		// uninitialized to let the bean factory post-processors apply to them!
   		// Separate between BeanDefinitionRegistryPostProcessors that implement
   		// PriorityOrdered, Ordered, and the rest.
   		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

   		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
   		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);
   			}
   		}
   		sortPostProcessors(currentRegistryProcessors, beanFactory);
   		registryProcessors.addAll(currentRegistryProcessors);
   		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
   		currentRegistryProcessors.clear();

   		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
   		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
   		for (String ppName : postProcessorNames) {
   			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
   				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
   				processedBeans.add(ppName);
   			}
   		}
   		sortPostProcessors(currentRegistryProcessors, beanFactory);
   		registryProcessors.addAll(currentRegistryProcessors);
   		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
   		currentRegistryProcessors.clear();

   		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
   		boolean reiterate = true;
   		while (reiterate) {
   			reiterate = false;
   			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
   			for (String ppName : postProcessorNames) {
   				if (!processedBeans.contains(ppName)) {
   					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
   					processedBeans.add(ppName);
   					reiterate = true;
   				}
   			}
   			sortPostProcessors(currentRegistryProcessors, beanFactory);
   			registryProcessors.addAll(currentRegistryProcessors);
   			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
   			currentRegistryProcessors.clear();
   		}

   		// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
   		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
   		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
   	}

   	else {
   		// Invoke factory processors registered with the context instance.
   		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
   	}

   	// Do not initialize FactoryBeans here: We need to leave all regular beans
   	// uninitialized to let the bean factory post-processors apply to them!
   	String[] postProcessorNames =
   			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

   	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
   	// Ordered, and the rest.
   	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);
   		}
   	}

   	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
   	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

   	// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
   	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
   	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<>(nonOrderedPostProcessorNames.size());
   	for (String postProcessorName : nonOrderedPostProcessorNames) {
   		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   	}
   	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

   	// Clear cached merged bean definitions since the post-processors might have
   	// modified the original metadata, e.g. replacing placeholders in values...
   	beanFactory.clearMetadataCache();
   }

在此方法中：执行BeanPostProcessor（）

简略来说就是先拿到BeanFactory，先来判断是不是BeanDefinitionRegistry的实例，如果是，

判断该beanfactory是不是BeanDefinitionRegistryPostProcessor的实例（因为 BeanDefinitionRegistryPostProcessors是优于BeanFactoryPostProcessor执行的）；是的话放入registryProcessors集合中，不是的话放入regularPostProcessors集合中。
再根据是否实现优先级接口（PriorityOrdered、Ordered、none），依次执行相关方法。

// 排序、添加到registryProcessors集合中，执行方法
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

最后剩下的（未实现排序接口的）执行invoke()方法

// 
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

在回到开始，如果不是BeanDefinitionRegistry的实例：
执行完BeanDefinitionRegistryPostProcessor之后，
接着，执行BeanFactoryPostProcessor：
与之类似，排序、添加到集合中，执行方法，此处不做赘述…

6、 registerBeanPostProcessors（）：注册BeanPostProcessor

// 	
	public static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		// Register BeanPostProcessorChecker that logs an info message when
		// a bean is created during BeanPostProcessor instantiation, i.e. when
		// a bean is not eligible for getting processed by all BeanPostProcessors.
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		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)) {
				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);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		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.
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		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.
		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).
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

呃，简单来说就是根据BeanPostProcessor的优先级顺序，依次注册到BeanFactory中，最后还注册一个ApplicationListenerDetector，用来声明监听器。

7、 initMessageSource()：初始化MessageSource组件

该组件一般用作 国际化消息、消息绑定、消息解析等。

// 初始化messagesource组件
protected void initMessageSource() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
			this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
			// Make MessageSource aware of parent MessageSource.
			if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
				HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
				if (hms.getParentMessageSource() == null) {
					// Only set parent context as parent MessageSource if no parent MessageSource
					// registered already.
					hms.setParentMessageSource(getInternalParentMessageSource());
				}
			}
			if (logger.isTraceEnabled()) {
				logger.trace("Using MessageSource [" + this.messageSource + "]");
			}
		}
		else {
			// Use empty MessageSource to be able to accept getMessage calls.
			DelegatingMessageSource dms = new DelegatingMessageSource();
			dms.setParentMessageSource(getInternalParentMessageSource());
			this.messageSource = dms;
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
			}
		}
	}

简单来说，获取beanfactory，看容器中是否有id为messageSource，类型是MessageSource的组件：
有的话赋值给messageSource属性；
没有的话就创建一个DelegatingMessageSource()，复制给messageSource属性；
最后把messageSource组件加到容器中，方便后续使用。

8、 initApplicationEventMulticaster() ：初始化事件派发器

// An highlighted block
protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		else {
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
						"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
			}
		}
	}

首先，获取BeanFactory；
再来判断是否有applicationEventMulticaster，有的话直接获取。没有的话就新创建一个SimpleApplicationEventMulticaster，并加到BeanFactory中。

9、 onRefresh() ：刷新

该方法留给子类重写，在容器刷新时可以自定义逻辑。

// 空方法
protected void onRefresh() throws BeansException {
		// For subclasses: do nothing by default.
	}

10、 registerListeners() ：注册事件监听器

// 
protected void registerListeners() {
		// Register statically specified listeners first.
		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!
		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);
			}
		}
	}

简单来说，就是从容器中拿到所有的applicationListener，并把它们加到applicationEventMulticaster事件派发器中。最后还会把之前（第一步）早期的事件earlyApplicationEvents也加进来。

11、 finishBeanFactoryInitialization() ：完成剩余的BeanFactory的初始化

前面的省略了一些方法代码。

在此方法中，初始化剩下所有的非懒加载的单实例bean

// 关键一个方法

		// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();

点进去，

在第一个for循环中，拿到所有的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.
		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)) {
					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);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

在for循环中，拿到所有bean的定义信息，当bean不是抽象的，且是单例的，且不是懒加载的（懒加载的bean在用时才创建，初始化是不会创建），此时判断是否是FactoryBean的实例，若是则通过FactoryBean的方法创建bean；如果不是，调用getBean(beanName)创建bean实例；
当所有的bean都创建完毕后，在第二个for循环中，

// 判断是否是 SmartInitializingSingleton的实例
for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

// 检查这些bean是不是SmartInitializingSingleton的实例，是的话就执行smartSingleton.afterSingletonsInstantiated()方法

下面来看一下第一个循环中getBean()的大概执行流程：点进去

调用了doGetBean()方法：再点进去

下面来看一下第一个循环中getBean()的大概执行流程：点进去
调用了doGetBean()方法：再点进去

// 调用了doGetBean
@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

// doGetBean()方法
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.
		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);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// Check if bean definition exists in this factory.
			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);
				}
			}

			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				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);
						}
					}
				}

				// Create bean instance.
				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;
						}
					});
					bean = 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);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
					String scopeName = mbd.getScope();
					final 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);
							}
						});
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope '" + scopeName + "' is not active for the current thread; consider " +
								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
				if (logger.isTraceEnabled()) {
					logger.trace("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

	}

呃方法有点长哦，简明扼要的说，
首先，尝试获取单实例bean，因为之前如果创建的有，会自动放到缓存中。

// 
Object sharedInstance = getSingleton(beanName);

getSingleton()实际上是获取一个名字叫singletonObjects的Map，该map中保存了所有的bean实例（key是bean名称，value是bean的对象实例）

// 
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256)；

当获取不到时，开始bean的创建：

// 各种判断
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);
				}
			}

			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				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);
						}
					}
				}

大概就是是否有父BeanFactory、标记为已创建，拿到bean的定义信息，及判断是否有依赖bean，有的话执行getBean()先创建出来。

接下来是真正创建bean的实例的过程：

// 
// Create bean instance.
				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;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

调用了createBean(beanName, mbd, args)方法，点进去：

// 
try {
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}

首先调用resolveBeforeInstantiation()方法返回一个bean对象，意思是给BeanPostProcessors一个机会返回代理对象

// 
try {
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}

点进去

@Nullable
	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

大概是说，如果有hasInstantiationAwareBeanPostProcessors()，代表InstantiationAwareBeanPostProcessors后置处理器要提前执行了，先触发applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);返回bean，再触发 applyBeanPostProcessorsAfterInitialization(bean, beanName);返回个代理对象，完成bean的初始化；

当上面没有返回代理对象时，调用doCreateBean(beanName, mbdToUse, args)来创建bean实例：

// 
try {
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}

那么，doCreateBean()的执行流程是怎么样的呢？点进去

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

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		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.
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			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.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

额，挑几步最重要的步骤：

// An highlighted block
if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}

首先是：创建一个bean实例对象并赋值给实例包装对象，

try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}

然后如果是执行上面的方法，该方法是判断后置处理器是否为applyMergedBeanDefinitionPostProcessors的实例，是的话就执行postProcessMergedBeanDefinition方法。

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		}
	}

经过一些逻辑后，准备给bean属性赋值：

try {
			populateBean(beanName, mbd, instanceWrapper);
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}

点进去，

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}

		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
		// state of the bean before properties are set. This can be used, for example,
		// to support styles of field injection.
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						return;
					}
				}
			}
		}

		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}

		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						if (filteredPds == null) {
							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
						}
						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvsToUse == null) {
							return;
						}
					}
					pvs = pvsToUse;
				}
			}
		}
		if (needsDepCheck) {
			if (filteredPds == null) {
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

大概就是拿到后置处理器InstantiationAwareBeanPostProcessors，先后执行postProcessAfterInstantiation()和postProcessPropertyValues()方法，最后再执行applyPropertyValues()对属性进行赋值。
赋值结束后，执行bean的初始化操作：

protected Object initializeBean(final String beanName, final 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()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			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()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

1、执行Aware接口的方法：invokeAwareMethods(beanName, bean);
2、执行后置处理器的初始化之前方法：applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)
3、执行目标初始化方法：invokeInitMethods(beanName, wrappedBean, mbd);
4、执行后置处理器的初始化之后方法：applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)
5、还在最后定义了销毁bean的方法。

try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}

最后，把单实例bean添加到缓存中，方便之后的使用。即把bean添加到名字是singletonObjects的Map中。
至此，单实例bean的创建就全部完成了。

if (newSingleton) {
					addSingleton(beanName, singletonObject);
				}

=============================================================

12、 finishRe fresh() ：完成bean的初始化创建工作，ioc创建完成

protected void finishRefresh() {
		// Clear context-level resource caches (such as ASM metadata from scanning).
		clearResourceCaches();

		// Initialize lifecycle processor for this context.
		initLifecycleProcessor();

		// Propagate refresh to lifecycle processor first.
		getLifecycleProcessor().onRefresh();

		// Publish the final event.
		publishEvent(new ContextRefreshedEvent(this));

		// Participate in LiveBeansView MBean, if active.
		LiveBeansView.registerApplicationContext(this);
	}

1、清除资源缓存，释放资源；
2、初始化bean的生命周期后置处理器，对里面的lifecycleProcessor进行重写，届时容器会从容器找一个叫做lifecycleProcessor的组件，没有的话，会默认创建一个DefaultLifecycleProcessor;
3、拿到（2）里面的生命周期后置处理器，回调onRefresh()方法；
4、容器刷新会发布一个事件；
5、不是很懂呜呜呜，无关紧要

==================================================================

努力学习，发愤图强，为了梦想，为了鸣鸣冲冲冲！！！^ _ ^
^ _ ^ ^ _ ^

千千晩星

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
小白Spring学习记：Spring容器的整个创建流程（with 部分源码）

目前来说，Spring框架的重要性无需赘述，它良好的兼容性和适配性使得它经久不衰。本小白今天就来对Spring框架中的容器创建过程进行学习。作为新手，含泪把整个生命周期流程进行了一番撕咬，终于明了一些。直接从容器的创建说起：在context的构造方法里，调用refresh()方法，进行容器的刷新创建的。// refresh()刷新创建容器public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
复制链接

扫一扫