Spring源码学习（十一）--启动流程

前言

通常，我们说的Spring启动，就是构造ApplicationContext对象以及调用refresh()方法的过程。​

之前已经在本地编译好了spring源码，也新建了一个子模块用来测试，可以断点一步一步的跟代码。

Spring IoC容器的加载过程

1.实例化化容器：AnnotationConfigApplicationContext

从这里出发：（这里使用的时javaconfig注解的方式，因为设计理念更先进，在对bean定义读取和操作方面使用了BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor，进行解耦，而xml是耦合的，当然在bean工厂去创建bean的地方是一样的）

//加载spring上下文
ApplicationContext context=new AnnotationConfigApplicationContext(MyConfig.class);

AnnotationConfigApplicationContext的结构关系： 

 创建AnnotationConfigApplicationContext对象：

	public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		//调用无参构造函数，会先调用父类GenericApplicationContext的构造函数
		//父类的构造函数里面就是初始化DefaultListableBeanFactory，并且赋值给beanFactory
		//本类的构造函数里面，初始化了一个读取器：AnnotatedBeanDefinitionReader read，一个扫描器ClassPathBeanDefinitionScanner scanner
		//scanner的用处不是很大，它仅仅是在我们外部手动调用 .scan 等方法才有用，常规方式是不会用到scanner对象的
		this();
		//把传入的类进行注册，这里有两个情况，
		//传入传统的配置类
		//传入bean（虽然一般没有人会这么做
		//看到后面会知道spring把传统的带上@Configuration的配置类称之为FULL配置类，不带@Configuration的称之为Lite配置类
		//但是我们这里先把带上@Configuration的配置类称之为传统配置类，不带的称之为普通bean
		register(componentClasses);
		//IOC容器刷新
		refresh();
	}

我们先来为构造方法做一个简单的说明：

1. 这是一个有参的构造方法，可以接收多个配置类，不过一般情况下，只会传入一个配置类。
2. 这个配置类有两种情况，一种是传统意义上的带上@Configuration注解的配置类，还有一种是没有带上@Configuration，但是带有@Component，@Import，@ImportResouce，@Service，@ComponentScan等注解的配置类，在Spring内部把前者称为Full配置类，把后者称之为Lite配置类。在本源码分析中，有些地方也把Lite配置类称为普通Bean。

使用断点调试，通过this()调用此类无参的构造方法，代码到下面：

首先无参构造方法中就是对读取器reader和扫描器scanner进行了实例化，reader的类型是AnnotatedBeanDefinitionReader，可以看出它是一个 “打了注解的Bean定义读取器”，scanner的类型是ClassPathBeanDefinitionScanner，它仅仅是在外面手动调用.scan方法，或者调用参数为String的构造方法，传入需要扫描的包名才会用到，像这样方式传入的配置类是不会用到这个scanner对象的。

AnnotationConfigApplicationContext类是有继承关系的，会隐式调用父类的构造方法：

下面代码

2.实例化工厂：DefaultListableBeanFactory

 

DefaultListableBeanFactory的关系图：

 可以看出DefaultListableBeanFactory是最底层的实现，功能是最全的，DefaultListableBeanFactory是相当重要的，从字面意思就可以看出它是一个Bean的工厂，什么是Bean的工厂？当然就是用来生产和获得Bean的。

3.实例化BeanDefinition读取器： AnnotatedBeanDefinitionReader

调用完父类的构造方法后，断点继续走，会实例化一个BeanDefinition读取器

让我们把目光回到AnnotationConfigApplicationContext的无参构造方法，让我们看看Spring在初始化AnnotatedBeanDefinitionReader的时候做了什么

	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
		this(registry, getOrCreateEnvironment(registry));
	}

这里的BeanDefinitionRegistry当然就是AnnotationConfigApplicationContext的实例了，这里又直接调用了此类其他的构造方法：

	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		Assert.notNull(environment, "Environment must not be null");
		//把ApplicationContext对象赋值给AnnotatedBeanDefinitionReader对象的BeanDefinitionRegistry
		this.registry = registry;
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
		//注册一些配置的后置处理器
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

让我们把目光移动到这个方法的最后一行，进入registerAnnotationConfigProcessors方法：

	public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
		registerAnnotationConfigProcessors(registry, null);
	}

 这又是一个门面方法，再点进去，这个方法的返回值Set，但是上游方法并没有去接收这个返回值，所以这个方法的返回值也不是很重要了，当然方法内部给这个返回值赋值也不重要了。

	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			//注册了实现Order接口的排序器
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			//设置@AutoWired的候选的解析器
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

		/**
		 * 为我们容器中注册了解析我们配置类的后置处理器ConfigurationClassPostProcessor
		 * 名字叫:org.springframework.context.annotation.internalConfigurationAnnotationProcessor
		 */
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		/**
		 * 为我们容器中注册了处理@Autowired 注解的处理器AutowiredAnnotationBeanPostProcessor
		 * 名字叫:org.springframework.context.annotation.internalAutowiredAnnotationProcessor
		 */
		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}


		/**
		 * 为我们容器注册处理JSR规范的注解处理器CommonAnnotationBeanPostProcessor
		 * org.springframework.context.annotation.internalCommonAnnotationProcessor
		 */
		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		/**
		 * 处理jpa注解的处理器org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor
		 */
		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		/**
		 * 处理监听方法的注解解析器EventListenerMethodProcessor
		 */
		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}

		/**
		 * 注册事件监听器工厂
		 */
		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}

这个方法的核心就是注册Spring内置的多个Bean，我们以其中一个最主要的ConfigurationClassPostProcessor代码来看：

		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

1. 判断容器中是否已经存在了ConfigurationClassPostProcessor Bean
2. 如果不存在（当然这里肯定是不存在的），就通过RootBeanDefinition的构造方法获得ConfigurationClassPostProcessor的BeanDefinition，RootBeanDefinition是BeanDefinition的子类
3. 执行registerPostProcessor方法，registerPostProcessor方法内部就是注册Bean，当然这里注册其他Bean也是一样的流程。

BeanDefinition是什么？

BeanDefinition联系图

向上

• BeanMetadataElement接口：BeanDefinition元数据，返回该Bean的来源
• AttributeAccessor接口：提供对BeanDefinition属性操作能力，

向下

它是用来描述Bean的，里面存放着关于Bean的一系列信息，比如Bean的作用域，Bean所对应的Class，是否懒加载，是否Primary等等，这个BeanDefinition也相当重要，我们以后会常常和它打交道。**

registerPostProcessor方法：

	private static BeanDefinitionHolder registerPostProcessor(
			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

		definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		registry.registerBeanDefinition(beanName, definition);
		return new BeanDefinitionHolder(definition, beanName);
	}

这方法为BeanDefinition设置了一个Role，ROLE_INFRASTRUCTURE代表这是spring内部的，并非用户定义的，然后又调用了registerBeanDefinition方法，再点进去，你会发现它是一个接口，没办法直接点进去了，首先要知道registry实现类是什么，那么它的实现是什么呢？答案是GenericApplicationContext

 这里将传进来的AnnotationConfigApplicationContext对象赋值给力registry，而AnnotationConfigApplicationContext的父类GenericApplicationContext实现了BeanDefinitionRegistry

 GenericApplicationContext的registerBeanDefinition方法：

	@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
	}

这又是一个门面方法，再点进去，核心在于下面两行代码：

//beanDefinitionMap是Map<String, BeanDefinition>，
//这里就是把beanName作为key，ScopedProxyMode作为value，推到map里面
this.beanDefinitionMap.put(beanName, beanDefinition);

//beanDefinitionNames就是一个List<String>,这里就是把beanName放到List中去
this.beanDefinitionNames.add(beanName);

从这里可以看出DefaultListableBeanFactory就是我们所说的容器了，里面放着beanDefinitionMap，beanDefinitionNames，beanDefinitionMap是一个hashMap，beanName作为Key,beanDefinition作为Value，beanDefinitionNames是一个集合，里面存放了beanName。

打个断点，第一次运行到这里，监视这两个变量：

DefaultListableBeanFactory中的beanDefinitionMap，beanDefinitionNames也是相当重要的，以后会经常看到它，最好看到它，第一时间就可以反应出它里面放了什么数据

这里仅仅是注册，可以简单的理解为把一些原料放入工厂，工厂还没有真正的去生产。

上面已经介绍过，这里会一连串注册好几个Bean，在这其中最重要的一个Bean（没有之一）就是BeanDefinitionRegistryPostProcessor Bean。

ConfigurationClassPostProcessor实现BeanDefinitionRegistryPostProcessor接口，BeanDefinitionRegistryPostProcessor接口又扩展了BeanFactoryPostProcessor接口，BeanFactoryPostProcessor是Spring的扩展点之一，ConfigurationClassPostProcessor是Spring极为重要的一个类，必须牢牢的记住上面所说的这个类和它的继承关系。

BeanFactoryPostProcessor

BeanPostProcessor表示Bean的后置处理器，是用来对Bean进行加工的，类似的，BeanFactoryPostProcessor理解为BeanFactory的后置处理器，用来用对BeanFactory进行加工的。​

Spring支持用户定义BeanFactoryPostProcessor的实现类Bean，来对BeanFactory进行加工，比如：

@Component
public class FztxBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		BeanDefinition beanDefinition = beanFactory.getBeanDefinition("userService");
		beanDefinition.setAutowireCandidate(false);
	}
}

以上代码，就利用了BeanFactoryPostProcessor来拿到BeanFactory，然后获取BeanFactory内的某个BeanDefinition对象并进行修改，注意这一步是发生在Spring启动时，创建单例Bean之前的，所以此时对BeanDefinition就行修改是会生效的。​

注意：在ApplicationContext内部有一个核心的DefaultListableBeanFactory，它实现了ConfigurableListableBeanFactory和BeanDefinitionRegistry接口，所以ApplicationContext和DefaultListableBeanFactory是可以注册BeanDefinition的，但是ConfigurableListableBeanFactory是不能注册BeanDefinition的，只能获取BeanDefinition，然后做修改。

所以Spring还提供了一个BeanFactoryPostProcessor的子接口：BeanDefinitionRegistryPostProcessor​

BeanDefinitionRegistryPostProcessor

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

我们可以看到BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor接口，并新增了一个方法，注意方法的参数为BeanDefinitionRegistry，所以如果我们提供一个类来实现BeanDefinitionRegistryPostProcessor，那么在postProcessBeanDefinitionRegistry()方法中就可以注册BeanDefinition了。比如：​

@Component
public class FztxBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
		beanDefinition.setBeanClass(User.class);
		registry.registerBeanDefinition("user", beanDefinition);
	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		BeanDefinition beanDefinition = beanFactory.getBeanDefinition("userService");
		beanDefinition.setAutowireCandidate(false);
	}
}

除了注册了ConfigurationClassPostProcessor，还注册了其他Bean，其他Bean也都实现了其他接口，比如BeanPostProcessor等。

BeanPostProcessor接口也是Spring的扩展点之一。

至此，实例化AnnotatedBeanDefinitionReader reader分析完毕。

其主要做了2件事情

1.注册内置BeanPostProcessor

2.注册相关的BeanDefinition

4.创建BeanDefinition扫描器:ClassPathBeanDefinitionScanner

由于常规使用方式是不会用到AnnotationConfigApplicationContext里面的scanner的，这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法。所以这里就不看scanner是如何被实例化的了。

5.注册配置类为BeanDefinition： register(annotatedClasses)

把目光回到最开始，再分析第二行代码：

 这里传进去的是一个数组，最终会循环调用如下方法：

	private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
			@Nullable BeanDefinitionCustomizer[] customizers) {

		//AnnotatedGenericBeanDefinition可以理解为一种数据结构，是用来描述Bean的，这里的作用就是把传入的标记了注解的类
		//转为AnnotatedGenericBeanDefinition数据结构，里面有一个getMetadata方法，可以拿到类上的注解
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);

		//判断是否需要跳过注解，spring中有一个@Condition注解，当不满足条件，这个bean就不会被解析
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}

		abd.setInstanceSupplier(supplier);
		//解析bean的作用域，如果没有设置的话，默认为单例
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		abd.setScope(scopeMetadata.getScopeName());

		//获得beanName
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

		//解析通用注解，填充到AnnotatedGenericBeanDefinition，解析的注解为Lazy，Primary，DependsOn，Role，Description
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

		//限定符处理，不是特指@Qualifier注解，也有可能是Primary,或者是Lazy，或者是其他（理论上是任何注解，这里没有判断注解的有效性），如果我们在外面，以类似这种
		//AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Appconfig.class);常规方式去初始化spring，
		//qualifiers永远都是空的，包括上面的name和instanceSupplier都是同样的道理
		//但是spring提供了其他方式去注册bean，就可能会传入了
		if (qualifiers != null) {
			//可以传入qualifier数组，所以需要循环处理
			for (Class<? extends Annotation> qualifier : qualifiers) {
				//Primary注解优先
				if (Primary.class == qualifier) {
					abd.setPrimary(true);
				}
				//Lazy注解
				else if (Lazy.class == qualifier) {
					abd.setLazyInit(true);
				}
				//其他，AnnotatedGenericBeanDefinition有个Map<String,AutowireCandidateQualifier>属性，直接push进去
				else {
					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
				}
			}
		}
		if (customizers != null) {
			for (BeanDefinitionCustomizer customizer : customizers) {
				customizer.customize(abd);
			}
		}

		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		//注册，最终会调用DefaultListableBeanFactory中的registerBeanDefinition方法去注册，
		//DefaultListableBeanFactory维护着一系列信息，比如beanDefinitionNames，beanDefinitionMap
		//beanDefinitionNames是一个List<String>,用来保存beanName
		//beanDefinitionMap是一个Map,用来保存beanName和beanDefinition
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

在这里又要说明下，以常规方式去注册配置类，此方法中除了第一个参数，其他参数都是默认值（null）。

1. 通过AnnotatedGenericBeanDefinition的构造方法，获得配置类的BeanDefinition，这里是不是似曾相似，在注册ConfigurationClassPostProcessor类的时候，也是通过构造方法去获得BeanDefinition的，只不过当时是通过RootBeanDefinition去获得，现在是通过AnnotatedGenericBeanDefinition去获得。

1. 判断需不需要跳过注册，Spring中有一个@Condition注解，如果不满足条件，就会跳过这个类的注册。
2. 然后是解析作用域，如果没有设置的话，默认为单例。
3. 获得BeanName。
4. 解析通用注解，填充到AnnotatedGenericBeanDefinition，解析的注解为Lazy，Primary，DependsOn，Role，Description。
5. 限定符处理，不是特指@Qualifier注解，也有可能是Primary，或者是Lazy，或者是其他（理论上是任何注解，这里没有判断注解的有效性）。
6. 把AnnotatedGenericBeanDefinition数据结构和beanName封装到一个对象中（这个不是很重要，可以简单的理解为方便传参）。
7. 注册，最终会调用DefaultListableBeanFactory中的registerBeanDefinition方法去注册：

BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry)

	public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		//获取beanName
		// Register bean definition under primary name.
		String beanName = definitionHolder.getBeanName();

		//注册bean
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// Register aliases for bean name, if any.
		//Spring支持别名
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

这个registerBeanDefinition是不是又有一种似曾相似的感觉，没错，在上面注册Spring内置的Bean的时候，已经解析过这个方法了，这里就不重复了，此时，让我们再观察下beanDefinitionMap beanDefinitionNames两个变量，除了Spring内置的Bean，还有我们传进来的Bean，这里的Bean当然就是我们的配置类了：

到这里注册配置类也分析完毕了。

6.refresh()

大家可以看到其实到这里，Spring还没有进行扫描，只是实例化了一个工厂，注册了一些内置的Bean和我们传进去的配置类，真正的大头是在第三行代码：

 这个方法做了很多事情，让我们点开这个方法：

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		//1:准备刷新上下文环境
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		//2:获取告诉子类初始化Bean工厂
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		//3:对bean工厂进行填充属性
		// 准备BeanFactory
		// 1. 设置BeanFactory的类加载器、表达式解析器、类型转化注册器
		// 2. 添加三个BeanPostProcessor，注意是具体的BeanPostProcessor实例对象
		// 3. 记录ignoreDependencyInterface
		// 4. 记录ResolvableDependency
		// 5. 添加三个单例Bean
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			// 第四:留给子类去实现该接口
			// 子类来设置一下BeanFactory
			postProcessBeanFactory(beanFactory);

			// BeanFactory准备好了之后，执行BeanFactoryPostProcessor，开始对BeanFactory进行处理
			// 默认情况下:
			// 此时beanFactory的beanDefinitionMap中有6个BeanDefinition，5个基础BeanDefinition+AppConfig的BeanDefinition
			// 而这6个中只有一个BeanFactoryPostProcessor：ConfigurationClassPostProcessor
			// 这里会执行ConfigurationClassPostProcessor进行@Component的扫描，扫描得到BeanDefinition，并注册到beanFactory中
			// 注意：扫描的过程中可能又会扫描出其他的BeanFactoryPostProcessor，那么这些BeanFactoryPostProcessor也得在这一步执行
			// Invoke factory processors registered as beans in the context.
			invokeBeanFactoryPostProcessors(beanFactory);

			// 注册beanPostProcessor
			// 将扫描到的BeanPostProcessors实例化并排序，并添加到BeanFactory的beanPostProcessors属性中去
			// Register bean processors that intercept bean creation.
			registerBeanPostProcessors(beanFactory);

			// 初始化国际化资源处理器.
			// 设置ApplicationContext的MessageSource，要么是用户设置的，要么是DelegatingMessageSource
			// Initialize message source for this context.
			initMessageSource();

			// 创建事件多播器
			// 设置ApplicationContext的applicationEventMulticaster，么是用户设置的，要么是SimpleApplicationEventMulticaster
			// Initialize event multicaster for this context.
			initApplicationEventMulticaster();

			// 给子类的模板方法
			// 这个方法同样也是留给子类实现的springboot也是从这个方法进行启动tomat的.
			// Initialize other special beans in specific context subclasses.
			onRefresh();

			//把我们的事件监听器注册到多播器上
			// 把定义的ApplicationListener的Bean对象，设置到ApplicationContext中去，并执行在此之前所发布的事件
			// Check for listener beans and register them.
			registerListeners();

			//实例化我们剩余的单实例bean.
			// Instantiate all remaining (non-lazy-init) singletons.
			finishBeanFactoryInitialization(beanFactory);

			// 最后容器刷新 发布刷新事件(Spring cloud也是从这里启动的)
			// Last step: publish corresponding event.
			finishRefresh();
		}

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

			// Destroy already created singletons to avoid dangling resources.
			destroyBeans();

			// Reset 'active' flag.
			cancelRefresh(ex);

			// Propagate exception to caller.
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			resetCommonCaches();
		}
	}
}

里面有很多小方法，我们一个一个来看

6.1 prepareRefresh

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.
	// 初始化property资源文件到environment中，spring这里没有实现，是留给子类去实现了
	// 比如子类可以把ServletContext中的参数对设置到environment
	initPropertySources();

	// Validate that all properties marked as required are resolvable:
	// see ConfigurablePropertyResolver#setRequiredProperties
	// 这里是验证现在系统资源中必须要存在哪些资源key，也就是说现在的环境中，必须要存在哪些key才能进行启动容器的意思
	// 就是验证资源的key是否在环境中存在的意思
	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<>();
}

6.2 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()

 进行BeanFactory的refresh，在这里会去调用子类的refreshBeanFactory方法，具体子类是怎么刷新的得看子类，然后再调用子类的getBeanFactory方法，重新得到一个BeanFactory

可以简单的认为，就是把beanFactory取出来而已。XML模式下会在这里读取BeanDefinition

6.3 prepareBeanFactory

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// Tell the internal bean factory to use the context's class loader etc.
	// 添加一个类加载器，这个类加载器的用处在那里呢？spring扫描类的时候是通过ASM字节码技术扫描的，这个时候这个class是没有被加载的
	// 只是在硬盘上的一个class文件而已，扫描到过后是放入了BeanDefinition的beanclass属性中，只是一个类的全限定名，
	// 这里设置类加载器的意思就是后面初始化bean的时候会将这个beanclass的全限定名拿出来然后加载到jvm，这个时候就需要一个类加载器
	// 所以这里设置一个了加载器
	beanFactory.setBeanClassLoader(getClassLoader());
	// 添加一个处理el表达式的解析器，比如我们的@Value()中就有可能是表达式，需要解析$和#
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

	// 添加PropertyEditorRegistrar：ResourceEditorRegistrar，PropertyEditor类型转化器注册器，用来注册一些默认的PropertyEditor
	// 注册一些默认的类型的转换器，比如我们在类中定义了
	/**
	 * @Value("c://xxx/tt.file")
	 * private File file;
	 * 那么这里设置的类型转换器就是讲@Value中的字符串直接生成一个File
	 */
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	// Configure the bean factory with context callbacks.
	/**
	 * 这里添加一个ApplicationContextAwareProcessor
	 * ApplicationContextAwareProcessor是一个bean的后置处理器
	 * ApplicationContextAwareProcessor会在初始化前这个步骤中进行其他Aware的回调：
	 * EnvironmentAware：回传环境变量
	 * EmbeddedValueResolverAware：回传占位符解析器
	 * ResourceLoaderAware：回传资源加载器
	 * ApplicationEventPublisherAware：回传事件发布器
	 * MessageSourceAware：回传国际化资源
	 * ApplicationStartupAware：回传应用其他监听对象，可忽略
	 * ApplicationContextAware：回传Spring容器ApplicationContext
	 */
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

	/**
	 * 向ignoreDependencyInterface这个属性中添加一些接口，如果某个类实现了这个接口，
	 * 并且这个类中的某些set方法在接口中也存在，那么这个set方法在自动注入的时候是不会执行的，
	 * 比如EnvironmentAware这个接口，如果某个类实现了这个接口，那么就必须实现它的setEnvironment方法，
	 * 而这是一个set方法，和Spring中的autowire是冲突的，那么Spring在自动注入时是不会调用setEnvironment方法的，
	 * 而是等到回调Aware接口时再来调用（注意，这个功能仅限于xml的autowire或者@Bean(autowire = Autowire.BY_TYPE)，@Autowired注解还是会执行setEnvironment）
	 * EnvironmentAware
	 * EmbeddedValueResolverAware
	 * ResourceLoaderAware
	 * ApplicationEventPublisherAware
	 * MessageSourceAware
	 * ApplicationContextAware
	 * 另外其实在构造BeanFactory的时候就已经提前添加了另外三个：
	 * BeanNameAware
	 * BeanClassLoaderAware
	 * BeanFactoryAware
	 */
	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.
	/**
	 * 添加resolvableDependencies：在byType进行依赖注入时，会先从这个属性中根据类型找bean
	 * BeanFactory.class：当前BeanFactory对象
	 * ResourceLoader.class：当前ApplicationContext对象
	 * ApplicationEventPublisher.class：当前ApplicationContext对象
	 * ApplicationContext.class：当前ApplicationContext对象
	 */
	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.
	/**
	 * 添加一个Bean的后置处理器：ApplicationListenerDetector，是一个BeanPostProcessor，
	 * 这个后置处理器在bean初始化后会调用postProcessAfterInitialization
	 * 用来判断某个Bean是不是ApplicationListener，
	 * 如果是则把这个Bean添加到ApplicationContext中去，注意一个ApplicationListener只能是单例的
	 */
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	/**
	 * 添加一个Bean的后置处理器：LoadTimeWeaverAwareProcessor，是一个BeanPostProcessor，
	 * 初始化前postProcessBeforeInitialization
	 * 用来判断某个Bean是不是实现了LoadTimeWeaverAware接口，
	 * 如果实现了则把ApplicationContext中的loadTimeWeaver回调setLoadTimeWeaver方法设置给该Bean。
	 */
	// 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.
	//将environment直接注册成一个单例bean，environment是系统的环境变量信息
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	//将系统中的属性配置信息注册一个bean，bean的名字就是systemProperties
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	//将系统的环境变量注册成一个单例bean，systemEnvironment
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
}

 之前分析依赖注入源码的时候有一个方法DefaultListableBeanFactory#findAutowireCandidates：搜索类型匹配的bean的Map，就是根据类型去找bean：

 先根据类型从resolvableDependencies中去匹配Bean，resolvableDependencies就是在Spring启动的时候设置的。

6.4 postProcessBeanFactory(beanFactory)

 提供给AbstractApplicationContext的子类进行扩展，具体的子类，可以继续向BeanFactory中再添加一些东西

6.5-invokeBeanFactoryPostProcessors(beanFactory)

执行BeanFactoryPostProcessor，首先我们要知道执行到此方法时Spring还没有进行扫描，所以此时Spring中可以拿到的BeanFactoryPostProcessor要么是spring在启动过程中自己添加的BeanFactoryPostProcessor，要么是我们在执行context.refresh()前添加的

在上面3.实例化BeanDefinition读取器： AnnotatedBeanDefinitionReader，这一步中spring向beanDefinition中添加了一些内置的后置处理器，其中有一个BeanDefinitionRegistryPostProcessor的实现类ConfigurationClassPostProcessor

 注意：这里只是生成了BeanDefiniton并且放到了beanDefinitionMap中，没有生成bean对象，也没有放到beanFactory的beanFactoryPostProcessors中

 或者程序员自己通过ApplicationContext手动添加

 这种方法是直接放到了beanFactory的beanFactoryPostProcessors中，beanDefinitionMap中是没有的。

以上所说都是执行invokeBeanFactoryPostProcessors方法前的。

/**
 * 调用spring默认的beanFactory后置处理器，最最重要的是ConfigurationClassPostProcessor，这个类扫描
 * 我们配置的类
 * @param beanFactory  bean工厂，子类是DefaultListableBeanFactory
 * @param beanFactoryPostProcessors 用户注册的BeanFactory后置处理器
 * 在这之前，我们的register和构造都没有注册过后置处理器，而我们的Import也还没被扫描
 * spring目前还没开始扫描，在这之前仅仅做了工厂初始化和默认的spring内置处理器，以及将我们的配置类注册
 * 到工厂的bdmap中 ，所以这里传入的beanFactoryPostProcessors如果在启动的时候没有添加后置处理器，那么这里传入的为空
 */

public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
	/**
	 * BeanFactoryPostProcessors按入场方式分为：
	 * 1. 程序员调用ApplicationContext的API手动添加
	 * 2. Spring自己扫描出来的
	 *
	 * BeanFactoryPostProcessor按类型又可以分为：
	 * 1. 普通BeanFactoryPostProcessor
	 * 2. BeanDefinitionRegistryPostProcessor
	 *
	 * 执行顺序顺序如下：
	 * 执行通过ApplicationContext添加进来的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
	 * 执行BeanFactory中实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
	 * 执行BeanFactory中实现了Ordered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
	 * 执行BeanFactory中其他的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
	 * 执行上面所有的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
	 * 执行通过ApplicationContext添加进来的BeanFactoryPostProcessor的postProcessBeanFactory()方法
	 * 执行BeanFactory中实现了PriorityOrdered接口的BeanFactoryPostProcessor的postProcessBeanFactory()方法
	 * 执行BeanFactory中实现了Ordered接口的BeanFactoryPostProcessor的postProcessBeanFactory()方法
	 * 执行BeanFactory中其他的BeanFactoryPostProcessor的postProcessBeanFactory()方法
	 *
	 * ConfigurationClassPostProcessor就会在第2步执行，会进行扫描
	 */

	// Invoke BeanDefinitionRegistryPostProcessors first, if any.
	//这里定义个Set存放处理器的Bean名称（为啥用Set，因为Set自动具有自动去重功能），这里的这个processedBeans存放的
	//是已经执行过的后置处理器
	Set<String> processedBeans = new HashSet<>();

	//beanFactory是DefaultListableBeanFactory，是BeanDefinitionRegistry的实现类，所以肯定满足if
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

		//regularPostProcessors 用来存放BeanFactoryPostProcessor，
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();

		//registryProcessors 用来存放BeanDefinitionRegistryPostProcessor
		//BeanDefinitionRegistryPostProcessor扩展了BeanFactoryPostProcessor
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

		// beanFactoryPostProcessors集合一般情况下都是空的，除非我们在启动前手动调用容器的addBeanFactoryPostProcessor方法添加了
		// beanFactoryPostProcessors中可能包含了：普通BeanFactoryPostProcessor对象和BeanDefinitionRegistryPostProcessor对象
		// 对于BeanDefinitionRegistryPostProcessor对象，会执行自己的postProcessBeanDefinitionRegistry()方法
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			// 判断postProcessor是不是BeanDefinitionRegistryPostProcessor，因为BeanDefinitionRegistryPostProcessor
			// 扩展了BeanFactoryPostProcessor，所以这里先要判断是不是BeanDefinitionRegistryPostProcessor
			// 是的话，直接执行postProcessBeanDefinitionRegistry方法，然后把对象装到registryProcessors里面去
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				//1.执行通过ApplicationContext添加进来的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
				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.
		/**
		 * 下面这个变量什么意思呢？这个集合的类型是BeanDefinitionRegistryPostProcessor，表示每次都存放符合条件的BeanDefinitionRegistryPostProcessor
		 * 的beanFactory的后置处理器，然后放入过后，循环去执行里面的后置处理器的postProcessBeanDefinitionRegistry
		 * 执行完成过后清空，然后下一个符合条件的后置处理器又添加进去，执行，就是一个临时变量。
		 */
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
		/**
		 * 上面处理的是程序员手动添加的后置处理器，这里是要获取从beanDefinitionMap中注册的所有bean工厂的后置处理器
		 * 但是代码执行到这里，我们的业务定义的bean还没有开始扫描的，这里最多获取的是spirng在启动开始添加到beanDefinitionMap
		 * 中的后置处理器，所以这里的思路是：
		 * 获取spring在启动添加到beanDefinitionMap中的bean工厂后置处理器，我们从前面的代码中可以知道spring只有在构建配置类读取
		 * 对象的时候放了一个ConfigurationClassPostProcessor后置处理器，这个后置处理器是spring的核心，非常重要，是对我们的
		 * 配置类进行解析，将配置类中符合条件的class生成BeanDefinition，然后放入到beanDefinitionMap
		 *这里spring的官方的解释是first；实现逻辑是：
		 * 1.将容器中所有实现了BeanDefinitionRegistryPostProcessor的beanName全部拿出来；
		 * 2.将这些后置处理器实现了PriorityOrdered（优先级最高）的分为一组，然后getBean（如果没有，会创建）
		 * 3.然后对这些实现了PriorityOrdered的后置处理器根据Order的数字进行排序，然后执行后置处理器中postProcessBeanDefinitionRegistry方法
		 * 4.执行过的postProcessBeanDefinitionRegistry方法的后置处理器添加到执行过后的集合中processedBeans；
		 * 5.currentRegistryProcessors表示当前执行的后置处理器（实现了BeanDefinitionRegistryPostProcessor接口的bean）
		 * 每次循环将符合条件的后置处理器放入这个集合中，然后去执行，执行完成过后清除。
		 *
		 */
		// 去beanDefinitionMap中找实现了BeanDefinitionRegistryPostProcessor的类
		// 此时Spring还未进行扫描，正常情况只会拿到一个ConfigurationClassPostProcessor后置处理器
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		// 循环找到的beanName
		for (String ppName : postProcessorNames) {
			// 如果当前bean还实现了PriorityOrdered接口，getBean创建，放入临时变量中
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				//将处理过的后置处理器名称放入processedBeans
				processedBeans.add(ppName);
			}
		}
		// 根据PriorityOrdered排序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		// 添加到registryProcessors，这个集合表示实现了BeanDefinitionRegistryPostProcessor的所有后置处理器集合
		registryProcessors.addAll(currentRegistryProcessors);
		// 2.执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		// 清空临时变量
		currentRegistryProcessors.clear();

		/**
		 * 上面会执行ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法
		 * 这方法会
		 * 解析AppConfig类
		 * 扫描得到BeanDefinition并注册
		 * 解析@Import，@Bean等注解得到BeanDefinition并注册
		 * 详细的会在下篇文章专门分析ConfigurationClassPostProcessor是如何工作的
		 * 在这里，我们只需要知道在这一步会去得到BeanDefinition，
		 * 而这些BeanDefinition中可能存在BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor，
		 * 所以执行完ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry()方法后，
		 * 还需要继续执行其他BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
		 * 所以再次去beanDefinitionMap中找实现了BeanDefinitionRegistryPostProcessor的类
		 */

		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			// 去除上面处理过的BeanDefinitionRegistryPostProcessor，并且实现了Ordered接口
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				//将处理过的后置处理器名称放入processedBeans
				processedBeans.add(ppName);
			}
		}
		// 根据Ordered接口排序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		// 和上面一样放入registryProcessors
		registryProcessors.addAll(currentRegistryProcessors);
		// 3.执行BeanFactory中实现了Ordered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		// 清空临时变量
		currentRegistryProcessors.clear();

		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
		/**
		 * spring的官方解释是finally，表示最后的一步，我们看下面的代码是用的循环来获取的；首先要明白上面的后置处理器中
		 * 都只执行了PriorityOrder 和Ordered以及程序员手动添加的后置处理器；你想哈，前三步执行的后置处理器，都有可能添加BeanDefinition
		 * 其中第二步是去解析我们的配置类的，肯定会将系统中程序员定义的所有的bean都扫描成了BeanDefinition，这里的代码逻辑就是说
		 * 获取系统中的所有的后置处理器（实现了BeanDefinitionRegistryPostProcessor），不分优先级，下面的也是执行
		 * BeanDefinitionRegistryPostProcessor中的postProcessBeanDefinitionRegistry方法；下面的代码逻辑是：
		 * 1.循环根据BeanDefinitionRegistryPostProcessor获取后置处理器名字列表；
		 * 2.如果这个后置处理器已经执行过了，那么久不执行；
		 * 3.如果没有执行过，添加到currentRegistryProcessors列表中；
		 * 4.然后设置reiterate为true，表示我本次处理了后置处理器，容器中可能还有后置处理器，循环继续；
		 * 5.然后对找到的符合条件的后置处理器开始执行；
		 * 6.逻辑一样，处理完成过后添加到registryProcessors；
		 * 7.然后清空已经还行过的后置处理器列表；
		 * 下面我们来分析为什么这里要用while循环，前面已经说了实现了BeanDefinitionRegistryPostProcessor的后置处理器中的
		 * postProcessBeanDefinitionRegistry方法是可以注册BeanDefinition的，而可以注册BeanDefinition，也就意味着可以注册
		 * BeanDefinitionRegistryPostProcessor类型的BeanDefinition，如果不用循环，不每次循环都去从新获取是否有BeanDefinitionRegistryPostProcessor
		 * 类型的后置处理器，那么你在某一次的 postProcessBeanDefinitionRegistry方法中注册了新的BeanDefinitionRegistryPostProcessor类型
		 * 的后置处理器，那系统不就漏掉了，漏处理了，所以这里用的是while循环，直到你每次获取到的后置处理器列表是空的，那么就表示系统中的所有
		 * bean工厂的BeanDefinitionRegistryPostProcessor类型的后置处理器都已经处理完成了，就可以退出循环了
		 */
		// 执行哪些没有实现了PriorityOrdered或Ordered接口的普通BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
		// 在这个过程中可能会向BeanFactory中注册另外的BeanDefinitionRegistryPostProcessor，所以需要while，直到确定所有的BeanDefinitionRegistryPostProcessor都执行完了
		// 在这个过程中注册的BeanDefinitionRegistryPostProcessor，所实现的PriorityOrdered或Ordered接口可能会不按顺序执行
		// 比如 A注册了B和C,B又注册了D和E,那么B和C会按顺序执行，D和E也会按顺序执行，但是B、C、D、E整体不能保证是顺序执行
		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);
			// 4.执行BeanFactory中其他的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();
		}

		// Now, invoke the postProcessBeanFactory callback of all processors handled so far.

		// registryProcessors这个集合存放的是找到的所有现了BeanDefinitionRegistryPostProcessor接口的后置处理器
		// 而上面的代码已经执行了所有BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法，
		// 但是父类中的postProcessBeanFactory还没执行
		// 5.执行上面所有的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);

		// regularPostProcessors存放的是程序员手动添加的后置处理器
		// 5.执行通过ApplicationContext添加进来的BeanFactoryPostProcessor的postProcessBeanFactory()方法
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}

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

	// 执行扫描出来的普通BeanFactoryPostProcessor
	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let the bean factory post-processors apply to them!
	// 所有实现了BeanFactoryPostProcessor的类，会包含实现了BeanDefinitionRegistryPostProcessor的类
	// 因为BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子类
	// 所以要过滤掉上面已经处理过的--processedBeans
	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);
	// 7.执行BeanFactory中实现了PriorityOrdered接口的BeanFactoryPostProcessor的postProcessBeanFactory()方法
	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);
	// 8.执行BeanFactory中实现了Ordered接口的BeanFactoryPostProcessor的postProcessBeanFactory()方法
	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));
	}
	// 9.执行BeanFactory中其他的BeanFactoryPostProcessor的postProcessBeanFactory()方法
	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();
}

这个方法就是执行beanFactory后置处理器的

执行BeanFactoryPostProcessor顺序

1. 执行通过ApplicationContext添加进来的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
2. 执行BeanFactory中实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
3. 执行BeanFactory中实现了Ordered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
4. 执行BeanFactory中其他的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
5. 执行上面所有的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
6. 执行通过ApplicationContext添加进来的BeanFactoryPostProcessor的postProcessBeanFactory()方法
7. 执行BeanFactory中实现了PriorityOrdered接口的BeanFactoryPostProcessor的postProcessBeanFactory()方法
8. 执行BeanFactory中实现了Ordered接口的BeanFactoryPostProcessor的postProcessBeanFactory()方法
9. 执行BeanFactory中其他的BeanFactoryPostProcessor的postProcessBeanFactory()方法

 ConfigurationClassPostProcessor就会在第2步执行：

1. 解析AppConfig类
2. 扫描得到BeanDefinition并注册
3. 解析@Import，@Bean等注解得到BeanDefinition并注册

只有执行了ConfigurationClassPostProcessor.的postProcessBeanDefinitionRegistry()方法，才会得到所有BeanDefinition，才会有之后的操作，关于ConfigurationClassPostProcessor下篇文章单独分析。

6.6-registerBeanPostProcessors(beanFactory)

因为上面的步骤完成了扫描，这个过程中程序员可能自己定义了一些BeanPostProcessor，在这一步就会把BeanFactory中所有的BeanPostProcessor找出来并实例化得到一个对象，并添加到BeanFactory中去（属性beanPostProcessors），最后再重新添加一个ApplicationListenerDetector对象（之前其实就添加了过，这里是为了把ApplicationListenerDetector移动到最后）

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

	// 这里按照BeanPostProcessor的类型从beanDefinitionMap中取出所有的后置处理器名称
	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.
	/**
	 * 下面就是对后置处理器进行分类，在循环的时候，这里就开始将得到的后置处理器创建出了对象，然后放入到单例池中
	 * 下面的分类是从实现了PriorityOrdered、Ordered和没有实现的后置处理器进行分类
	 * 1.首先将实现了PriorityOrdered的分一组 priorityOrderedPostProcessors
	 * 2.实现了Ordered的分一组     orderedPostProcessorNames
	 * 3.没有实现上述的两个接口的分一组   nonOrderedPostProcessorNames
	 * 4.如果实现了MergedBeanDefinitionPostProcessor 分一组 internalPostProcessors
	 *
	 */
	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.
	//对实现了PriorityOrdered的后置处理器列表进行排序，排序的类就是启动的时候设置进去的一个排序比较器dependencyComparator
	//就是里面有个属性order，每个后置处理器的order越小，越靠前
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	// Next, register the BeanPostProcessors that implement Ordered.
	//下面是对实现了Ordered的进行处理，这里的循环和上面的循环都做了一件相同的事情，就是把实现了MergedBeanDefinitionPostProcessor
	//的后置处理器都单独拿出来加入到了internalPostProcessors，我们知道spring的依赖注入，生命周期的回调用法的后置处理器都实现了
	//MergedBeanDefinitionPostProcessor,所以这里应该是叫做内部的后置处理器单独拿出来
	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.
	//下面的是没有实现了上面的排序相关的后置处理器拿出来循环，如果实现了MergedBeanDefinitionPostProcessor都放在
	//internalPostProcessors中
	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.
	// 将所有实现了MergedBeanDefinitionPostProcessor的BeanPostProcessor排序
	sortPostProcessors(internalPostProcessors, beanFactory);
	// 将所有实现了MergedBeanDefinitionPostProcessor的BeanPostProcessor放到最后
	// Spring内置的几个BeanPostProcessor都是实现了MergedBeanDefinitionPostProcessor，可能spring设计就是先执行用户定义的，后执行内置的
	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).
	/**
	 * 这里再添加一个后置处理器ApplicationListenerDetector，这个后置处理器是不是很熟悉，好像在哪儿见过
	 * 的确，这个后置处理器是在refresh中的prepareBeanFactory初始化工厂的时候添加了一次，那这里为什么又要添加一次
	 * spring大概是这样设计的，这个后置处理器是获取系统中所有的实现了ApplicationLister的BeanDefinition添加到
	 * 事件监听器中，前面准备工厂的时候添加了，但是到这里spring已经经过了扫描我们定义的类过程了，那么这个时候所有的类
	 * 都在BeanDefinition中了，这个时候再添加就是后面调用的时候可以获取到更全的事件监听器类
	 * 也就是前面添加的时候，可能系统中的事件监听器还真是系统中默认的，而这里添加的就是表示包括而来系统默认的和用户添加的自定义的
	 * ，所以比较全，反正我这样理解的，而且你仔细看下ApplicationListenerDetector这个类，它重写了equals方法
	 * 也就是你每次都是new出来的对象，但是其实equals判断是一个对象，在remove的时候，虽然每次都是new的，但是其实
	 * 就只有一个，也就是bean的后置处理器中只会有一个这么后置处理器ApplicationListenerDetector
	 *
	 */
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

6.7-initMessageSource()

/**
 * Initialize the MessageSource.
 * Use parent's if none defined in this context.
 * 这里是初始化国际化资源信息，在单例池中看是否有一个bean是messageSource，如果有
 * 判断它是否实现了HierarchicalMessageSource，也就是父类的国际化，如果没有这个bean、
 * 就创建一个默认的beanmessageSource，类型是DelegatingMessageSource
 */
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 + "]");
		}
	}
}

6.8-initApplicationEventMulticaster()

/**
 * Initialize the ApplicationEventMulticaster.
 * Uses SimpleApplicationEventMulticaster if none defined in the context.
 * @see org.springframework.context.event.SimpleApplicationEventMulticaster
 * 这里看容器中是否有一个applicationEventMulticaster，事件注册器，如果没有
 * 注册一个默认的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.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() + "]");
		}
	}
}

6.9-onRefresh();

提供给AbstractApplicationContext的子类进行扩展，模板方法，在容器刷新的时候可以自定义逻辑，不同的Spring容器做不同的事情。

6.10-registerListeners();

BeanFactory中获取ApplicationListener类型的beanName，然后添加到ApplicationContext中的事件广播器applicationEventMulticaster中去，到这一步因为FactoryBean还没有调用getObject()方法生成Bean对象，所以这里要在根据类型找一下ApplicationListener，记录一下对应的beanName

protected void registerListeners() {
	/**
	 * 这里是扫描完成过后，注册了事件发布器过后，这里把系统中所有的ApplicationListener添加到事件发布器中
	 */
	// 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!
	/**
	 * 上面是添加了已经实现了ApplicationListener接口的bean添加到事件发布器中
	 * 但是下面又在获取ApplicationListener，是byType获取的，为什么这里还要去获取
	 * 因为容器中可能有FactoryBean，我们知道FactoryBean中的bean是需要真正调用的时候也就是getObject
	 * 才会返回具体的对象，估factoryBean默认是懒加载的，所以这里的ByType是获取BeanDefinition中facatorybean
	 * 类型是ApplicationListener的取出来然后添加到事件发布器的applicationListenerBeans中
	 */
	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...
    // 添加了事件监听器后，判断是否有earlyApplicationEvents，如果有就使用事件广播器发布earlyApplicationEvents
	// earlyApplicationEvents表示在事件广播器还没生成好之前ApplicationContext所发布的事件
	Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
	this.earlyApplicationEvents = null;
	if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
		for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
			getApplicationEventMulticaster().multicastEvent(earlyEvent);
		}
	}
}

6.11-finishBeanFactoryInitialization(beanFactory);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// Initialize conversion service for this context.
	// 如果BeanFactory中存在名字叫conversionService的Bean,则设置为BeanFactory的conversionService属性
	// 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));
	}

	// Register a default embedded value resolver if no BeanFactoryPostProcessor
	// (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:
	// at this point, primarily for resolution in annotation attribute values.
	// 设置默认的占位符解析器
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
	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);

	// Allow for caching all bean definition metadata, not expecting further changes.
	beanFactory.freezeConfiguration();

	// Instantiate all remaining (non-lazy-init) singletons.
	// 实例化非懒加载的单例Bean
	beanFactory.preInstantiateSingletons();
}

完成BeanFactory的初始化，主要就是实例化非懒加载的单例Bean，之前文章分析过了

Spring源码学习（六）-- Bean的生命周期（下）_学习笔记-CSDN博客

6.12-finishRefresh()

BeanFactory的初始化完后，就到了Spring启动的最后一步了

1. 设置ApplicationContext的lifecycleProcessor，默认情况下设置的是DefaultLifecycleProcessor
2. 调用lifecycleProcessor的onRefresh()方法，如果是DefaultLifecycleProcessor，那么会获取所有类型为Lifecycle的Bean对象，然后调用它的start()方法，这就是ApplicationContext的生命周期扩展机制
3. 发布ContextRefreshedEvent事件

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

   // Initialize lifecycle processor for this context.
   /**
    * 初始化容器上下文生命周期，
    * 也就是说容器启动完毕过后，提供了一个扩展点，就是在容器初始化完毕过后，会获取容器中是LiftCycle的类型bean
    * 然后取出来执行里面的start方法，容器停止的时候会调用lifeCycle的stop方法
    */
   initLifecycleProcessor();

   // Propagate refresh to lifecycle processor first.
   //初始化完成容器的LifeCycle过后，开始调用onRefresh
   getLifecycleProcessor().onRefresh();

   // Publish the final event.
   //发布一个容器刷新完毕的事件
   publishEvent(new ContextRefreshedEvent(this));

   // Participate in LiveBeansView MBean, if active.
   LiveBeansView.registerApplicationContext(this);
}
/**
 * Initialize the LifecycleProcessor.
 * Uses DefaultLifecycleProcessor if none defined in the context.
 * @see org.springframework.context.support.DefaultLifecycleProcessor
 * 判断容器中是否有个一个bean lifecycleProcessor，如果没有，就添加一个默认的lifecycleProcessor bean
 * DefaultLifecycleProcessor
 */
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.isTraceEnabled()) {
         logger.trace("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.isTraceEnabled()) {
         logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
               "[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
      }
   }
}
@Override
public void onRefresh() {
   startBeans(true);
   this.running = true;
}
private void startBeans(boolean autoStartupOnly) {
   //获取系统中实现了LifeCycle的bean，得到一个map，然后调用里面的start方法
   Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
   Map<Integer, LifecycleGroup> phases = new HashMap<>();
   //然后分组，搞那么复杂干嘛呀，取出来执行不就得行了，而且实现了LifeCycle还不得行，还必须是要实现SmartLifecycle才行
   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) {
         //调用LifeCycle中的start、方法
         phases.get(key).start();
      }
   }
}
/**\
 *调用实现了LifeCycle类的中的star方法
 */
public void start() {
   if (this.members.isEmpty()) {
      return;
   }
   if (logger.isDebugEnabled()) {
      logger.debug("Starting beans in phase " + this.phase);
   }
   Collections.sort(this.members);
   for (LifecycleGroupMember member : this.members) {
      //调用
      doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
   }
}

Lifecycle的使用

Lifecycle表示的是ApplicationContext的生命周期，可以定义一个SmartLifecycle来监听ApplicationContext的启动和关闭：

@Component
public class FztxLifecycle implements SmartLifecycle {

	private boolean isRunning = false;

	@Override
	public void start() {
		System.out.println("启动");
		isRunning = true;
	}

	@Override
	public void stop() {
        // 要触发stop()，要调用context.close()，或者注册关闭钩子（context.registerShutdownHook();）
		System.out.println("停止");
		isRunning = false;
	}

	@Override
	public boolean isRunning() {
		return isRunning;
	}
}