ApplicationContext拓展功能

关注

原创最新推荐文章于 2026-08-22 21:30:33 发布 807 阅读 AI 写同款· GEO 优化 ›

Spring中的Aware接口及应用场景 Aware接口是Spring Framework中提供的一组标记接口，用于在Bean装配的过程中获取Spring容器中提供的一些核心组件或运行时上下文等信息。通过使用Aware接口，我们可以在Bean实例化和初始化过程中获取到Spring容器中其他组件，方便Bean类实现更复杂的业务逻辑。本文将会一一介绍Spring中各个Aware接口，以及这些接口的主要应用场景。阅读详情

一、属性设置

对于ApplicationContext，其实例化前必须要设置的就是配置文件的路径--configLocation。例如：

对于非Web环境下的ClasspathXmlApplicationContext，需要通过构造函数或调用setConfigLocation设置配置文件路径；

对于Web环境下的XmlWebApplicationContext，会使用web.xml中配置的contextConfigLocation作为配置文件路径

//另外Web环境下使用的WebXmlApplicationContext还会保存ServletContext对象以及一些Web环境下的参数。

二、刷新上下文

refresh方法基本算是ApplicationContext最重要的方法之一，基本包含了ApplicationContext的大部分功能。需要注意的是，refresh方法并不是在ApplicationContext接口中定义的，而是在其子接口ConfigurableApplicationContext中定义的。下面是refresh的实现（代码位于AbstractApplicationContext）：

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 准备刷新的上下文
			prepareRefresh();

			// 初始化BeanFactory，并读取配置文件
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 对BeanFactory进行填充
			prepareBeanFactory(beanFactory);

			try {
				// 模版方法，由子类对初始化好的BeanFactory进行额外的处理
				postProcessBeanFactory(beanFactory);

				// 调用BeanFactoryPostProcessor后处理器
				invokeBeanFactoryPostProcessors(beanFactory);

				// 注册Bean处理器
				registerBeanPostProcessors(beanFactory);

				// 初始化Message源，与国际化处理相关
				initMessageSource();

				// 初始化应用消息广播器，并作为一个Bean注册到BeanFactory中
				initApplicationEventMulticaster();

				// 模版方法，交由子类实现，刷新前的特殊处理
				onRefresh();

				// 在注册的bean列表中查找Listener类型的bean，注册到消息广播器中
				registerListeners();

				// 提前初始化单例bean（非惰性的）
				finishBeanFactoryInitialization(beanFactory);

				// 通知生命周期处理器LifecycleProcessor刷新过程，并且发出ContextRefreshEvent事件
				finishRefresh();
			}

			catch (BeansException ex) {
				//log..
				// 销毁已经创建好的bean
				destroyBeans();
				// Reset 'active' flag.
				cancelRefresh(ex);
				throw ex;
			}
			finally {
				resetCommonCaches();
			}
		}
	}

刷新的流程为：

初始化的准备工作，如系统属性或环境变量的准备和验证
创建BeanFactory，并读取xml配置文件
对BeanFactory进行功能填充
通过模版方法模式，交由子类覆盖方法postProcessBeanFactory，对BeanFactory做额外处理
激活BeanFactory后处理器
注册拦截Bean创建的Bean处理器
初始化Message源
初始化消息广播器
留给子类初始化其他bean
将注册的Listener bean注册到消息广播器中
提前初始化单例bean（非惰性）
完成刷新，发出ContextRefreshEvent事件，并通知生命周期处理器LifecycleProcessor刷新过程

1、环境准备

主要是做些准备工作，对属性进行初始化和验证工作

	protected void prepareRefresh() {
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);
		
		//log...
		// 交由子类覆盖
		initPropertySources();

		// 验证需要的属性是否都已经被放入环境中
		getEnvironment().validateRequiredProperties();

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

2、加载BeanFactory

ApplicationContext通过obtainFreshBeanFactory函数创建BeanFactory，自此方法后也就拥有了BeanFactory的所有功能：

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		//委托给了refreshBeanFactory方法
		refreshBeanFactory();
		//因为创建BeanFactory实在子类中实现的，所以需要通过getBeanFactory才能获取到实例
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

下面是refreshBeanFactory的实现（位于AbstractRefreshableApplicationContext）：

	protected final void refreshBeanFactory() throws BeansException {
		//如果已经创建过BeanFactory，则销毁所有已经创建的Bean并且重新创建BeanFactory
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			//实例化
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			//设置一些属性
			customizeBeanFactory(beanFactory);
			//加载xml配置文件
			loadBeanDefinitions(beanFactory);
			//将BeanFactory实例设置到ApplicationContext中
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

初始化流程：

如果已经创建过，则销毁、清理掉以前创建的BeanFactory
实例化BeanFactory
定制BeanFactory
加载xml配置文件

a、实例化BeanFactory

实例化的代码比较简单，直接新建了一个DefaultListableBeanFactory，并且传入父ApplicationContext（如果存在的话）中的BeanFactory作为父BeanFactory，下面是实例化代码：

	protected DefaultListableBeanFactory createBeanFactory() {
		//如果存在父ApplicationContext，会通过它获取父BeanFactory传出构造函数
		return new DefaultListableBeanFactory(getInternalParentBeanFactory());
	}

getInternalParentBeanFactory实现：

	protected BeanFactory getInternalParentBeanFactory() {
		return (getParent() instanceof ConfigurableApplicationContext) ?
				((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent();
	}

如果父ApplicationContext类型是ConfigurableApplicationContext，则获取其中的BeanFactory，否则将父ApplicationContext作为BeanFactory传入。

b、定制BeanFactory

	protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
		//allowBeanDefinitionOverriding：是否允许覆盖同名称的不同定义的对象
		if (this.allowBeanDefinitionOverriding != null) {
			beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
		//allowCircularReferences：是否允许循环依赖
		if (this.allowCircularReferences != null) {
			beanFactory.setAllowCircularReferences(this.allowCircularReferences);
		}
	}

主要是对allowBeanDefinitionOverriding和allowCircularReferences属性进行设置，在AbstractRefreshableApplicationContext中并未对这两个属性进行设置，而是需要由子类来进行配置。

c、加载配置文件

	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// 为指定的BeanFactory创建XmlBeanDefinitionReader
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// 对XmlBeanDefinitionReader设置环境变量
		beanDefinitionReader.setEnvironment(getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		// 设置XmlBeanDefinitionReader的属性
		initBeanDefinitionReader(beanDefinitionReader);
		//加载配置文件
		loadBeanDefinitions(beanDefinitionReader);
	}

2、BeanFactory功能填充

对BeanFactory的功能填充是在prepareBeanFactory方法中完成的，再次之前，BeanFactory已经创建好并且完成了对xml配置文件的解析：

	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 设置BeanFactory的ClassLoader为当前Context的ClassLoader
		beanFactory.setBeanClassLoader(getClassLoader());
		//设置BeanFactory的表达式语言处理器，例如对#{bean.xx}调用相关值
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		//对bean属性等设置管理的工具
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// 添加PostPrecessor
		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.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// 添加PostPrecessor（该PostProcessor功能是对AspectJ的支持）
		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()));
		}

		// 在BeanFactory中注册系统环境Bean
		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());
		}
	}

上面代码中的拓展包括：

对SpEL（Spring Expression Language）的支持
对属性编辑器的支持
增加一些内置类，如EnvironmentAware、MessageSourceAware的信息注入
设置依赖功能需要忽略的接口
增加AspectJ的支持
将环境变量和属性注册的对象注册到BeanFactory中
注册了一些固定的依赖属性，如BeanFactory、ApplicationContext等

3、激活BeanFactory后处理器

BeanFactoryPostProcessor接口与BeanPostProcessor类似，能够在Bean创建过程中修改bean的定义信息。Spring允许BeanFactoryPostProcessor在容器实例化bean前读取bean定义，并可以修改它。下面是激活的代码：

	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		//激活BeanFactoryPostProcessor的功能委托给了PostProcessorRegistrationDelegate
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		//tempClassLoader为null && BeanFactory包含"loadTimeWeaver"名的bean
		//将loadTimeWeaver封装到一个BeanPostProcessor中
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

PostProcessorRegistrationDelegate中的实现：

	public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		// 存放处理过的BeanFactoryPostProcessor，避免重复添加、处理
		Set<String> processedBeans = new HashSet<String>();

		//BeanDefinitionRegistry的处理
		//因为DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，所以会进入下面的代码
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
			List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
					new LinkedList<BeanDefinitionRegistryPostProcessor>();
			/*
			*硬编码注册的后处理器
			*/
			//调用BeanDefinitionRegistryPostProcessor的额外方法
			//将处理器分类保存到registryPostProcessors和regularPostProcessors
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				//BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcesso,
				//并在BeanFactoryPostProcessor基础上还定义了postProcessBeanDefinitionRegistry方法
				//所以需要西先调用额外定义的方法
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryPostProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
					registryPostProcessors.add(registryPostProcessor);
				}
				else {
					//记录常规beanFactoryPostProcessors
					regularPostProcessors.add(postProcessor);
				}
			}

			/*
			*通过配置注册的BeanDefinitionRegistryPostProcessor后处理器
			*/
			//先获取的是后处理器的beanName列表，而不是后处理器的实例
			//Sping会依次处理实现了PriorityOrdered、Ordered接口的后处理器，最后处理剩下的常规后处理器
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

			// 处理实现了PriorityOrdered接口的后处理器，结果暂存到priorityOrderedPostProcessors
			List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			//排序（通过PriorityOrdered接口）
			sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
			//将结果添加到registryPostProcessors
			registryPostProcessors.addAll(priorityOrderedPostProcessors);
			//和上面一样，调用BeanDefinitionRegistryPostProcessor中自己定义的方法postProcessBeanDefinitionRegistry
			invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);

			//处理实现了Ordered接口的后处理器，结果暂存到orderedPostProcessors（处理过程和PriorityOrdered接口的类似）
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
			for (String ppName : postProcessorNames) {
				//该PostProcessor还未被处理过 && 实现了Ordered接口
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(beanFactory, orderedPostProcessors);	//排序（通过Ordered接口）
			//结果添加到registryPostProcessors
			registryPostProcessors.addAll(orderedPostProcessors);
			//和上面一样，调用BeanDefinitionRegistryPostProcessor中自己定义的方法postProcessBeanDefinitionRegistry
			invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);

			// 最后，处理剩下的BeanDefinitionRegistryPostProcessor
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				//获取所有BeanDefinitionRegistryPostProcessor类型的bean
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					//如果还未被处理过
					if (!processedBeans.contains(ppName)) {
						BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
						//将结果添加到registryPostProcessors
						registryPostProcessors.add(pp);
						processedBeans.add(ppName);
						//调用BeanDefinitionRegistryPostProcessor中自己定义的方法postProcessBeanDefinitionRegistry
						pp.postProcessBeanDefinitionRegistry(registry);
						reiterate = true;
					}
				}
			}

			// 调用BeanFactoryPostProcessor中定义的postProcessBeanFactory方法
			//（前面调用的都是registryPostProcessors，定义在BeanDefinitionRegistryPostProcessor中）
			invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// 调用BeanFactoryPostProcessor中定义的postProcessBeanFactory方法.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}
		/*
		*上面代码已经将硬编码的BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor和配置中的BeanDefinitionRegistryPostProcessor分类处理了
		*后面代码需要处理配置中的BeanFactoryPostProcessor类型的后处理器
		*/
		// 获取通过配置注册的BeanFactoryPostProcessor后处理器的beanName列表
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
				
		//Spring还是会将处理器分为排序和不需要排序两类，分别处理
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
		for (String ppName : postProcessorNames) {
			//过滤掉处理过的，剩下的就是配置中的BeanFactoryPostProcessor
			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);
			}
		}

		// 对实现了PriorityOrdered的处理器排序，并依次应用BeanFactoryPostProcessor
		sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// 对实现了Ordered的处理器排序，并依次应用BeanFactoryPostProcessor
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(beanFactory, orderedPostProcessors);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// 应用常规BeanFactoryPostProcessor
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// 因为可能修改了Bean的定义信息。所以需要清除缓存的merged beanDefinitions
		beanFactory.clearMetadataCache();
	}

Spring中少有的长代码。。

上面代码功能就是应用BeanFactoryPostProcessor后处理器。但是，由一点比较特特殊的是BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor，并且还定义了一个postProcessBeanDefinitionRegistry方法（BeanFactoryPostProcessor中只定义了一个方法-postProcessBeanFactory）。所以，在应用BeanFactoryPostProcessor后处理器中的postProcessBeanFactory方法前，需要先调用BeanDefinitionRegistryPostProcessor中的方法。

另外，向ApplicationContext中添加BeanFactoryPostProcessor的方法由两种：一是通过context直接调用addBeanFactoryPostProcessor硬编码添加；二是通过配置文件或@Component等注解向BeanFactory中注册一个BeanFactoryPostProcessor类型的bean。Spring针对两种配置，需要分类处理。

如果后处理器继承了PriorityOrdered或Ordered接口，Spring会优先将这些处理器排序后依次调用。（对于硬编码添加和配置添加的都会进行排序，但是对于Spring3以前的版本，并不会对硬编码方式添加的后处理器进行排序）

调用顺勋：PriorityOrdered --> Ordered --> 常规处理器

处理流程如下：

对BeanDefinitionRegistryPostProcessor的特殊处理，调用其postProcessBeanDefinitionRegistry方法
处理硬编码的所有BeanFactoryPostProcessor后处理器以及通过配置注册的BeanDefinitionRegistryPostProcessor后处理器：按照 PriorityOrdered --> Ordered --> 常规处理器 的顺序应用BeanFactoryPostProcessor中的方法
处理剩下的通过配置注册的BeanFactoryPostProcessor。因为BeanDefinitionRegistryPostProcessor已经在上一步中处理过了，这一步只需要按照 PriorityOrdered --> Ordered --> 常规处理器的顺序应用剩下的BeanFactoryPostProcessor

3、注册BeanPostProcessor

Spring的大部分功能都是通过BeanPostProcessor来拓展添加的，在这一步，Spring会将BeanFactory中所有的BeanPostProcessor类型的bean注册为后处理器，具体代码如下：

	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		//真正注册的功能委托给了PostProcessorRegistrationDelegate
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

PostProcessorRegistrationDelegate中的实现：

	public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
		//获取BeanFactory中所有BeanPostProcessor类型的beanName
		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.
		//注册一个特殊的BeanPostProcessor：BeanPostProcessorChecker
		//该后处理器的功能就是如果一个bean在BeanPostProcessor还没全部加载完成的时候创建，Spring会打印一条info级别的信息，
		//打印信息表明该bean并没有被所有BeanPostProcessor处理
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// 根据是否支持排序分类处理BeanPostProcessor
		// 处理顺序为PriorityOrdered -> Ordered -> 常规后处理器
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
		//内部使用的BeanPostProcessor（如果后处理器类型是MergedBeanDefinitionPostProcessor的话，会放入该列表）
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
		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);
			}
		}

		// 注册继承自PriorityOrdered接口的BeanPostProcessor
		sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// 注册继承自Ordered接口的BeanPostProcessor
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(beanFactory, orderedPostProcessors);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// 注册剩下的常规BeanPostProcessor
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		//最后重新注册一遍内部BeanPostProcessor（会将这些BeanPostProcessor放在列表最后）
		sortPostProcessors(beanFactory, internalPostProcessors);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// 会注册一个特殊的BeanPostProcessor
		// ApplicationListenerDetector的功能是将类型是 ApplicationListener 的bean添加到事件广播器
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

上述代码处理流程为：

注册BeanPostProcessorChecker。该BeanPostProcessor功能是：如果一个bean在BeanPostProcessor还没全部加载完成的时候创建，Spring会打印一条info级别的信息，该信息内容表明该创建的bean并未被所有BeanPostProcessor处理
查找出BeanFactory中所有BeanPostProcessor的bean，并作为BeanPostProcessor注册到BeanFactory中。同时支持排序接口，注册顺序为：PriorityOrdered -> Ordered -> 常规后处理器。比较特殊的是，MergedBeanDefinitionPostProcessor类型的后处理器是作为Spring内部使用的，所以会在添加到BeanPostProcessor列表末尾
注册ApplicationListenerDetector。该BeanPostProcessor功能：在创建bean的时候，如果bean类型是ApplicationListener ，会被添加到事件广播器

4、初始化消息资源

	protected void initMessageSource() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		//如果配置了messageSource，就将其实例保存到this.messageSource中
		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());
				}
			}
			//log...
		}
		else {
			// 如果用户没有定义，使用默认的DelegatingMessageSource作为messageSource
			DelegatingMessageSource dms = new DelegatingMessageSource();
			dms.setParentMessageSource(getInternalParentMessageSource());
			this.messageSource = dms;
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
			if (logger.isDebugEnabled()) {
				logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
						"': using default [" + this.messageSource + "]");
			}
		}
	}

5、初始化ApplicationEventMulticaster

事件广播器作用就是发布各种事件，然后由ApplicationListener处理（前面注册BeanPostProcessor中专门有一个ApplicationListenerDetector来注册用户配置的ApplicationListener），初始化并注册的代码如下：

	protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		//如果BeanFactory中包含名称为“applicationEventMulticaster”的bean，就使用该bean作为事件广播器
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			// log...
		}
		else {
			//使用默认的SimpleApplicationEventMulticaster作为广播器，并注册到BeanFactory中
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			//log...
		}
	}

6、注册监听器

在上一步初始化好事件广播器后，Spring接着会向其添加监听器：

	protected void registerListeners() {
		// 将前面硬编码方式注册的监听器添加到广播器中
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		//配置文件或者注解注册的监听器处理
		//为了使监听器得到后处理器的加工，这里并没有实例化监听器，而是保存beanName
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// 发布earlyApplicationEvents的事件
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

7、初始化非延迟单例

除了初始化单例bean以外，这一步还会完成一部分初始化BeanFactory的功能，包括：ConversionService的设置、冻结配置、设置EmbeddedValueResolver、初始化LoadTimeWeaverAware，源码如下：

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 初始化conversionService，如果存在的话
		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));
		}

		// 注册一个默认的StringValueResolver到embeddedValueResolver
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
				@Override
				public String resolveStringValue(String strVal) {
					return getEnvironment().resolvePlaceholders(strVal);
				}
			});
		}

		// 提前初始化 LoadTimeWeaverAware 
		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);

		// 冻结bean定义，表明注册的bean定义将无法再次被修改
		beanFactory.freezeConfiguration();

		// 初始化剩余的非延迟加载单例
		beanFactory.preInstantiateSingletons();
	}

下面是初始化非延加载单例的源码：

	public void preInstantiateSingletons() throws BeansException {
		//log...
		List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

		// 遍历beanNames，初始化其中的非惰性单例bean
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			//非Abstract || 单例 || 非惰性
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				//FactoryBean类型bean的处理
				if (isFactoryBean(beanName)) {
					//对于普通FactoryBean类型的bean，Spring会初始化其对应的FactoryBean，并不会初始化实际的bean
					final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
					boolean isEagerInit;
					//对于SmartFactoryBean类型并且isEagerInit返回true的bean，Spring会初始化真正的bean
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
							@Override
							public Boolean run() {
								return ((SmartFactoryBean<?>) factory).isEagerInit();
							}
						}, getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
				else {
					//普通bean直接调用getBean初始化
					getBean(beanName);
				}
			}
		}

对于FactoryBean，Spring会提前初始化其FactoryBean；如果类型是SmartFactoryBean并且isEagerInit 返回true（表示需要立即初始化），Spring才会初始化其真正的bean单例
对于普通bean，Spring会直接调用getBean进行初始化

8、finnishRefresh

在完成刷新上下文后，Spring会通知Lifecycle调用其start方法（销毁时会调用stop方法），进行生命周期管理；并且发布刷新完成的事件：

	protected void finishRefresh() {
		// 初始化lifecycleProcessor
		initLifecycleProcessor();

		// 通知lifecycleProcessor
		getLifecycleProcessor().onRefresh();

		// 发布ContextRefreshedEvent事件
		publishEvent(new ContextRefreshedEvent(this));

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