java源码 - Spring5.x（3）之 ApplicationContext#refresh

最新推荐文章于 2022-03-05 21:48:25 发布

everyD_struggle

最新推荐文章于 2022-03-05 21:48:25 发布

阅读量158

点赞数

分类专栏：源码文章标签： spring

本文链接：https://blog.csdn.net/littlewhitevg/article/details/107939741

版权

源码专栏收录该内容

35 篇文章 5 订阅

订阅专栏

ApplicationContext 相比BeanFactory提供了更多的扩展功能

1. ApplicationContext

在这里插入图片描述
请着重关注一下ClassPathXmlApplicationContext，AnnotationConfigApplicationContext这两个类。

2. ClassPathXmlApplicationContext

ApplicationContext bf= new ClassPathXrnlApplicationContext (”beanFactoryTest.xml”) ;

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
		this(new String[] {configLocation}, true, null);
	}
public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {

		super(parent);
		setConfigLocations(configLocations);
		if (refresh) {
			refresh();
		}
	}

调用的其父类的AbstractApplicationContext的refresh方法。

3. AbstractApplicationContext

refresh()

可以说refresh中包含了几乎ApplicationContext提供的全部功能。
org.springframework.context.support.AbstractApplicationContext#refresh
存在的模板方法调用需要我们十分注意，调用到哪里去了，所以我们得十分注意继承依赖关系。

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			//准备此上下文以进行刷新。
			prepareRefresh();

			//告诉子类刷新内部bean工厂。
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			//准备在此上下文中使用的bean工厂。
			prepareBeanFactory(beanFactory);

			try {
				//允许在上下文子类中对bean工厂进行后处理。
				postProcessBeanFactory(beanFactory);

				//调用上下文中注册为bean的工厂处理器。
				invokeBeanFactoryPostProcessors(beanFactory);

				//注册拦截bean创建的bean处理器。
				registerBeanPostProcessors(beanFactory);

				//为这个上下文初始化消息源。
				initMessageSource();

				//为这个上下文初始化事件多播器。
				initApplicationEventMulticaster();

			//初始化特定上下文子类中的其他特殊bean。
				onRefresh();

				//检查侦听器bean并注册它们。
				registerListeners();

				//实例化所有剩余的(非延迟-init)单例。
				finishBeanFactoryInitialization(beanFactory);

				//最后一步:发布相应的事件。
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				//销毁已经创建的单例，以避免悬空资源。
				destroyBeans();

				//重置“活动”标志。
				cancelRefresh(ex);

				//将异常传播给调用者。
				throw ex;
			}

			finally {
				//重置Spring核心中的普通自省缓存，因为我们
				//可能再也不需要单例bean的元数据了……
				resetCommonCaches();
			}
		}
	}

步骤如下：

初始化前额准备工作，例如对系统属性或者环境变量进行加载验证。
初始化 BeanFactory，并进行 XML 文件读取。
对BeanFactory 进行各种功能填充。
子类模板方法处理。
激活BeanFactory处理器。
注册拦截bean创建的bean处理器。
为上下文初始化message源。
初始化应用消息广播器。
留给子类来初始化其他bean。
在bean中查找listener bean并注册。
初始化剩下的单实例。
完成刷新过程。通知生命周期处理器 lifecycleProcessor 刷新过程，同时发出 ContextRefreshEvent 通知别人。
接下来详细看refresh方法

4. refresh

prepareRefresh()

/**
	*准备这个上下文来刷新，设置它的启动日期和
	*活动标志以及执行任何属性源的初始化。
	 */
	protected void prepareRefresh() {
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);

		if (logger.isInfoEnabled()) {
			logger.info("Refreshing " + this);
		}

		//初始化上下文环境中的任何占位符属性源 留给子类覆盖
		initPropertySources();

		//验证所有标记为必需的属性都是可解析的
		//看到ConfigurablePropertyResolver # setRequiredProperties
		getEnvironment().validateRequiredProperties();

		//允许收集早期申请事件，
		//一旦多播机可用，就会发布……
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}
	protected void initPropertySources() {
		// For subclasses: do nothing by default.
	}

initPropertySources是一个模板方法，留给子类实现个性化的属性处理及设置。
validateRequiredProperties是对属性的验证。
org.springframework.core.env.ConfigurablePropertyResolver接口内的方法：

/**
	*验证指定的每个属性
	* {@link #setRequiredProperties}出现并解析为
	*非{@code空}值。
	* @抛出MissingRequiredPropertiesException如果有任何需要
	属性不可解析。
* /
	void validateRequiredProperties() throws MissingRequiredPropertiesException;

这段代码的含义就是查找是否有遗失的必要属性。

	@Override
	public void validateRequiredProperties() {
		MissingRequiredPropertiesException ex = new MissingRequiredPropertiesException();
		for (String key : this.requiredProperties) {
			if (this.getProperty(key) == null) {
				ex.addMissingRequiredProperty(key);
			}
		}
		if (!ex.getMissingRequiredProperties().isEmpty()) {
			throw ex;
		}
	}

obtainFreshBeanFactory()

	/**
	 *告诉子类刷新内部bean工厂。
	 * @return fresh BeanFactory实例
	 * @see #refreshBeanFactory()
	 * @see #getBeanFactory()
	 */
	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}
	/*
	模板方法，子类实现这个来实现刷新BeanFactory的功能
	*/
protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;

ApplicationContext是对BeanFactory的功能上的扩展，不但包含了 BeanFactory 的全部功能更在其基础上添加了大量的扩展应用，那么obtainFreshBeanFactory正是实现 BeanFactory 的地方，也就是经过了这个函数后 ApplicationContext 就已经拥有了 BeanFactory 的全部功能。
org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory

/**
	*此实现执行上下文底层的实际刷新
	* bean工厂，关闭前一个bean工厂(如果有的话)和
	为上下文生命周期的下一阶段初始化一个新鲜的bean工厂。
	 */
	@Override
	protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
		//创建DefaultListableBeanFactory 
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			//为了序列化指定id，如果需要的话 让这个beanFactory从id 反序列beanFactory对象
			beanFactory.setSerializationId(getId());
			//定制 beanFactory，设置相关属性 包括是否允许覆盖名称的不 定义的对象以及循环依赖。
			//并设置@AutoWired @Qualifier注解解析器Qualif ierAnnotationAutowireCandidateResolver
			customizeBeanFactory(beanFactory);
			//初始化 DodumentReader ，加载类定义
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

从这里结合之前所看的，DefaultListableBeanFactory是Spring容器的基础。
除了5.x已经弃用的XmlBeanFactory，在org.springframework.context.support.AbstractRefreshableApplicationContext中：
在这里插入图片描述
其基本容器也是DefaultListableBeanFactory。

请找准AbstractRefreshableApplicationContext的位置。

customizeBeanFactory()

这里已开始了对 BeanFactory 的扩展，在基本容器的基础上，增加了是否允许覆盖是否
允许扩展的设置并提供了注解＠Qualifier 和＠Autowired 的支持。

/**
	定制这个上下文使用的内部bean工厂。
	*调用每个{@link #refresh()}尝试。
	默认的实现应用这个上下文的
	* {@linkplain # setallowbeandefinitionoverride " allowbeandefinitionoverride "}
	*和{@linkplain #setAllowCircularReferences "allowCircularReferences"}设置，
	*如果指定。可以在子类中覆盖以自定义任何
	 * {@link DefaultListableBeanFactory}'s settings.
	 * @param beanFactory the newly created bean factory for this context
	 * @see DefaultListableBeanFactory#setAllowBeanDefinitionOverriding
	 * @see DefaultListableBeanFactory#setAllowCircularReferences
	 * @see DefaultListableBeanFactory#setAllowRawInjectionDespiteWrapping
	 * @see DefaultListableBeanFactory#setAllowEagerClassLoading
	 */
	protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
	//如果属性allowBeanDefinitionOverriding不为空 ，设置给beanFactory相应属性。
	// 此属性的含义：是否允许覆盖同名称的不同定义的对象
		if (this.allowBeanDefinitionOverriding != null) {
			beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
	//如果属性allowCircularReferences 不为空 ，设置给beanFactory相应属性。
	// 此属性的含义：是否允许bean间存在循环依赖
		if (this.allowCircularReferences != null) {
			beanFactory.setAllowCircularReferences(this.allowCircularReferences);
		}
	}

loadBeanDefinitions()

交给子类来实现类定义的加载
org.springframework.context.support.AbstractRefreshableApplicationContext#loadBeanDefinitions

	/**
	*将bean定义加载到给定的bean工厂中，通常通过委托给一个或多个bean定义读取器。
	 * @param 加载bean定义的bean工厂
	 * @throws 如果bean定义解析失败，则异常
	 * @throws 如果加载bean定义文件失败，IOException异常
	 * @see org.springframework.beans.factory.support.PropertiesBeanDefinitionReader
	 * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader
	 */
	protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
			throws BeansException, IOException;

org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)



/**
	 *通过XmlBeanDefinitionReader加载bean定义。
	 * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader
	 * @see #initBeanDefinitionReader
	 * @see #loadBeanDefinitions
	 */
	@Override
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		//为给定的BeanFactory创建新的XmlBeanDefinitionReader。
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		//使用此上下文的bean定义读取器配置
		//资源加载环境。
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		//允许子类提供阅读器的自定义初始化，
		//然后继续实际加载bean定义。
		initBeanDefinitionReader(beanDefinitionReader);
		loadBeanDefinitions(beanDefinitionReader);
	}

在初始XmlBeanDefinitionReader 与DefaultListableBeanFactory后就可以进行配置文件的读取了。

	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			reader.loadBeanDefinitions(configResources);
		}
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			reader.loadBeanDefinitions(configLocations);
		}
	}

使用XmlBeanDefinitionReader loadBeanDefinitions 方法进行配置文件的加载机注册相信
大家不陌生，这完全就是开始BeanFactory的套路。XmlBeanDefinitionReader中已将之前初始化的 DefaultListableBeanFactory注册进了，所以XmlBeanDefinitionReader所读
取的BeanDefinitionHolder都会注册到 DefaultListableBeanFactory中，也就是经过此步骤，类型DefaultListableBeanFactory的变BeanFactory已经包含了所有解析好的配置。

prepareBeanFactory()

/**
	 * Configure the factory's standard context characteristics,
	 * such as the context's ClassLoader and post-processors.
	 * @param beanFactory the BeanFactory to configure
	 */
	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		//告诉内部bean工厂使用上下文的类装入器等。
		beanFactory.setBeanClassLoader(getClassLoader());
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		//用上下文回调配置bean工厂
		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接口在普通工厂中未注册为可解析类型。
	// MessageSource注册(并为自动装配找到)为bean。
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		//注册用于检测内部bean的早期后处理器作为应用程序监听器。
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	    //检测LoadTimeWeaver并准备编织(如果找到)。
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			//设置用于类型匹配的临时类加载器。
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

			//注册默认环境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());
		}
	}

这个方法对Application进行了几个方面扩展。

增加 SpEL语言的支持

SpEL 使用＃｛．．．｝作为定界符，所有在大框号中的字符都将被认为是 SpEL。
其设置到Spring中的代码为如下一句：

	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

其调用的时候，是在Spring在bean进行初始化的时候会有属性填充的一步，而在这一步
Spring 周用 AbstractAutowireCapableBeanFactory的applyPropertyValues函数来完成功能。

org.springframework.beans.factory.support.AbstractBeanFactory#evaluateBeanDefinitionString

/**
	*对包含在bean定义中的给定字符串求值，
	*潜在地将其解析为表达式。
	 * @param 设置要检查的值
	 * @param 值来自于的bean定义
	 * @return 解析后的价值
	 * @see #setBeanExpressionResolver
	 */
	@Nullable
	protected Object evaluateBeanDefinitionString(@Nullable String value, @Nullable BeanDefinition beanDefinition) {
		if (this.beanExpressionResolver == null) {
			return value;
		}

		Scope scope = null;
		if (beanDefinition != null) {
			String scopeName = beanDefinition.getScope();
			if (scopeName != null) {
				scope = getRegisteredScope(scopeName);
			}
		}
		return this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));
	}

当调用这个方法时会判断是否存在语言解析器，如果存在则调用语言解析器的方法进行解
析，解析的过程是在 Spring 的expression 的包内。

这个函数调用主要是在解析依赖注入bean 的时候，以及在完成 bean 的初始化和属性获取后进行属性填充的时候。

属性注册编辑器

Spring DI 注入的时候可以把普通属性注入进来，但是像 Date 类型就无法被识别。
但我们可以自定义一个属性编辑器将特定的String类型转换成Date类型。

通过继承 PropertyEditorSupport，重写SetAsText方法，然后注册到Spring的CustomEditorConfigurer中。
通过注册 Spring 自带的属性编辑器CustomDateEditor。

在bean的初始化后会调用 ResourceEditorRegistrar的registerCustomEditors方法进行批量的通用属性编辑器注册后，在属性填充的环节便可直接让Spring 使用这些编辑器进行属性的解析了。

addBeanPostProcessor()

	/**
	*为给定的上下文创建一个新的applicationcontext tawareprocessor。
	*/
	public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
		this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
	}

仔细一看，ApplicationContextAwareProcessor 实现了BeanPostProcessor接口。

class ApplicationContextAwareProcessor implements BeanPostProcessor {

在前面的学习中知道了，在 bean 实例化的时候，也就是Spring 激活 bean的init-method的前后，会调用 BeanPostProcessor的postProcessBeforelnitialization方法和postProcessAfterlnitialization方法。

	@Override
	@Nullable
	public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
		AccessControlContext acc = null;

		if (System.getSecurityManager() != null &&
				(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
						bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
						bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
			invokeAwareInterfaces(bean);
		}

		return bean;
	}
		@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		return bean;
	}

postProcessBeforeInitialization方法中调用了 invokeAwarelnterfaces。从invokeAwareinterfaces方法中，我们或许已经或多或少了解了 Spring 的用意，现这些 Aware接口的bean在被初始化之后，可以取得一些对应的资源。

	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof EnvironmentAware) {
				((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
			}
			if (bean instanceof EmbeddedValueResolverAware) {
				((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
			}
			if (bean instanceof ResourceLoaderAware) {
				((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
			}
			if (bean instanceof ApplicationEventPublisherAware) {
				((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
			}
			if (bean instanceof MessageSourceAware) {
				((MessageSourceAware) bean).setMessageSource(this.applicationContext);
			}
			if (bean instanceof ApplicationContextAware) {
				((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
			}
		}
	}

ignoreDependencyInterface()

当Spring将ApplicationContextAwareProcessor 注册后，那么在 invokeAwarelnterfaces 方法中间接调用的 Aware类已经不是普通的 bean ，如 ResourceLoaderAware、ApplicationEventPublisherAware，那么当然需要在Spring做bean的依赖注入的时候忽略它们。

registerResolvableDependency()

当注册了依赖解析后，例如当注册了对 BeanFactory.class 解析依赖后，当 bean 的属性注入的时候，一旦检测到属性为 BeanFactory 类型便会将beanFactory 的实例注入进去。

postProcessBeanFactory()

	/**
	*根据标准修改应用程序上下文的内部bean工厂
	*初始化。所有bean定义都已加载，但没有bean
	*还没有实例化。这允许注册特殊
	*在某些ApplicationContext实现中的beanpostprocessor等。
	 * @param 应用程序上下文使用的bean工厂
	 */
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	}

BeanFacotry 是Spring 容器功能基础，用于存放所有已经加载的 bean ，为了保证程序上的高可扩展性，Spring 针对 BeanFactory 了大量的扩展，比如我们熟知的PostProcessor等都是在这里实现的。

BeanFactoryPostProcessor 接口跟 BeanPostProcessor 类似，可以对 bean 的定义（配元数据）进行处理。也就是说，SpringIoC容器允许BeanFactoryPostProcessor在容器实际实例化任何其他的bean之前读取配置元数据，井有可能修改它。

但是要注意BeanFactoryPostProcessor是容器级的。无法跨容器使用。它仅仅对本容器的bean进行后置处理。

invokeBeanFactoryPostProcessors()

	/**
	*实例化和调用所有注册的BeanFactoryPostProcessor bean，
	*尊重明确的命令。
	*必须在singleton实例化之前被调用。
	 */
	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		//检测LoadTimeWeaver并准备编织(如果在此期间发现)
		//(例如通过ConfigurationClassPostProcessor注册的@Bean方法)
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

接着请关注PostProcessorRegistrationDelegate的静态方法invokeBeanFactoryPostProcessors。

PostProcessorRegistrationDelegate是AbstractApplicationContext委托执行post processors任务的工具类
这里的postProcessor包括两类 :

BeanFactoryPostProcessor
BeanPostProcessor
实际上BeanFactoryPostProcessor又细分为两类:

1.BeanDefinitionRegistryPostProcessor–BeanDefinitionRegistry后置处理器

2.BeanFactoryPostProcessor–BeanFactory后置处理器

BeanDefinitionRegistryPostProcessor其实继承自BeanFactoryPostProcessor,是一种特殊的BeanFactoryPostProcessor。BeanDefinitionRegistryPostProcessor的设计目的是在常规BeanFactoryPostProcessor处理BeanFactory(也就是容器)前先对bean注册做处理，比如注册更多的bean，实现此目的是通过BeanDefinitionRegistryPostProcessor定义的方法postProcessBeanDefinitionRegistry。

如果一个实现类是BeanDefinitionRegistryPostProcessor,那么它的postProcessBeanDefinitionRegistry方法总是要早与它的postProcessBeanFactory方法被调用。

/**
 * 调用BeanFactoryPostProcessor
 * 
 * @参数 beanFactory 应用上下文的 BeanFactory 实例
 * @参数 beanFactoryPostProcessors 应用上下文指定要执行的 BeanFactoryPostProcessor
**/
public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

	// 如果有的话，首先调用BeanDefinitionRegistryPostProcessors。
	Set<String> processedBeans = new HashSet<String>();

	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		
		// 用于记录常规 BeanFactoryPostProcessor
		List<BeanFactoryPostProcessor> regularPostProcessors = 
			new LinkedList<BeanFactoryPostProcessor>();
			
		// 用于记录 BeanDefinitionRegistryPostProcessor
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = 
			new LinkedList<BeanDefinitionRegistryPostProcessor>();
		
		// 遍历所有参数传递进来的 BeanFactoryPostProcessor(它们并没有作为bean注册在容器中)
        // 将所有参数传入的 BeanFactoryPostProcessor 分成两组 : 
        // BeanDefinitionRegistryPostProcessor 和常规 BeanFactoryPostProcessor
        // 1.如果是BeanDefinitionRegistryPostProcessor，现在执行postProcessBeanDefinitionRegistry()，
        // 2.否则记录为一个常规 BeanFactoryPostProcessor，现在不执行处理
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				registryProcessors.add(registryProcessor);
			}
			else {
				regularPostProcessors.add(postProcessor);
			}
		}

		//不要在这里初始化factorybean:我们需要保留所有常规bean
		//未初始化，让bean工厂后处理器应用到它们!
		// beandefinitionregistrypostprocessor之间的分离实现
		//排好序，点好，等等。
		// currentRegistryProcessors 用于记录当前正要被执行的BeanDefinitionRegistryPostProcessor
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = 
			new ArrayList<BeanDefinitionRegistryPostProcessor>();

		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
		// 1. 对 Bean形式 BeanDefinitionRegistryPostProcessor + PriorityOrdered 的调用
		// 找出所有容器中注册为bean存在的BeanDefinitionRegistryPostProcessor
		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);
		// Bean形式存在的 BeanDefinitionRegistryPostProcessor 也添加到 registryProcessors 中
		registryProcessors.addAll(currentRegistryProcessors);
				
		// 对bean形式存在的 BeanDefinitionRegistryPostProcessor 执行其对		
		// BeanDefinitionRegistry的postProcessBeanDefinitionRegistry()
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();//清空

		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
		// 2. 对 Bean形式 BeanDefinitionRegistryPostProcessor + 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);
		// Bean形式存在的 BeanDefinitionRegistryPostProcessor 也添加到 registryProcessors 中
		registryProcessors.addAll(currentRegistryProcessors);
		// 对Bean形式存在的 BeanDefinitionRegistryPostProcessor 执行其对		
		// BeanDefinitionRegistry的postProcessBeanDefinitionRegistry()		
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();//清空

		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
		// 3. 对 Bean形式 BeanDefinitionRegistryPostProcessor , 并且未实现
		// PriorityOrdered或者Ordered接口进行处理，直到没有未被处理的
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			postProcessorNames = beanFactory.getBeanNamesForType(
					BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName)) {
					// 发现了一个尚未被处理的 BeanDefinitionRegistryPostProcessor 
					currentRegistryProcessors.add(beanFactory.getBean(ppName, 
							BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
					reiterate = true;
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();//清空
		}

		// 现在，调用到目前为止处理的所有处理器的postProcessBeanFactory回调。
		// 因为BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor,所以这里
		// 也对所有 BeanDefinitionRegistryPostProcessor 调用其方法 postProcessBeanFactory()
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		// 对所有常规 BeanFactoryPostProcessor 调用其方法 postProcessBeanFactory()
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}

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

	// 以上逻辑执行了所有参数传入的和以bean定义方式存在的BeanDefinitionRegistryPostProcessor,
	// 也执行了所有参数传入的BeanFactoryPostProcessor, 但是尚未处理所有以bean定义方式存在的
	// BeanFactoryPostProcessor, 下面的逻辑处理这部分 BeanFactoryPostProcessor.

	// 不要在这里初始化factorybean:我们需要保留所有常规bean
	//未初始化，让bean工厂后处理器应用到它们!
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	// 将所有目前记录的所有BeanFactoryPostProcessor分成三部分 :
	// 1. 实现了 PriorityOrdered 接口的,
	// 2. 实现了 Ordered 接口的，
	// 3. 其他.
	// 接下来的逻辑会对这三种BeanFactoryPostProcessor分别处理
	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = 
										new ArrayList<BeanFactoryPostProcessor>();
	List<String> orderedPostProcessorNames = new ArrayList<String>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
	for (String ppName : postProcessorNames) {
		if (processedBeans.contains(ppName)) {
			// 跳过——已经在上面的第一阶段处理
		}
		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.
	// 1. 执行Bean形式 BeanFactoryPostProcessor + PriorityOrdered
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

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

	// Finally, invoke all other BeanFactoryPostProcessors.
	// 3. 执行Bean形式 BeanFactoryPostProcessor , 没有实现 PriorityOrdered 或者 Ordered 接口
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
	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();
}

对于BeanFactoryPostProcessor的处理主要分两种情况进行，一个是对于BeanDefinitionRegistry类的特殊处理。另一种是对普通的BeanFactoryPostProcessor 进行处理。而对于每种情况都需要考虑硬编码注入注册的后处理器以及通过配置注入的后处理器。
对BeanDefinitionRegistry型的处理类的处理主要包括以下内容：

对于硬编码注册的后处理器的处理，主要是通过 AbstractApplicatonContext 中的添加处理器方法 addBeanFactoryPostProcessor 进行添加。

	private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors = new ArrayList<>();
	@Override
	public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor) {
		Assert.notNull(postProcessor, "BeanFactoryPostProcessor must not be null");
		this.beanFactoryPostProcessors.add(postProcessor);
	}

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

	/**
	修改应用程序上下文的内部bean定义注册表
	*标准的初始化。所有常规bean定义都将被加载，
	但是还没有实例化bean。这允许进一步添加
	*下一个后处理阶段开始之前的bean定义。
	 * @param 应用程序上下文使用的bean定义注册表
	 * @throws org.springframework.beans。BeansException在错误的情况下
	 */
	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

BeanDefinitionRegistry主要使用了三个list完成。

		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

对 List 中的后处理器进行统一调用BeanFactoryPostProcessor的postProcessBeanFactory 方法。
对beanFactoryPostProcessors中非BeanDefinitionRegistryPostProcessor进行postProcessBeanFactory 方法调用。
普通beanFactory处理。

下面是两个例子：

@Component
public class MyBeanDefinitonRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("--- MyBeanDefinitonRegistryPostProcessor.postProcessBeanFactory 被执行了。");

    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        System.out.println("--- MyBeanDefinitonRegistryPostProcessor.postProcessBeanDefinitionRegistry 被执行了。");
    }

}
@Component
public class MyBeanDefinitonRegistryPostProcessor3 implements BeanDefinitionRegistryPostProcessor, PriorityOrdered {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("--- MyBeanDefinitonRegistryPostProcessor3.postProcessBeanFactory 被执行了。");

    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        System.out.println("--- MyBeanDefinitonRegistryPostProcessor3.postProcessBeanDefinitionRegistry 被执行了。");
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

registerBeanPostProcessors()

Spring提供了自动注册BeanPostProcessors的功能。例如：只要实现了InstantiationAwareBeanPostProcessor。
在这里插入图片描述
那么Spring便会自动在bean容器查找到该类并注册。

@Component
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
    public MyInstantiationAwareBeanPostProcessor() {
        super();
    }

    @Override
    public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
        return super.predictBeanType(beanClass, beanName);
    }

    @Override
    public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
        return super.determineCandidateConstructors(beanClass, beanName);
    }

    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        return super.getEarlyBeanReference(bean, beanName);
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return super.postProcessBeforeInstantiation(beanClass, beanName);
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInstantiation"+beanName);
        return super.postProcessAfterInstantiation(bean, beanName);
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        System.out.println("注入属性"+beanName);
        return super.postProcessPropertyValues(pvs, pds, bean, beanName);
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("实例初始化之前"+beanName);
        return super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("实例初始化之后"+beanName);
        return super.postProcessAfterInitialization(bean, beanName);
    }
}

	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

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

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

		//注册BeanPostProcessorChecker，当记录一个信息消息
		// bean是在BeanPostProcessor实例化期间创建的，即when
		//一个bean不能被所有beanpostprocessor处理。
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// 在实现优先排序的beanpostprocessor之间分离，
		// 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);
			}
		}

		//首先，注册实现PriorityOrdered的beanpostprocessor。
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		//接下来，注册实现Ordered的BeanPostProcessors。
		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);

		// 现在，注册所有常规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);

		//最后，重新注册所有内部beanpostprocessor。
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// 重新注册后处理器来检测内部bean作为应用监听器，
		//将其移动到处理器链的末端(用于拾取代理等)。
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

总结：
Spring的后处理器只要有两大类，一个是针对BeanDefinition的容器级别的后处理器 - BeanFactoryPostProcessor，一个是针对getBean操作获得的对象的后处理器 -BeanPostProcessor。

此两个后处理器不同之处主要有三点：

1、触发时机不同，前者BeanFactoryPostProcessor是在容器refresh方法中调用，而后者实际调用时机是在getBean方法获取对象时调用；

2、因触发时机不同导致二者处理的对象不同。BeanFactoryPostProcessor处理的是解析完配置文件后注册在容器中的BeanDefinition，而BeanPostProcessor处理的是通过反射生成的实例Bean；

使用的时候注意这两者的继承关系：
在这里插入图片描述

initMessageSource()

这是一个关于Spring国际化的方法。不多解释。

initApplicationEventMulticaster()

初始化事件传播器。

/**
	初始化ApplicationEventMulticaster。
	*使用SimpleApplicationEventMulticaster(如果上下文中没有定义的话)。
	 * @see org.springframework.context.event.SimpleApplicationEventMulticaster
	 */
	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.isDebugEnabled()) {
				logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		else {
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			if (logger.isDebugEnabled()) {
				logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
						APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
						"': using default [" + this.applicationEventMulticaster + "]");
			}
		}
	}

如果用户自定义了事件广播器，那么使用用户自定义的事件广播器。
没有则使用默认的ApplicationEventMulticaster。
ApplicationEventMulticaster的触发为multicastEvent方法。其遍历所有的监听器，并由监听器来决定当前接受时间是否需要触发。

	@Override
	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
		for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
			Executor executor = getTaskExecutor();
			if (executor != null) {
				executor.execute(() -> invokeListener(listener, event));
			}
			else {
				invokeListener(listener, event);
			}
		}
	}

onRefresh()

/**
	*模板方法，可以重写该方法以添加特定上下文的刷新工作。
	*在实例化单例对象之前调用特殊bean的初始化。
	 * <p>This implementation is empty.
	 * @throws BeansException in case of errors
	 * @see #refresh()
	 */
	protected void onRefresh() throws BeansException {
		// For subclasses: do nothing by default.
	}

registerListeners()

	/**
	*添加实现ApplicationListener的bean作为侦听器。
	*不影响其他侦听器，可以添加其他侦听器而不使用bean。
	 */
	protected void registerListeners() {
		//先注册静态指定的监听器。
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

	//不要在这里初始化factorybean:我们需要保留所有常规bean
	//未初始化，让后处理器应用到它们!
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

	//发布早期的应用事件，现在我们终于有了多播机…
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

finishBeanFactoryInitialization()

完成 BeanFactory 的初始化，其中包括 ConvesionService 的设置、非延迟加载的bean 的初始化。

	/**
	*完成这个上下文的bean工厂的初始化，
	*初始化所有剩余的单例bean。
	 */
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		//为这个上下文初始化转换服务。
		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));
		}

		//如果没有bean后处理器，注册一个默认的嵌入式值解析器
		//(例如PropertyPlaceholderConfigurer bean)在以下情况下注册:
		//此时，主要用于解析注释属性值。
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		//尽早初始化LoadTimeWeaverAware bean，以便尽早注册它们的转换器。
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		//停止使用临时类加载器进行类型匹配。
		beanFactory.setTempClassLoader(null);

		//允许缓存所有bean定义元数据，不期望进一步更改。
		beanFactory.freezeConfiguration();

		//实例化所有剩余的(非延迟-init)单例。
		beanFactory.preInstantiateSingletons();
	}

ConversionService()

之前我们提到过使用自定义型转换器从 String 转换为 Date 的方式，那么 Sprin
还提供了另一种转换方式：使用 Coverter。

public class DateConverter implements Converter<String,Date>{
    @Override
    public Date convert(String source) {
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-dd-mm");
        Date date=null;
        if(StringUtils.isEmpty(source)) {
            return null;
        }
        try {
            date= sdf.parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

@Configuration
public class WebConfiguration {
    
    @Bean
    public GenericConversionService getGenericConversionService(@Autowired GenericConversionService conversionService) {
        conversionService.addConverter(new DateConverter());
        System.out.println("类型转换已加入！");
        return conversionService;
        
    }
}

freezeConfiguration()

冻结所有的bean定义，说明注册的 bean 定义将不被修改或进行任何进一步的处理。

preInstantiateSingletons()

@Override
	public void preInstantiateSingletons() throws BeansException {
		if (logger.isDebugEnabled()) {
			logger.debug("Pre-instantiating singletons in " + this);
		}

	//迭代一个副本以允许init方法注册新的bean定义。
	//虽然这可能不是常规工厂引导程序的一部分，但它在其他方面工作得很好。
		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);
				}
			}
		}

ApplicationContext 实现的默认行为就是在启动时将所有单例 bean 提前进行实例化。

finishRefresh()

/**
	*调用LifecycleProcessor来完成这个上下文的刷新
	方法，并发布
	 * {@link org.springframework.context.event.ContextRefreshedEvent}.
	 */
	protected void finishRefresh() {
		//清除上下文级资源缓存(如扫描的ASM元数据)。
		clearResourceCaches();

		//为这个上下文初始化生命周期处理器。
		initLifecycleProcessor();

		//首先将刷新传播到生命周期处理器。
		getLifecycleProcessor().onRefresh();

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

		//参与LiveBeansViewMBean，如果是活动的。
		LiveBeansView.registerApplicationContext(this);
	}

clearResourceCaches()

public void clearResourceCaches() {
		this.resourceCaches.clear();
	}

initLifecycleProcessor()

当ApplicationContext 启动或停止时，它通过lifecycleProcessor 来与所有声明的 bean
周期做状态更新，而在 LifecycleProcessor 的使用前需要初始化。

protected void initLifecycleProcessor() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
			this.lifecycleProcessor =
					beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
			if (logger.isDebugEnabled()) {
				logger.debug("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
			}
		}
		else {
			DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
			defaultProcessor.setBeanFactory(beanFactory);
			this.lifecycleProcessor = defaultProcessor;
			beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
			if (logger.isDebugEnabled()) {
				logger.debug("Unable to locate LifecycleProcessor with name '" +
						LIFECYCLE_PROCESSOR_BEAN_NAME +
						"': using default [" + this.lifecycleProcessor + "]");
			}
		}
	}

getLifecycleProcessor().onRefresh()

启动所有 Lifecycle 接口的 bean；

	//org.springframework.context.support.DefaultLifecycleProcessor#start
	@Override
	public void onRefresh() {
		startBeans(true);
		this.running = true;
	}
	//org.springframework.context.support.DefaultLifecycleProcessor#startBeans
	private void startBeans(boolean autoStartupOnly) {
		Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
		Map<Integer, LifecycleGroup> phases = new HashMap<>();
		lifecycleBeans.forEach((beanName, bean) -> {
			if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
				int phase = getPhase(bean);
				LifecycleGroup group = phases.get(phase);
				if (group == null) {
					group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
					phases.put(phase, group);
				}
				group.add(beanName, bean);
			}
		});
		if (!phases.isEmpty()) {
			List<Integer> keys = new ArrayList<>(phases.keySet());
			Collections.sort(keys);
			for (Integer key : keys) {
				phases.get(key).start();
			}
		}
	}

publishEvent()

当完成 pplicationContext 初始化的时候，要通过Spring 中的件发布机制来发出 Context
RefreshedEvent 事件，以保证对应的监听器可以做进一步的逻辑处理。

	protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
		Assert.notNull(event, "Event must not be null");
		if (logger.isTraceEnabled()) {
			logger.trace("Publishing event in " + getDisplayName() + ": " + event);
		}

		//如有必要，可将装修活动作为申请活动
		ApplicationEvent applicationEvent;
		if (event instanceof ApplicationEvent) {
			applicationEvent = (ApplicationEvent) event;
		}
		else {
			applicationEvent = new PayloadApplicationEvent<>(this, event);
			if (eventType == null) {
				eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
			}
		}

	//如果可能的话马上进行组播——或者在组播初始化后延迟
		if (this.earlyApplicationEvents != null) {
			this.earlyApplicationEvents.add(applicationEvent);
		}
		else {
			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
		}

	//通过父上下文发布事件…
		if (this.parent != null) {
			if (this.parent instanceof AbstractApplicationContext) {
				((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
			}
			else {
				this.parent.publishEvent(event);
			}
		}
	}

registerApplicationContext()

属于JNDI 资源名称一部分的内容。
org.springframework.context.support.LiveBeansView#registerApplicationContext

static void registerApplicationContext(ConfigurableApplicationContext applicationContext) {
		String mbeanDomain = applicationContext.getEnvironment().getProperty(MBEAN_DOMAIN_PROPERTY_NAME);
		if (mbeanDomain != null) {
			synchronized (applicationContexts) {
				if (applicationContexts.isEmpty()) {
					try {
						MBeanServer server = ManagementFactory.getPlatformMBeanServer();
						applicationName = applicationContext.getApplicationName();
						server.registerMBean(new LiveBeansView(),
								new ObjectName(mbeanDomain, MBEAN_APPLICATION_KEY, applicationName));
					}
					catch (Throwable ex) {
						throw new ApplicationContextException("Failed to register LiveBeansView MBean", ex);
					}
				}
				applicationContexts.add(applicationContext);
			}
		}
	}