spring启动卡1分钟 spring 启动时的加载过程

转载

我心依旧 2024-04-18 15:23:15

文章标签 spring启动卡1分钟初始化构造方法 ci 文章分类 架构后端开发

Spring启动过程

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

AnnotationConfigApplicationContext applicationContext=new AnnotationConfigApplicationContext();
applicationContext.register(SpringConfig.class);
applicationContext.refresh();

构建默认BeanFactory

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {

    //注解bean定义读取器，主要作用是用来读取被注解的了bean
    private final AnnotatedBeanDefinitionReader reader;

    //扫描器，它仅仅是在我们外部手动调用 .scan 等方法才有用，常规方式是不会用到scanner对象的
    private final ClassPathBeanDefinitionScanner scanner;

    /**
     * Create a new AnnotationConfigApplicationContext that needs to be populated
     * through {@link #register} calls and then manually {@linkplain #refresh refreshed}.
     */
    public AnnotationConfigApplicationContext() {
        //会隐式调用父类的构造方法，初始化DefaultListableBeanFactory

        //初始化一个Bean读取器
        this.reader = new AnnotatedBeanDefinitionReader(this);

        //初始化一个扫描器，它仅仅是在我们外部手动调用 .scan 等方法才有用，常规方式是不会用到scanner对象的
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
}

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

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

DefaultListableBeanFactory是相当重要的，从字面意思就可以看出它是一个Bean的工厂

实例化BeanDefinition读取器

实例化BeanDefinition读取器AnnotatedBeanDefinitionReader,其主要做了2件事情

1.注册内置BeanPostProcessor

2.注册相关的BeanDefinition

spring启动卡1分钟 spring 启动时的加载过程_spring启动卡1分钟

让我们把目光回到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");
	this.registry = registry;
	this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

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

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

这又是一个门面方法，再点进去,源码如下

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

	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
	if (beanFactory != null) {
		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
			//AnnotationAwareOrderComparator主要能解析@Order注解和@Priority
			beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
		}
		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
			//ContextAnnotationAutowireCandidateResolver提供处理延迟加载的功能
			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
		}
	}


	//BeanDefinitionHolder是存储BeanDefinitionName和BeanDefinition的一个数据结构
	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
	//BeanDefinition的注册，需要理解注册每个bean的类型

	// CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME=internalConfigurationAnnotationProcessor
	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		//ConfigurationClassPostProcessor是一个BeanFactory的后置处理器，
		//主要功能是解析加了@Configuration的配置类，还会解析@ComponentScan、@ComponentScans注解扫描的包，以及解析@Import等注解
		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
		def.setSource(source);
		//将ConfigurationClassPostProcessor注册到DefaultListableBeanFactory的BeanDefinitionMap中
		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	//AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME=internalAutowiredAnnotationProcessor
	if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		//AutowiredAnnotationBeanPostProcessor是解析AutoWired注解的BeanPostProcessor
		RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
		def.setSource(source);
		//将AutowiredAnnotationBeanPostProcessor注册到DefaultListableBeanFactory的BeanDefinitionMap中
		beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	//COMMON_ANNOTATION_PROCESSOR_BEAN_NAME=internalCommonAnnotationProcessor
	// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
	if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		//CommonAnnotationBeanPostProcessor支持对@PostConstruct和@PreDestroy注解,以及对@Resource注解的处理
		RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
		def.setSource(source);
		//将CommonAnnotationBeanPostProcessor注册到DefaultListableBeanFactory的BeanDefinitionMap中
		beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
	}
	
	//PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME=internalPersistenceAnnotationProcessor
	// 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);
		//将internalPersistenceAnnotationProcessor,注册到DefaultListableBeanFactory的BeanDefinitionMap中
		beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
	}
	
	//EVENT_LISTENER_PROCESSOR_BEAN_NAME=internalEventListenerProcessor
	if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
		//EventListenerMethodProcessor支持事件监听
		RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
		def.setSource(source);
		//将EventListenerMethodProcessor,注册到DefaultListableBeanFactory的BeanDefinitionMap中
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
	}
	//EVENT_LISTENER_FACTORY_BEAN_NAME=internalEventListenerFactory
	if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
		//DefaultEventListenerFactory,事件监听相关
		RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
		def.setSource(source);
		//将DefaultEventListenerFactory,注册到DefaultListableBeanFactory的BeanDefinitionMap中
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
	}

	return beanDefs;
}

这个方法的返回值Set，但是上游方法并没有去接收这个返回值，所以这个方法的返回值也不是很重要了。

这个方法的核心就是注册Spring内置的多个Bean：

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));
}

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);
}

首先要知道registry实现类是什么，那么它的实现是什么呢？答案是DefaultListableBeanFactory：

registry.registerBeanDefinition(beanName, definition);源码如下

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

	Assert.hasText(beanName, "Bean name must not be empty");
	Assert.notNull(beanDefinition, "BeanDefinition must not be null");

	if (beanDefinition instanceof AbstractBeanDefinition) {//验证
		try {
			((AbstractBeanDefinition) beanDefinition).validate();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Validation of bean definition failed", ex);
		}
	}
	//这里beanDefinitionMap是存储bean的name和.beanDefinition的map结果,此处有5个spring内置的BeanDefinition
	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);//这里的beanName是配置类的名字,existingDefinition应该为null
	if (existingDefinition != null) {
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
		}
		else if (existingDefinition.getRole() < beanDefinition.getRole()) {
			// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
			if (logger.isInfoEnabled()) {
				logger.info("Overriding user-defined bean definition for bean '" + beanName +
						"' with a framework-generated bean definition: replacing [" +
						existingDefinition + "] with [" + beanDefinition + "]");
			}
		}
		else if (!beanDefinition.equals(existingDefinition)) {
			if (logger.isDebugEnabled()) {
				logger.debug("Overriding bean definition for bean '" + beanName +
						"' with a different definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		else {
			if (logger.isTraceEnabled()) {
				logger.trace("Overriding bean definition for bean '" + beanName +
						"' with an equivalent definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		this.beanDefinitionMap.put(beanName, beanDefinition);
	}
	else {//进这里
		if (hasBeanCreationStarted()) {//这里跳过,不进这里,先不看
			// Cannot modify startup-time collection elements anymore (for stable iteration)
			synchronized (this.beanDefinitionMap) {
				this.beanDefinitionMap.put(beanName, beanDefinition);
				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
				updatedDefinitions.addAll(this.beanDefinitionNames);
				updatedDefinitions.add(beanName);
				this.beanDefinitionNames = updatedDefinitions;
				removeManualSingletonName(beanName);
			}
		}
		else {//关键代码
			// Still in startup registration phase
			//这里的beanDefinitionMap是一个map,存放beanName,beanDefinition
			this.beanDefinitionMap.put(beanName, beanDefinition);
			//这里的beanDefinitionNames是一个list,存放beanName
			this.beanDefinitionNames.add(beanName);
			removeManualSingletonName(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}

	if (existingDefinition != null || containsSingleton(beanName)) {
		resetBeanDefinition(beanName);
	}
}

从这里可以看出DefaultListableBeanFactory就是我们所说的容器了，里面放着beanDefinitionMap，beanDefinitionNames，

/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

/** List of bean definition names, in registration order. */
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

上面介绍过，这里会注册好几个Bean，在这其中最重要的一个Bean就是ConfigurationClassPostProcessor。

ConfigurationClassPostProcessor是一个BeanFactory的后置处理器，主要功能是解析加了@Configuration的配置类，还会解析@ComponentScan、@ComponentScans注解扫描的包，以及解析@Import等注解

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

spring启动卡1分钟 spring 启动时的加载过程_spring启动卡1分钟_02

除了注册了ConfigurationClassPostProcessor，还注册了其他Bean

spring启动卡1分钟 spring 启动时的加载过程_初始化_03

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

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

创建BeanDefinition扫描器

创建BeanDefinition扫描器ClassPathBeanDefinitionScanner

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

注册配置类

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

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

register(annotatedClasses);

会调用如下方法：

public void register(Class<?>... annotatedClasses) {
	for (Class<?> annotatedClass : annotatedClasses) {
		//注册配置类
		registerBean(annotatedClass);
	}
}

registerBean--->doRegisterBean

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
						@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

	/**
	 * 根据指定的bean创建一个AnnotatedGenericBeanDefinition
	 * 这个AnnotatedGenericBeanDefinition可以理解为一个数据结构
	 * AnnotatedGenericBeanDefinition包含了类的其他信息,比如一些元信息
	 * scope，lazy等等.
	 * 此时因为传入的注解,所以new AnnotatedGenericBeanDefinition
	 */
	AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
	/**
	 * 判断这个类是否需要跳过解析,spring中有一个@Condition注解，当不满足条件，这个bean就不会被解析
	 * 通过代码可以知道spring判断是否跳过解析，主要判断类有没有加注解
	 */
	if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
		return;
	}

	abd.setInstanceSupplier(instanceSupplier);
	/**
	 * 得到类的作用域 singleton,如果没有设置的话，默认为单例
	 */
	ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
	abd.setScope(scopeMetadata.getScopeName());
	/**
	 * 通过beanNameGenerator 获得beanName
	 */
	String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
	/**
	 * 处理类当中的通用注解
	 * 分析源码可以知道他主要处理 Lazy DependsOn Primary Role等等注解
	 * 处理完成之后processCommonDefinitionAnnotations中依然是把他添加到AnnotatedGenericBeanDefinition数据结构当中
	 */
	AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
	//qualifiers永远都是空的，包括上面的name和instanceSupplier都是同样的道理
	if (qualifiers != null) {
		for (Class<? extends Annotation> qualifier : qualifiers) {
			//如果配置了@Primary注解，如果加了则作为首选
			if (Primary.class == qualifier) {
				abd.setPrimary(true);
			}
			//懒加载Lazy注解
			else if (Lazy.class == qualifier) {
				abd.setLazyInit(true);
			} else {
				//如果使用了除@Primary和@Lazy以外的其他注解，则为该Bean添加一个根据名字自动装配的限定符
				//AnnotatedGenericBeanDefinition有个Map<String,AutowireCandidateQualifier>属性，直接push进去
				abd.addQualifier(new AutowireCandidateQualifier(qualifier));
			}
		}
	}
	//自定义注解
	for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
		customizer.customize(abd);
	}

	/**
	 * 这个BeanDefinitionHolder也是一个数据结构,这个对象放入了BeanDefinition和beanName,可以理解为一个map
	 */
	BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
	/**
	 * ScopedProxyMode 这个知识点比较复杂，需要结合web去理解
	 * 可以暂时放一下，等说道springmvc的时候再说
	 * 或者看情况现在说也是一样的
	 */
	definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
	/**
	 * 把上述的这个数据结构注册给registry
	 * registy就是AnnotatonConfigApplicationContext
	 * AnnotatonConfigApplicationContext在初始化的時候通過調用父類的構造方法
	 * 實例化了一个DefaultListableBeanFactory
	 * *registerBeanDefinition里面就是把definitionHolder这个数据结构包含的信息注册到
	 * DefaultListableBeanFactory这个工厂维护着一系列信息，比如beanDefinitionNames，beanDefinitionMap
	 * beanDefinitionNames是一个List<String>,用来保存beanName
	 * beanDefinitionMap是一个Map,用来保存beanName和beanDefinition
	 */
	BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);//关键代码
}

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

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

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

跟踪最后一行

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

	// Register bean definition under primary name.
	//获取beanName
	String beanName = definitionHolder.getBeanName();
	//注册bean
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

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

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

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

refresh()

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

@Override
public void refresh() throws BeansException, IllegalStateException {
	// 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛
	synchronized (this.startupShutdownMonitor) {

		/**
		 * 容器刷新前的准备工作
		 * 1.设置容器启动时间
		 * 2.将容器 active 属性设置为 true，closed 属性设置为 false
		 * 3.设置new StandardEnvironment对象,将系统属性配置加载到Environment对象中
		 * 4.准备监听器ApplicationListener,事件驱动ApplicationEvent
		 */
		// Prepare this context for refreshing.
		prepareRefresh();


		//这个方法和主流程关系也不是很大，可以简单的认为，就是把DefaultListableBeanFactory取出来而已
		// Tell the subclass to refresh the internal bean factory.
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
		//还是一些准备工作，添加了两个后置处理器：ApplicationContextAwareProcessor，ApplicationListenerDetector
		//还设置了 忽略自动装配 和 允许自动装配 的接口,如果不存在某个bean的时候，spring就自动注册singleton bean
		//还设置了bean表达式解析器 等
		// Prepare the bean factory for use in this context.
		prepareBeanFactory(beanFactory);

		try {

			// 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
			// 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
			//目前是空方法,留给后续扩展
			// Allows post-processing of the bean factory in context subclasses.
			postProcessBeanFactory(beanFactory);

			//实例化并执行所有注册的实现了BeanFactoryPostProcessor的bean,必须要在单例bean实例化之前调用
			//完成扫描和解析(类--->beanDefinition) 		beanDefinitionMap
			// Invoke factory processors registered as beans in the context.
			invokeBeanFactoryPostProcessors(beanFactory);

			//实例化并注册所有的BeanPostProcessor,还没有执行
			// Register bean processors that intercept bean creation.
			registerBeanPostProcessors(beanFactory);

			// 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了
			// Initialize message source for this context.
			initMessageSource();

			// 初始化当前 ApplicationContext 的事件广播器，这里也不展开了
			// Initialize event multicaster for this context.
			initApplicationEventMulticaster();

			// 空方法 从方法名就可以知道，典型的模板方法(钩子方法)，
			// 具体的子类可以在这里初始化一些特殊的 Bean,springboot在这里会做扩展
			// Initialize other special beans in specific context subclasses.
			onRefresh();

			// 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
			// Check for listener beans and register them.
			registerListeners();

			//涉及到FactoryBean
			// 重点，重点，重点
			// 初始化所有的 非懒加载 的 singleton beans
			//（lazy-init 的除外）
			// Instantiate all remaining (non-lazy-init) singletons.
			finishBeanFactoryInitialization(beanFactory);

			// 最后，广播事件，ApplicationContext 初始化完成
			// Last step: publish corresponding event.
			finishRefresh();
		}

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

			// 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源
			// 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();
		}
	}
}

里面有很多小方法,逐个分析

刷新前的准备

prepareRefresh();

从命名来看，就知道这个方法主要做了容器刷新前的准备工作

设置容器启动时间
将容器 active 属性设置为 true，closed 属性设置为 false
设置new StandardEnvironment对象,将系统属性配置加载到Environment对象中
准备监听器ApplicationListener,事件驱动ApplicationEvent

取出beanFactory

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

这个方法和主流程关系也不是很大，可以简单的认为，就是把beanFactory取出来而已。XML模式下会在这里读取BeanDefinition

BeanFactory的准备工作

prepareBeanFactory(beanFactory);

这代码相比前面两个就比较重要了，我们需要点进去好好看看，做了什么操作:

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// 设置 BeanFactory 的类加载器，我们知道 BeanFactory 需要加载类，也就需要类加载器，
	// 这里设置为加载当前 ApplicationContext 类的类加载器 一般为APPClassLoader
	// Tell the internal bean factory to use the context's class loader etc.
	beanFactory.setBeanClassLoader(getClassLoader());

	//设置bean表达式解析器
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

	//属性编辑器支持
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	// 添加一个后置处理器：ApplicationContextAwareProcessor，此后置处理处理器实现了BeanPostProcessor接口
	// 这个我们很常用，如我们会为了获取 ApplicationContext 而 implement ApplicationContextAware
	// 注意：它不仅仅回调 ApplicationContextAware，
	//   还会负责回调 EnvironmentAware、ResourceLoaderAware 等，看下源码就清楚了
	// Configure the bean factory with context callbacks.
	// 能够在bean中获得到各种*Aware（*Aware都有其作用）
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));//核心代码

	// 下面几行的意思就是，如果某个 bean 依赖于以下几个接口的实现类，在自动装配的时候忽略它们，
	// Spring 会通过其他方式来处理这些依赖。
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

	/**
	 * 下面几行就是为特殊的几个 bean 赋值，如果有 bean 依赖了以下几个，会注入这边相应的值，
	 * 当前 ApplicationContext 持有一个 BeanFactory,还继承了 ResourceLoader、ApplicationEventPublisher、MessageSource
	 * 所以对于这几个依赖，可以赋值为 this，注意 this 是一个 ApplicationContext
	 * 那这里怎么没看到为 MessageSource 赋值呢？那是因为 MessageSource 被注册成为了一个普通的 bean
	 * 以下接口，允许自动装配,第一个参数是自动装配的类型，，第二个字段是自动装配的值
	 */
	// BeanFactory interface not registered as resolvable type in a plain factory.
	// MessageSource registered (and found for autowiring) as a bean.
	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
	beanFactory.registerResolvableDependency(ApplicationContext.class, this);

	//添加一个后置处理器：ApplicationListenerDetector，此后置处理器实现了BeanPostProcessor接口
	// 这个 BeanPostProcessor 也很简单，在 bean 实例化后，如果是 ApplicationListener 的子类，
	// 那么将其添加到 listener 列表中，可以理解成：注册 事件监听器
	// Register early post-processor for detecting inner beans as ApplicationListeners.
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	// 这里涉及到特殊的 bean，名为：loadTimeWeaver，这不是我们的重点，忽略它
	// tips: ltw 是 AspectJ 的概念，指的是在运行期进行织入，这个和 Spring AOP 不一样，
	// 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()));
	}

	/**
	 * 从下面几行代码我们可以知道，Spring 往往很 "智能" 就是因为它会帮我们默认注册一些有用的 bean，
	 * 我们也可以选择覆盖
	 */
	//如果没有注册过bean名称为XXX，spring就自己创建一个名称为XXX的singleton bean
	// 这两个Bean就是一些系统配置和系统环境信息
	// Register default environment beans.
	// 如果没有定义 "environment" 这个 bean，那么 Spring 会 "手动" 注册一个
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	// 如果没有定义 "systemProperties" 这个 bean，那么 Spring 会 "手动" 注册一个
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	// 如果没有定义 "systemEnvironment" 这个 bean，那么 Spring 会 "手动" 注册一个
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
}

主要做了如下的操作：

设置了一个类加载器
设置了bean表达式解析器
添加了属性编辑器的支持
添加了一个后置处理器：ApplicationContextAwareProcessor，此后置处理器实现了BeanPostProcessor接口
设置了一些忽略自动装配的接口
设置了一些允许自动装配的接口，并且进行了赋值操作
在容器中还没有XX的bean的时候，帮我们注册beanName为XX的singleton bean

提供给子类的扩展点

postProcessBeanFactory(beanFactory);

这是一个空方法，以后提供给子类进行扩展。

完成扫描和解析

invokeBeanFactoryPostProcessors(beanFactory);

源码如下:可以结合流程图一起观看更佳：https://www.processon.com/view/link/5f18298a7d9c0835d38a57c0

/**
 * 实例化并执行所有注册的实现了BeanFactoryPostProcessor的bean,必须要在单例bean实例化之前调用
 */
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	//先看下getBeanFactoryPostProcessors方法
	//getBeanFactoryPostProcessor这里是获取自定义的BeanFactoryPostProcessor,一般为空
	// 1.getBeanFactoryPostProcessors(): 拿到当前应用上下文beanFactoryPostProcessors变量中的值
	// 2.invokeBeanFactoryPostProcessors: 实例化并调用所有已注册的BeanFactoryPostProcessor
	PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

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

让我们点开invokeBeanFactoryPostProcessors方法：

/**
 * Set<String> processedBeans = new HashSet<>();  存储执行过的BeanFactoryPostProcessor的bean名称
 * List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();  存储当前需要执行的实现了BeanDefinitionRegistryPostProcessor接口的后置处理器
 * List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();  存储实现了BeanFactoryPostProcessor接口的后置处理器
 * List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>(); 存储实现了BeanDefinitionRegistryPostProcessor接口的后置处理器
 * 执行流程
 * 1.判断是否存在ApplicationContext添加的实现BeanFactoryPostProcessor接口的类(refresh方法执行前)
 * 	如果存在,执行实现了BeanDefinitionRegistryPostProcessor接口特有的postProcessBeanDefinitionRegistry方法
 * 		将实现了BeanDefinitionRegistryPostProcessor接口存储到实现了BeanDefinitionRegistryPostProcessor接口的后置处理器registryProcessors
 * 	将实现了BeanFactoryPostProcessor接口存储到实现了BeanFactoryPostProcessor接口的后置处理器regularPostProcessors
 * 2.找出所有实现BeanDefinitionRegistryPostProcessor接口以及PriorityOrdered接口的Bean
 * 	一般来说,此时只有Spring内部的ConfigurationClassPostProcessor,将其添加到currentRegistryProcessors集合中(ConfigurationClassPostProcessor会解析加了@Configuration的配置类，还会解析@ComponentScan、@ComponentScans注解扫描的包，以及解析@Import)
 *  将currentRegistryProcessors集合中的bean名称存入processedBeans
 *  根据是否实现PriorityOrdered、Ordered接口和order值来进行排序
 *  将currentRegistryProcessors集合中的对象存储到registryProcessors,后续统一执行
 *  执行currentRegistryProcessors集合中的对象的postProcessBeanDefinitionRegistry方法
 *  清空currentRegistryProcessors集合
 * 3. 找出所有实现BeanDefinitionRegistryPostProcessor接口以及Ordered接口的Bean
 * 此处判断processedBeans.contains(ppName)即排除了上一步执行过的ConfigurationClassPostProcessor,
 * 其他逻辑完全同2
 * 重复执行原因:因为在我们上面执行过了BeanDefinitionRegistryPostProcessor中，可以在某个类中，我们扩展的时候又注册了一个实现了BeanDefinitionRegistryPostProcessor接口的后置处理器
 * 4. 找出所有实现BeanDefinitionRegistryPostProcessor接口以及两个排序接口都没有实现的接口的BeanDefinitionRegistryPostProcessor们
 * 此处判断processedBeans.contains(ppName)即排除了上一步执行过的ConfigurationClassPostProcessor
 * 只要发现有一个需要执行了的后置处理器，就需要再次循环，因为执行了这个后置处理可能会注册新的BeanDefinitionRegistryPostProcessor
 * 其他逻辑完全同2
 * 5.
 * 		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();  //保存直接实现了BeanFactoryPostProcessor接口和PriorityOrdered接口的后置处理器
 * 		List<String> orderedPostProcessorNames = new ArrayList<>(); // 保存直接实现了BeanFactoryPostProcessor接口和Ordered接口的后置处理器
 * 		List<String> nonOrderedPostProcessorNames = new ArrayList<>(); //保存直接实现了BeanFactoryPostProcessor接口的后置处理器，不包括那些实现了排序接口的类
 * 	找出所有实现BeanFactoryPostProcessor接口的BeanFactoryPostProcessors,排除在processedBeans集合中的,将BeanFactoryPostProcessors按照条件存入以上3个集合中
 * 6.排序并执行实现了priorityOrderedPostProcessors集合中的postProcessBeanFactory方法
 * 7.排序并执行实现了orderedPostProcessorNames集合中的postProcessBeanFactory方法
 * 8.排序并执行实现了nonOrderedPostProcessorNames集合中的postProcessBeanFactory方法
 * 9.注册ApplicationListenerDetector（主要是为了移动到处理器链的末尾）
 * 		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
 *
 * @param beanFactory  此处为DefaultListableBeanFactory
 * @param beanFactoryPostProcessors  在refresh方法执行前,ApplicationContext添加的实现BeanFactoryPostProcessor接口的类,一般为空
 */
public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

	//储存执行过的BeanFactoryPostProcessor
	// Invoke BeanDefinitionRegistryPostProcessors first, if any.
	Set<String> processedBeans = new HashSet<>();

	//只有此beanFactory 是BeanDefinitionRegistry  才能执行BeanDefinitionRegistryPostProcessor，才能修改Bean的定义嘛~
	//  1.判断beanFactory是否为BeanDefinitionRegistry，beanFactory为DefaultListableBeanFactory,而DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，因此这边为true
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		// 存储了只实现了BeanFactoryPostProcessor接口的后置处理器
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		// 存储了实现了BeanDefinitionRegistryPostProcessor接口的后置处理器
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

		// 2.首先处理入参中的beanFactoryPostProcessors
		//遍历所有的beanFactoryPostProcessors, 将BeanDefinitionRegistryPostProcessor和普通BeanFactoryPostProcessor区分开
		// 这个beanFactoryPostProcessors集合一般情况下都是空的，除非我们手动调用容器的addBeanFactoryPostProcessor方法
		//这里是我们自己的set进去的，若没set，这里就是空(若是Sprng容器里的，下面会处理，见下面)
		//自定义的beanFactoryPostProcessors,从此处可以看出，我们手动set进去的，是最优先执行的
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			// 2.1 如果是BeanDefinitionRegistryPostProcessor
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
				// 2.1.1 执行实现了BeanDefinitionRegistryPostProcessor接口的后置处理器的postProcessBeanDefinitionRegistry方法，
				// 注意这里执行的不是postProcessBeanFactory,是这个接口特有的postProcessBeanDefinitionRegistry方法
				registryProcessor.postProcessBeanDefinitionRegistry(registry);// 这里执行post方法，然后然后吧它缓冲起来了，放在了registryProcessors里
				// 2.1.2 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
				// 保存执行过了的BeanDefinitionRegistryPostProcessor，这里执行过的BeanDefinitionRegistryPostProcessor只是代表它的特有方法：postProcessBeanDefinitionRegistry方法执行过了，但是千万记得，它还有一个标准的postProcessBeanFactory，也就是从父接口中继承的方法还未执行
				registryProcessors.add(registryProcessor);
			}
			else {
				// 2.2 否则，只是普通的BeanFactoryPostProcessor
				// 2.2.1 添加到regularPostProcessors(用于最后执行postProcessBeanFactory方法)
				// 将只实现了BeanFactoryPostProcessor接口的后置处理器加入到集合中
				regularPostProcessors.add(postProcessor);
			}
		}
		// 接下来，就是去执行Spring容器里面的一些PostProcessor了。他们顺序也写得很清楚：先执行实现了PriorityOrdered接口的，然后是Ordered接口的，最后执行剩下的
		// 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接口的后置处理器
		//这个currentRegistryProcessors 放的是spring内部自己实现了BeanDefinitionRegistryPostProcessor接口的对象
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		// 发生一次bd的合并
		// 这里只会获取实现了BeanDefinitionRegistryPostProcessor接口的Bean的名字
		// 从容器中获取到所有实现了BeanDefinitionRegistryPostProcessor接口的Bean的名字
		//获取所有的BeanDefinitionRegistryPostProcessor类型BeanDefinition的名字
		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
		//BeanDefinitionRegistryPostProcessor 等于 BeanFactoryPostProcessor
		//getBeanNamesForType  根据bean的类型获取bean的名字ConfigurationClassPostProcessor
		// 3.调用所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类
		// 3.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

		//这个地方可以得到一个BeanFactoryPostProcessor，因为是spring默认在最开始自己注册的
		//为什么要在最开始注册这个呢？
		//因为spring的工厂需要许解析去扫描等等功能
		//而这些功能都是需要在spring工厂初始化完成之前执行
		//要么在工厂最开始的时候、要么在工厂初始化之中，反正不能再之后
		//因为如果在之后就没有意义，因为那个时候已经需要使用工厂了
		//所以这里spring'在一开始就注册了一个BeanFactoryPostProcessor，用来插手springfactory的实例化过程
		//在这个地方断点可以知道这个类叫做ConfigurationClassPostProcessor
		//ConfigurationClassPostProcessor那么这个类能干嘛呢？可以参考源码
		//下面我们对这个牛逼哄哄的类（他能插手spring工厂的实例化过程还不牛逼吗？）重点解释
		// 3.2 遍历postProcessorNames
		for (String ppName : postProcessorNames) {
			// 3.3 校验是否实现了PriorityOrdered接口
			//Spring容器自己提供的ConfigurationClassPostProcessor实现了PriorityOrdered接口,且优先级最低
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 3.4 获取ppName对应的bean实例, 添加到currentRegistryProcessors中,
				// beanFactory.getBean: 这边getBean方法会触发创建ppName对应的bean对象, 目前暂不深入解析
				// 如果满足条件，会将其创建出来，同时添加到集合中
				// 正常情况下，只会有一个，就是Spring容器自己提供的ConfigurationClassPostProcessor,Spring通过这个类完成了扫描以及BeanDefinition的功能
				//里面执行了扫描Bean，Import，ImportResouce等各种操作
				//用来处理配置类（有两种情况 一种是传统意义上的配置类，一种是普通的bean）的各种逻辑
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				// 3.5 将要被执行的加入processedBeans，避免后续重复执行
				processedBeans.add(ppName);// processedBeans也顺带保存了一份，保存的是bean的Name哦~
			}
		}

		// 3.6 进行排序(根据是否实现PriorityOrdered、Ordered接口和order值来排序
		// 根据实现的PriorityOrdered接口进行排序,不重要，况且currentRegistryProcessors这里也只有一个数据
		sortPostProcessors(currentRegistryProcessors, beanFactory);

		//合并Processors，为什么要合并，因为registryProcessors是装载BeanDefinitionRegistryPostProcessor的
		//一开始的时候，spring只会执行BeanDefinitionRegistryPostProcessor独有的方法
		//而不会执行BeanDefinitionRegistryPostProcessor父类的方法，即BeanFactoryProcessor的方法
		//所以这里需要把处理器放入一个集合中，后续统一执行父类的方法
		registryProcessors.addAll(currentRegistryProcessors);

		//可以理解为执行ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法
		//Spring热插播的体现，像ConfigurationClassPostProcessor就相当于一个组件，Spring很多事情就是交给组件去管理
		//如果不想用这个组件，直接把注册组件的那一步去掉就可以
		//最重要。注意这里是方法调用，就是把currentRegistryProcessors里面所有的处理器for循环一个个的执行掉
		//执行所有BeanDefinitionRegistryPostProcessor
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

		// 3.9 执行完毕后, 清空currentRegistryProcessors
		//执行完成了所有BeanDefinitionRegistryPostProcessor
		//这个list只是一个临时变量，故而要清除
		// 清空集合
		currentRegistryProcessors.clear();

		// 这里又进行了一个bd的合并
		// 这里重新获取实现了BeanDefinitionRegistryPostProcesso接口的后置处理器的名字，思考一个问题：为什么之前获取了一次不能直接用呢？还需要获取一次呢？
		// 这是因为在我们上面执行过了BeanDefinitionRegistryPostProcessor中，可以在某个类中，我们扩展的时候又注册了一个实现了BeanDefinitionRegistryPostProcessor接口的后置处理器
		// 此处逻辑完全同上，实例化和执行Ordered类型的BeanDefinitionRegistryPostProcessor
		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			// 确保没有被处理过并且实现了Ordered接口
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
				// 加入到当前需要被执行的集合中
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		// 根据ordered接口进行排序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		// 将当前将要执行的currentRegistryProcessors全部添加到registryProcessors这个集合中
		registryProcessors.addAll(currentRegistryProcessors);
		// 执行后置处理器的逻辑，这里只会执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		// 清空集合
		currentRegistryProcessors.clear();

		//最后执行，实例化和执行两个排序接口都没有实现的BeanDefinitionRegistryPostProcessor们
		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
		// 接下来这段代码是为了确认所有实现了BeanDefinitionRegistryPostProcessor的后置处理器能够执行完，
		// 之所有要一个循环中执行，也是为了防止在执行过程中注册了新的BeanDefinitionRegistryPostProcessor
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;

			// 5.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
			// 这里再次进行了一次bd的合并
			// 获取普通的BeanDefinitionRegistryPostProcessor，不需要实现PriorityOrdered或者Ordered接口
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 5.2 跳过已经执行过的
				// 只要发现有一个需要执行了的后置处理器，就需要再次循环，因为执行了这个后置处理可能会注册新的BeanDefinitionRegistryPostProcessor
				if (!processedBeans.contains(ppName)) {
					// 5.3 如果有BeanDefinitionRegistryPostProcessor被执行, 则有可能会产生新的BeanDefinitionRegistryPostProcessor,
					// 因此这边将reiterate赋值为true, 代表需要再循环查找一次
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
					reiterate = true;
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			// 执行的是普通的后置处理器，即没有实现任何排序接口（PriorityOrdered或Ordered)
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();
		}

		//执行上面实例化过所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
		// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
		//执行BeanFactoryPostProcessor的回调，前面不是吗？
		//前面执行的BeanFactoryPostProcessor的子类BeanDefinitionRegistryPostProcessor的回调
		//这是执行的是BeanFactoryPostProcessor    postProcessBeanFactory
		//regularPostProcessors.size=2包括配置类和自定义BeanFactoryPostProcessor
		// 这里开始执行单独实现了BeanFactoryPostProcessor接口的后置处理器
		// 1.先执行实现了BeanDefinitionRegistryPostProcessor的BeanFactoryPostProcessor，在前面的逻辑中我们只执行了BeanDefinitionRegistryPostProcessor特有的postProcessBeanDefinitionRegistry方法，它的postProcessBeanFactory方法还没有被执行，它会在这里被执行
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);

		// 2.执行直接实现了BeanFactoryPostProcessor接口的后置处理器
		//regularPostProcessors.size=0
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}

	else {
		// 正常情况下，进不来这个判断，不用考虑
		//若是普通的Bean工厂，就直接执行set进来的后置处理器即可（因为容器里就没有其它Bean定义了）
		// Invoke factory processors registered with the context instance.
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}
	// 获取所有实现了BeanFactoryPostProcessor接口的后置处理器，这里会获取到已经执行过的后置处理器，所以后面的代码会区分已经执行过或者未执行过
	//获取所有的BeanFactoryPostProcessor类型BeanDefinition的名字
	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let the bean factory post-processors apply to them!
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	// 保存直接实现了BeanFactoryPostProcessor接口和PriorityOrdered接口的后置处理器
	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	// 保存直接实现了BeanFactoryPostProcessor接口和Ordered接口的后置处理器
	//存放实现Ordered接口的BeanFactoryPostProcessor
	List<String> orderedPostProcessorNames = new ArrayList<>();
	// 保存直接实现了BeanFactoryPostProcessor接口的后置处理器，不包括那些实现了排序接口的类
	//存放上面2个接口都没有实现的BeanFactoryPostProcessor
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	for (String ppName : postProcessorNames) {
		if (processedBeans.contains(ppName)) {
			//如果当前BeanFactoryPostProcessor已经执行过了，忽略
			// 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);
		}
	}

	// 先执行实现了BeanFactoryPostProcessor接口和PriorityOrdered接口的后置处理器
	//执行实现PriorityOrdered接口的BeanFactoryPostProcessor
	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	// 再执行实现了BeanFactoryPostProcessor接口和Ordered接口的后置处理器
	// Next 执行实现Ordered接口的BeanFactoryPostProcessor
	// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
	for (String postProcessorName : orderedPostProcessorNames) {
		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	sortPostProcessors(orderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

	// 最后执行BeanFactoryPostProcessor接口的后置处理器，不包括那些实现了排序接口的类
	// Finally 执行实现剩下的BeanFactoryPostProcessor
	// Finally, invoke all other BeanFactoryPostProcessors.
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

	// 12.清除元数据缓存（mergedBeanDefinitions、allBeanNamesByType、singletonBeanNamesByType），
	// 因为后处理器可能已经修改了原始元数据，例如， 替换值中的占位符...
	// 将合并的BeanDefinition清空，这是因为我们在执行后置处理器时，可能已经修改过了BeanDefinition中的属性，所以需要清空，以便于重新合并
	// Clear cached merged bean definitions since the post-processors might have
	// modified the original metadata, e.g. replacing placeholders in values...
	beanFactory.clearMetadataCache();
}

首先判断beanFactory是不是BeanDefinitionRegistry的实例，当然肯定是的，然后执行如下操作：

定义了一个Set，装载BeanName，后面会根据这个Set，来判断后置处理器是否被执行过了。
定义了两个List，一个是regularPostProcessors，用来装载BeanFactoryPostProcessor，一个是registryProcessors用来装载BeanDefinitionRegistryPostProcessor，其中BeanDefinitionRegistryPostProcessor扩展了BeanFactoryPostProcessor。BeanDefinitionRegistryPostProcessor有两个方法，一个是独有的postProcessBeanDefinitionRegistry方法，一个是父类的postProcessBeanFactory方法。
循环传进来的beanFactoryPostProcessors，上面已经解释过了，一般情况下，这里永远都是空的，只有手动add beanFactoryPostProcessor，这里才会有数据。我们假设beanFactoryPostProcessors有数据，进入循环，判断postProcessor是不是BeanDefinitionRegistryPostProcessor，因为BeanDefinitionRegistryPostProcessor扩展了BeanFactoryPostProcessor，所以这里先要判断是不是BeanDefinitionRegistryPostProcessor，是的话，执行postProcessBeanDefinitionRegistry方法，然后把对象装到registryProcessors里面去，不是的话，就装到regularPostProcessors。
定义了一个临时变量：currentRegistryProcessors，用来装载BeanDefinitionRegistryPostProcessor。
getBeanNamesForType，顾名思义，是根据类型查到BeanNames，这里有一点需要注意，就是去哪里找，点开这个方法的话，就知道是循环beanDefinitionNames去找，这个方法以后也会经常看到。这里传了BeanDefinitionRegistryPostProcessor.class，就是找到类型为BeanDefinitionRegistryPostProcessor的后置处理器，并且赋值给postProcessorNames。一般情况下，只会找到一个，就是org.springframework.context.annotation.internalConfigurationAnnotationProcessor，也就是ConfigurationAnnotationProcessor。这个后置处理器在上一节中已经说明过了，十分重要。这里有一个问题，为什么我自己写了个类，实现了BeanDefinitionRegistryPostProcessor接口，也打上了@Component注解，但是这里没有获得，因为直到这一步，Spring还没有完成扫描，扫描是在ConfigurationClassPostProcessor类中完成的，也就是下面第一个invokeBeanDefinitionRegistryPostProcessors方法。
循环postProcessorNames，其实也就是org.springframework.context.annotation.internalConfigurationAnnotationProcessor，判断此后置处理器是否实现了PriorityOrdered接口（ConfigurationAnnotationProcessor也实现了PriorityOrdered接口），如果实现了，把它添加到currentRegistryProcessors这个临时变量中，再放入processedBeans，代表这个后置处理已经被处理过了。当然现在还没有处理，但是马上就要处理了。。。
进行排序，PriorityOrdered是一个排序接口，如果实现了它，就说明此后置处理器是有顺序的，所以需要排序。当然目前这里只有一个后置处理器，就是ConfigurationClassPostProcessor。
把currentRegistryProcessors合并到registryProcessors，为什么需要合并？因为一开始spring只会执行BeanDefinitionRegistryPostProcessor独有的方法，而不会执行BeanDefinitionRegistryPostProcessor父类的方法，即BeanFactoryProcessor接口中的方法，所以需要把这些后置处理器放入一个集合中，后续统一执行BeanFactoryProcessor接口中的方法。当然目前这里只有一个后置处理器，就是ConfigurationClassPostProcessor。
可以理解为执行currentRegistryProcessors中的ConfigurationClassPostProcessor中的postProcessBeanDefinitionRegistry方法，这就是Spring设计思想的体现了，在这里体现的就是其中的热插拔，插件化开发的思想。Spring中很多东西都是交给插件去处理的，这个后置处理器就相当于一个插件，如果不想用了，直接不添加就是了。这个方法特别重要，我们后面会详细说来。
清空currentRegistryProcessors，因为currentRegistryProcessors是一个临时变量，已经完成了目前的使命，所以需要清空，当然后面还会用到。
再次根据BeanDefinitionRegistryPostProcessor获得BeanName，然后进行循环，看这个后置处理器是否被执行过了，如果没有被执行过，也实现了Ordered接口的话，把此后置处理器推送到currentRegistryProcessors和processedBeans中。这里就可以获得我们定义的，并且打上@Component注解的后置处理器了，因为Spring已经完成了扫描，但是这里需要注意的是，由于ConfigurationClassPostProcessor在上面已经被执行过了，所以虽然可以通过getBeanNamesForType获得，但是并不会加入到currentRegistryProcessors和processedBeans。
处理排序。
合并Processors，合并的理由和上面是一样的。
执行我们自定义的BeanDefinitionRegistryPostProcessor。
清空临时变量。
在上面的方法中，仅仅是执行了实现了Ordered接口的BeanDefinitionRegistryPostProcessor，这里是执行没有实现Ordered接口的BeanDefinitionRegistryPostProcessor。
上面的代码是执行子类独有的方法，这里需要再把父类的方法也执行一次。
执行regularPostProcessors中的后置处理器的方法，需要注意的是，在一般情况下，regularPostProcessors是不会有数据的，只有在外面手动添加BeanFactoryPostProcessor，才会有数据。
查找实现了BeanFactoryPostProcessor的后置处理器，并且执行后置处理器中的方法。和上面的逻辑差不多，不再详细说明。

这就是这个方法中做的主要的事情了，可以说是比较复杂的。但是逻辑还是比较清晰的，在第9步的时候，我说有一个方法会详细说来，现在就让我们好好看看这个方法究竟做了什么吧。

这里面调用链很深,篇幅有限。

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
	//判断是否已经处理过,处理过,抛异常
	int registryId = System.identityHashCode(registry);
	if (this.registriesPostProcessed.contains(registryId)) {
		throw new IllegalStateException(
				"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
	}
	if (this.factoriesPostProcessed.contains(registryId)) {
		throw new IllegalStateException(
				"postProcessBeanFactory already called on this post-processor against " + registry);
	}
	this.registriesPostProcessed.add(registryId);
	//处理配置类的BeanDefinition
	processConfigBeanDefinitions(registry);
}

继续最后一行

/**
 * @param registry 此处就是DefaultListableBeanFactory
 * Build and validate a configuration model based on the registry of
 * {@link Configuration} classes.
 */
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
	//定义一个list存放bd,BeanDefinitionHolder是BeanDefinition的包装类
	List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
	//获取DefaultListableBeanFactory 中的beanDefinitionNames
	String[] candidateNames = registry.getBeanDefinitionNames();

	/**
	 * 遍历所有BeanDefinitionNames,筛选加了@Configuration的配置类
	 * Full
	 * Lite 目的是将配置类找出来
	 */
	for (String beanName : candidateNames) {
		BeanDefinition beanDef = registry.getBeanDefinition(beanName);
		//如果BeanDefinition中的configurationClass属性为full或者lite,则意味着已经处理过了,直接跳过
		if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) || ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
			if (logger.isDebugEnabled()) {
				logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
			}
		}
		// checkConfigurationClassCandidate()会判断一个是否是一个配置类,并为BeanDefinition设置属性为lite或者full。
		// 在这儿为BeanDefinition设置lite和full属性值是为了后面在使用
		// 如果加了@Configuration，那么对应的BeanDefinition为full;
		// 如果加了@Bean,@Component,@ComponentScan,@Import,@ImportResource这些注解，则为lite。
		//lite和full均表示这个BeanDefinition对应的类是一个配置类
		else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
			//BeanDefinitionHolder是BeanDefinition的包装类
			configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
		}
	}

	// Return immediately if no @Configuration classes were found
	if (configCandidates.isEmpty()) {
		return;
	}
	// 对configCandidates 进行 排序,按照@Order 配置的值进行排序,不重要
	// Sort by previously determined @Order value, if applicable
	configCandidates.sort((bd1, bd2) -> {
		int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
		int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
		return Integer.compare(i1, i2);
	});
	// 检测是否有自定义bean名称生成器
	// Detect any custom bean name generation strategy supplied through the enclosing application context
	SingletonBeanRegistry sbr = null;
	// 我们当前传入的是DefaultListableBeanFactory,是SingletonBeanRegistry 的子类,因此会将registry强转为SingletonBeanRegistry
	if (registry instanceof SingletonBeanRegistry) {
		sbr = (SingletonBeanRegistry) registry;
		if (!this.localBeanNameGeneratorSet) {
			//是否有自定义的命名生成器,不重要
			BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
			if (generator != null) {
				this.componentScanBeanNameGenerator = generator;
				this.importBeanNameGenerator = generator;
			}
		}
	}
	//检测是否存在环境对象
	if (this.environment == null) {
		this.environment = new StandardEnvironment();
	}
	//实例化ConfigurationClassParser 为了解析各个配置类
	// 创建配置类解析器,解析每一个@Configuration注解修饰的配置类
	// Parse each @Configuration class
	ConfigurationClassParser parser = new ConfigurationClassParser(
			this.metadataReaderFactory, this.problemReporter, this.environment,
			this.resourceLoader, this.componentScanBeanNameGenerator, registry);

	//实例化2个set,candidates用于将之前加入的configCandidates进行去重
	//因为可能有多个配置类重复了,去重
	Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
	//alreadyParsed用于判断是否处理过
	Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
	do {
		//核心代码,解析@Configuration,@Bean,@Component,@ComponentScan,@Import,@ImportResource这些类
		parser.parse(candidates);
		parser.validate();

		Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
		configClasses.removeAll(alreadyParsed);

		// Read the model and create bean definitions based on its content
		if (this.reader == null) {
			this.reader = new ConfigurationClassBeanDefinitionReader(
					registry, this.sourceExtractor, this.resourceLoader, this.environment,
					this.importBeanNameGenerator, parser.getImportRegistry());
		}
		this.reader.loadBeanDefinitions(configClasses);// 这个方法主要是把前面解析出来的配置类的beanDefinition都注册到容器中
		alreadyParsed.addAll(configClasses);

		candidates.clear();
		if (registry.getBeanDefinitionCount() > candidateNames.length) {
			String[] newCandidateNames = registry.getBeanDefinitionNames();
			Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
			Set<String> alreadyParsedClasses = new HashSet<>();
			for (ConfigurationClass configurationClass : alreadyParsed) {
				alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
			}
			for (String candidateName : newCandidateNames) {
				if (!oldCandidateNames.contains(candidateName)) {
					BeanDefinition bd = registry.getBeanDefinition(candidateName);
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
							!alreadyParsedClasses.contains(bd.getBeanClassName())) {
						candidates.add(new BeanDefinitionHolder(bd, candidateName));
					}
				}
			}
			candidateNames = newCandidateNames;
		}
	}
	while (!candidates.isEmpty());

	// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
	if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
		sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
	}

	if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
		// Clear cache in externally provided MetadataReaderFactory; this is a no-op
		// for a shared cache since it'll be cleared by the ApplicationContext.
		((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
	}
}

parser.parse(candidates)就是核心方法,后面就是扫描包了,详情请看生命周期一文

注册所有BeanPostProcessors

registerBeanPostProcessors(beanFactory);

源码如下

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

	// 1.找出所有实现BeanPostProcessor接口的类
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	// Register BeanPostProcessorChecker that logs an info message when
	// a bean is created during BeanPostProcessor instantiation, i.e. when
	// a bean is not eligible for getting processed by all BeanPostProcessors.
	// BeanPostProcessor的目标计数
	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	// 2.添加BeanPostProcessorChecker(主要用于记录信息)到beanFactory中
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	// Separate between BeanPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	// 3.定义不同的变量用于区分: 实现PriorityOrdered接口的BeanPostProcessor、实现Ordered接口的BeanPostProcessor、普通BeanPostProcessor
	// 3.1 priorityOrderedPostProcessors: 用于存放实现PriorityOrdered接口的BeanPostProcessor
	List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	// 3.2 internalPostProcessors: 用于存放Spring内部的BeanPostProcessor
	List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
	// 3.3 orderedPostProcessorNames: 用于存放实现Ordered接口的BeanPostProcessor的beanName
	List<String> orderedPostProcessorNames = new ArrayList<>();
	// 3.4 nonOrderedPostProcessorNames: 用于存放普通BeanPostProcessor的beanName
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	// 4.遍历postProcessorNames, 将BeanPostProcessors按3.1 - 3.4定义的变量区分开
	for (String ppName : postProcessorNames) {
		// 4.1 如果ppName对应的Bean实例实现了PriorityOrdered接口, 则拿到ppName对应的Bean实例并添加到priorityOrderedPostProcessors
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			priorityOrderedPostProcessors.add(pp);
			// 4.2 如果ppName对应的Bean实例也实现了MergedBeanDefinitionPostProcessor接口,则将ppName对应的Bean实例添加到internalPostProcessors
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		// 4.3 如果ppName对应的Bean实例没有实现PriorityOrdered接口, 但是实现了Ordered接口, 则将ppName添加到orderedPostProcessorNames
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		// 4.4 否则, 将ppName添加到nonOrderedPostProcessorNames
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	// 5.首先, 注册实现PriorityOrdered接口的BeanPostProcessors
	// First, register the BeanPostProcessors that implement PriorityOrdered.
	// 5.1 对priorityOrderedPostProcessors进行排序
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	// 5.2 注册priorityOrderedPostProcessors
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	// 6.接下来, 注册实现Ordered接口的BeanPostProcessors
	// Next, register the BeanPostProcessors that implement Ordered.
	List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
	for (String ppName : orderedPostProcessorNames) {
		// 6.1 拿到ppName对应的BeanPostProcessor实例对象
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		// 6.2 将ppName对应的BeanPostProcessor实例对象添加到orderedPostProcessors, 准备执行注册
		orderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			// 6.3 如果ppName对应的Bean实例也实现了MergedBeanDefinitionPostProcessor接口,
			// 则将ppName对应的Bean实例添加到internalPostProcessors
			internalPostProcessors.add(pp);
		}
	}
	// 6.4 对orderedPostProcessors进行排序
	sortPostProcessors(orderedPostProcessors, beanFactory);
	// 6.5 注册orderedPostProcessors
	registerBeanPostProcessors(beanFactory, orderedPostProcessors);

	// 7.注册所有常规的BeanPostProcessors（过程与6类似）
	// Now, register all regular BeanPostProcessors.
	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);

	// 8.最后, 重新注册所有内部BeanPostProcessors（相当于内部的BeanPostProcessor会被移到处理器链的末尾）
	// Finally, re-register all internal BeanPostProcessors.
	// 8.1 对internalPostProcessors进行排序
	sortPostProcessors(internalPostProcessors, beanFactory);
	// 8.2注册internalPostProcessors
	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).
	// 9.重新注册ApplicationListenerDetector（跟8类似，主要是为了移动到BeanPostProcessor链的末尾）
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);源码如下

private static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

	// 1.遍历postProcessors
	for (BeanPostProcessor postProcessor : postProcessors) {
		// 2.将PostProcessor添加到BeanFactory中的beanPostProcessors缓存
		beanFactory.addBeanPostProcessor(postProcessor);
	}
}

继续跟

@Override
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
	Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
	// Remove from old position, if any
	// 1.如果beanPostProcessor已经存在则移除（可以起到排序的效果，beanPostProcessor可能本来在前面，移除再添加，则变到最后面）
	this.beanPostProcessors.remove(beanPostProcessor);

	// 3.如果beanPostProcessor是InstantiationAwareBeanPostProcessor, 则将hasInstantiationAwareBeanPostProcessors设置为true,
	// 该变量用于指示beanFactory是否已注册过InstantiationAwareBeanPostProcessors
	// Track whether it is instantiation/destruction aware
	if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
		this.hasInstantiationAwareBeanPostProcessors = true;
	}
	// 4.如果beanPostProcessor是DestructionAwareBeanPostProcessor, 则将hasInstantiationAwareBeanPostProcessors设置为true,
	// 该变量用于指示beanFactory是否已注册过DestructionAwareBeanPostProcesso
	if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
		this.hasDestructionAwareBeanPostProcessors = true;
	}
	// 2.将beanPostProcessor添加到beanPostProcessors缓存
	// Add to end of list
	this.beanPostProcessors.add(beanPostProcessor);//核心代码
}

存入如下集合

private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();

国际化处理(不重要)

initMessageSource();

初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了

protected void initMessageSource() {
	//获取beanFactory,判断是否存在MessageSource
	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 {
		//如果不存在MessageSource,new DelegatingMessageSource,并注册到单例池
		// 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 + "]");
		}
	}
}

初始化事件广播器

initApplicationEventMulticaster();

源码如下

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() + "]");
		}
	}
}

扩展点

onRefresh();

空方法从方法名就可以知道，典型的模板方法(钩子方法)，
具体的子类可以在这里初始化一些特殊的 Bean,springboot在这里会做扩展

注册事件监听器

registerListeners();

源码如下

protected void registerListeners() {
	// Register statically specified listeners first.
	for (ApplicationListener<?> listener : getApplicationListeners()) {
		getApplicationEventMulticaster().addApplicationListener(listener);
	}

	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let post-processors apply to them!
	String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
	for (String listenerBeanName : listenerBeanNames) {
		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
	}

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

初始化所有非懒加载的单例bean

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

源码如下

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {

	// 为spring容器初始化类型转化器
	// Initialize conversion service for this context.
	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 bean post-processor
	// (such as a PropertyPlaceholderConfigurer bean) registered any before:
	// at this point, primarily for resolution in annotation attribute values.
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// 先初始化 LoadTimeWeaverAware 类型的 Bean
	// 之前也说过，这是 AspectJ 相关的内容，放心跳过吧
	// 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);

	// 到这一步的时候，Spring 已经开始预初始化 singleton beans 了，
	// 肯定不希望这个时候还出现 bean 定义解析、加载、注册。
	// Allow for caching all bean definition metadata, not expecting further changes.
	beanFactory.freezeConfiguration();

	//实例剩下所有非懒加载的单例类
	// Instantiate all remaining (non-lazy-init) singletons.
	beanFactory.preInstantiateSingletons();
}

最后一行

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

	// this.beanDefinitionNames 保存了所有的 beanNames
	// Iterate over a copy to allow for init methods which in turn register new bean definitions.
	// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// 下面这个循环，触发所有的非懒加载的 singleton beans 的初始化操作
	// Trigger initialization of all non-lazy singleton beans...
	for (String beanName : beanNames) {
		// 合并父 Bean 中的配置，得到RootBeanDefinition,合并后存在mergedBeanDefinitions的map中,
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

		// 非抽象、非懒加载的 singletons。如果配置了 'abstract = true'，那是不需要初始化的
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			// 如果该beanName对应的是FactoryBean,处理 FactoryBean,FactoryBean不需要遵循spring的bean生命周期
			if (isFactoryBean(beanName)) {
				// FactoryBean 的话，在 beanName 前面加上 ‘&’ 符号。再调用 getBean，getBean 方法
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
					final FactoryBean<?> factory = (FactoryBean<?>) bean;
					// 判断当前 FactoryBean 是否是 SmartFactoryBean 的实现，此处忽略，直接跳过
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
										((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						//是否是SmartFactoryBean且非懒加载
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						//创建真正的bean
						getBean(beanName);
					}
				}
			}
			else {
				//核心代码,创建真正的bean 对于普通的 Bean，只要调用 getBean(beanName) 这个方法就可以进行初始化了
				getBean(beanName);
			}
		}
	}

	// 到这里说明所有的非懒加载的 singleton beans 已经完成了初始化
	// 如果我们定义的 bean 是实现了 SmartInitializingSingleton 接口的，那么在这里得到回调，忽略
	// 7.遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调
	// Trigger post-initialization callback for all applicable beans...
	for (String beanName : beanNames) {
		// 7.1 拿到beanName对应的bean实例
		Object singletonInstance = getSingleton(beanName);
		// 7.2 判断singletonInstance是否实现了SmartInitializingSingleton接口
		if (singletonInstance instanceof SmartInitializingSingleton) {
			// 7.3 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			}
			else {
				smartSingleton.afterSingletonsInstantiated();
			}
		}
	}
}

getBean(beanName)是核心代码,在后面的生命周期一文中表述

容器初始化完成,广播事件

finishRefresh();

源码如下

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

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

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

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

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

至此,启动流程表述完毕

Spring启动过程主要做了这么几件事情：

构造一个BeanFactory对象
解析配置类，得到BeanDefinition，并注册到BeanFactory中

解析@ComponentScan，此时就会完成扫描
解析@Import
解析@Bean
...

因为ApplicationContext还支持国际化，所以还需要初始化MessageSource对象
因为ApplicationContext还支持事件机制，所以还需要初始化ApplicationEventMulticaster对象
把用户定义的ApplicationListener对象添加到ApplicationContext中，等Spring启动完了就要发布事件了
创建非懒加载的单例Bean对象，并存在BeanFactory的单例池中。
调用Lifecycle Bean的start()方法
发布ContextRefreshedEvent事件

由于Spring启动过程中要创建非懒加载的单例Bean对象，那么就需要用到BeanPostProcessor，所以Spring在启动过程中就需要做两件事：

生成默认的BeanPostProcessor对象，并添加到BeanFactory中

AutowiredAnnotationBeanPostProcessor：处理@Autowired、@Value
CommonAnnotationBeanPostProcessor：处理@Resource、@PostConstruct、@PreDestroy
ApplicationContextAwareProcessor：处理ApplicationContextAware等回调

找到外部用户所定义的BeanPostProcessor对象（类型为BeanPostProcessor的Bean对象），并添加到BeanFactory中

如何理解refresh()？

在Spring的设计中，也提供可以刷新的ApplicationContext和不可以刷新的ApplicationContext。比如：

AbstractRefreshableApplicationContext extends AbstractApplicationContext

就是可以刷新的

GenericApplicationContext extends AbstractApplicationContext

就是不可以刷新的。

AnnotationConfigApplicationContext继承的是GenericApplicationContext，所以它是不能刷新的。 AnnotationConfigWebApplicationContext继承的是AbstractRefreshableWebApplicationContext，所以它是可以刷的。

上面说的不能刷新是指不能重复刷新，只能调用一次refresh方法，第二次时会报错。

refresh()底层原理流程

底层原理流程图：https://www.processon.com/view/link/5f60a7d71e08531edf26a919

下面以AnnotationConfigApplicationContext为例子，来介绍refresh的底层原理。

在调用AnnotationConfigApplicationContext的构造方法之前，会调用父类GenericApplicationContext的无参构造方法，会构造一个BeanFactory，为DefaultListableBeanFactory。
构造AnnotatedBeanDefinitionReader（
主要作用添加一些基础的PostProcessor，同时可以通过reader进行BeanDefinition的注册
），同时对BeanFactory进行设置和添加
PostProcessor
（后置处理器）

设置dependencyComparator：AnnotationAwareOrderComparator，它是一个Comparator，是用来进行排序的，会获取某个对象上的Order注解或者通过实现Ordered接口所定义的值进行排序，在日常开发中可以利用这个类来进行排序。
设置autowireCandidateResolver：ContextAnnotationAutowireCandidateResolver，用来解析某个Bean能不能进行自动注入，比如某个Bean的autowireCandidate属性是否等于true
向BeanFactory中添加ConfigurationClassPostProcessor对应的BeanDefinition，它是一个BeanDefinitionRegistryPostProcessor，并且实现了PriorityOrdered接口
向BeanFactory中添加AutowiredAnnotationBeanPostProcessor对应的BeanDefinition，它是一个InstantiationAwareBeanPostProcessorAdapter，MergedBeanDefinitionPostProcessor
向BeanFactory中添加CommonAnnotationBeanPostProcessor对应的BeanDefinition，它是一个InstantiationAwareBeanPostProcessor，InitDestroyAnnotationBeanPostProcessor
向BeanFactory中添加EventListenerMethodProcessor对应的BeanDefinition，它是一个BeanFactoryPostProcessor，SmartInitializingSingleton
向BeanFactory中添加DefaultEventListenerFactory对应的BeanDefinition，它是一个EventListenerFactory

构造ClassPathBeanDefinitionScanner（
主要作用可以用来扫描得到并注册BeanDefinition
），同时进行设置：

设置this.includeFilters = AnnotationTypeFilter(Component.class)
设置environment
设置resourceLoader

利用reader注册AppConfig为BeanDefinition，类型为AnnotatedGenericBeanDefinition
接下来就是调用refresh方法
prepareRefresh()：

记录启动时间
可以允许子容器设置一些内容到Environment中
验证Environment中是否包括了必须要有的属性

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

设置beanFactory的类加载器
设置表达式解析器：StandardBeanExpressionResolver，用来解析Spring中的表达式
添加PropertyEditorRegistrar：ResourceEditorRegistrar，PropertyEditor类型转化器注册器，用来注册一些默认的PropertyEditor
添加一个Bean的后置处理器：ApplicationContextAwareProcessor，是一个BeanPostProcessor，用来执行EnvironmentAware、ApplicationEventPublisherAware等回调方法
添加
ignoredDependencyInterface
：可以向这个属性中添加一些接口，如果某个类实现了这个接口，并且这个类中的某些set方法在接口中也存在，那么这个set方法在自动注入的时候是不会执行的，比如EnvironmentAware这个接口，如果某个类实现了这个接口，那么就必须实现它的setEnvironment方法，而这是一个set方法，和Spring中的autowire是冲突的，那么Spring在自动注入时是不会调用setEnvironment方法的，而是等到回调Aware接口时再来调用（注意，这个功能仅限于xml的autowire，@Autowired注解是忽略这个属性的）

EnvironmentAware
EmbeddedValueResolverAware
ResourceLoaderAware
ApplicationEventPublisherAware
MessageSourceAware
ApplicationContextAware
另外其实在构造BeanFactory的时候就已经提前添加了另外三个：
BeanNameAware
BeanClassLoaderAware
BeanFactoryAware

添加
resolvableDependencies
：在byType进行依赖注入时，会先从这个属性中根据类型找bean

BeanFactory.class：当前BeanFactory对象
ResourceLoader.class：当前ApplicationContext对象
ApplicationEventPublisher.class：当前ApplicationContext对象
ApplicationContext.class：当前ApplicationContext对象

添加一个Bean的后置处理器：ApplicationListenerDetector，是一个BeanPostProcessor，用来判断某个Bean是不是ApplicationListener，如果是则把这个Bean添加到ApplicationContext中去，注意一个ApplicationListener只能是单例的
添加一个Bean的后置处理器：LoadTimeWeaverAwareProcessor，是一个BeanPostProcessor，用来判断某个Bean是不是实现了LoadTimeWeaverAware接口，如果实现了则把ApplicationContext中的loadTimeWeaver回调setLoadTimeWeaver方法设置给该Bean。
添加一些单例bean到单例池：

"environment"：Environment对象
"systemProperties"：System.getProperties()返回的Map对象
"systemEnvironment"：System.getenv()返回的Map对象

postProcessBeanFactory(beanFactory) ：提供给AbstractApplicationContext的子类进行扩展，具体的子类，可以继续向BeanFactory中再添加一些东西
invokeBeanFactoryPostProcessors(beanFactory)：
执行BeanFactoryPostProcessor

此时在BeanFactory中会存在一个BeanFactoryPostProcessor：ConfigurationClassPostProcessor，它也是一个BeanDefinitionRegistryPostProcessor
第一阶段
从BeanFactory中找到类型为BeanDefinitionRegistryPostProcessor的beanName，也就是ConfigurationClassPostProcessor，然后调用BeanFactory的getBean方法得到实例对象
执行ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry()方法:

解析AppConfig类
扫描得到BeanDefinition并注册
解析@Import，@Bean等注解得到BeanDefinition并注册
详细的看另外的笔记，专门分析了ConfigurationClassPostProcessor是如何工作的
在这里，我们只需要知道在这一步会去得到BeanDefinition，而这些BeanDefinition中可能存在BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor，所以执行完ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry()方法后，还需要继续执行其他BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法

执行其他BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
执行所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
第二阶段
从BeanFactory中找到类型为BeanFactoryPostProcessor的beanName，而这些BeanFactoryPostProcessor包括了上面的BeanDefinitionRegistryPostProcessor
执行还没有执行过的BeanFactoryPostProcessor的postProcessBeanFactory()方法

到此，所有的BeanFactoryPostProcessor的逻辑都执行完了，主要做的事情就是得到BeanDefinition并注册到BeanFactory中
registerBeanPostProcessors(beanFactory)：因为上面的步骤完成了扫描，这个过程中程序员可能自己定义了一些BeanPostProcessor，在这一步就会把BeanFactory中所有的BeanPostProcessor找出来并实例化得到一个对象，并添加到BeanFactory中去（属性beanPostProcessors），最后再重新添加一个ApplicationListenerDetector对象（之前其实就添加了过，这里是为了把ApplicationListenerDetector移动到最后）
initMessageSource()：如果BeanFactory中存在一个叫做"messageSource"的BeanDefinition，那么就会把这个Bean对象创建出来并赋值给ApplicationContext的messageSource属性，让ApplicationContext拥有国际化的功能
initApplicationEventMulticaster()：如果BeanFactory中存在一个叫做"applicationEventMulticaster"的BeanDefinition，那么就会把这个Bean对象创建出来并赋值给ApplicationContext的applicationEventMulticaster属性，让ApplicationContext拥有事件发布的功能
onRefresh()：提供给AbstractApplicationContext的子类进行扩展，没用
registerListeners()：从BeanFactory中获取ApplicationListener类型的beanName，然后添加到ApplicationContext中的事件广播器applicationEventMulticaster中去，到这一步因为FactoryBean还没有调用getObject()方法生成Bean对象，所以这里要在根据类型找一下ApplicationListener，记录一下对应的beanName
finishBeanFactoryInitialization(beanFactory)：完成BeanFactory的初始化，主要就是实例化非懒加载的单例Bean，单独的笔记去讲。
finishRefresh()：BeanFactory的初始化完后，就到了Spring启动的最后一步了
设置ApplicationContext的lifecycleProcessor，默认情况下设置的是DefaultLifecycleProcessor
调用lifecycleProcessor的onRefresh()方法，如果是DefaultLifecycleProcessor，那么会获取所有类型为Lifecycle的Bean对象，然后调用它的start()方法，这就是ApplicationContext的生命周期扩展机制
发布ContextRefreshedEvent事件

执行BeanFactoryPostProcessor

执行通过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()方法

Lifecycle的使用

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

@Componentpublic class ZhouyuLifecycle 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;	}}

解析配置类

在启动Spring时，需要传入一个AppConfig.class给ApplicationContext，ApplicationContext会根据AppConfig类封装为一个BeanDefinition，这种BeanDefinition我们把它称为配置类BeanDefinition。
ConfigurationClassPostProcessor中会把配置类BeanDefinition取出来
构造一个ConfigurationClassParser用来解析配置类BeanDefinition，并且会生成一个配置类对象ConfigurationClass
如果配置类上存在@Component注解，那么解析配置类中的内部类（这里有递归，如果内部类也是配置类的话）
如果配置类上存在@PropertySource注解，那么则解析该注解，并得到PropertySource对象，并添加到environment中去
如果配置类上存在@ComponentScan注解，那么则解析该注解，进行扫描，扫描得到一系列的BeanDefinition对象，然后判断这些BeanDefinition是不是也是配置类BeanDefinition（只要存在@Component注解就是配置类，所以基本上扫描出来的都是配置类），如果是则继续解析该配置类，（也有递归），并且会生成对应的ConfigurationClass
如果配置类上存在@Import注解，那么则判断Import的类的类型：

如果是ImportSelector，那么调用执行selectImports方法得到类名，然后在把这个类当做配置类进行解析（也是递归）
如果是ImportBeanDefinitionRegistrar，那么则生成一个ImportBeanDefinitionRegistrar实例对象，并添加到配置类对象中（ConfigurationClass）的importBeanDefinitionRegistrars属性中。

如果配置类上存在@ImportResource注解，那么则把导入进来的资源路径存在配置类对象中的importedResources属性中。
如果配置类中存在@Bean的方法，那么则把这些方法封装为BeanMethod对象，并添加到配置类对象中的beanMethods属性中。
如果配置类实现了某些接口，则看这些接口内是否定义了@Bean的默认方法
如果配置类有父类，则把父类当做配置类进行解析
AppConfig这个配置类会对应一个ConfigurationClass，同时在解析的过程中也会生成另外的一些ConfigurationClass，接下来就利用reader来进一步解析ConfigurationClass

如果ConfigurationClass是通过@Import注解导入进来的，则把这个类生成一个BeanDefinition，同时解析这个类上@Scope,@Lazy等注解信息，并注册BeanDefinition
如果ConfigurationClass中存在一些BeanMethod，也就是定义了一些@Bean，那么则解析这些@Bean，并生成对应的BeanDefinition，并注册
如果ConfigurationClass中导入了一些资源文件，比如xx.xml，那么则解析这些xx.xml文件，得到并注册BeanDefinition
如果ConfigurationClass中导入了一些ImportBeanDefinitionRegistrar，那么则执行对应的registerBeanDefinitions进行BeanDefinition的注册

总结一下

解析AppConfig类，生成对应的ConfigurationClass
再扫描，扫描到的类都会生成对应的BeanDefinition，并且同时这些类也是ConfigurationClass
再解析ConfigurationClass的其他信息，比如@ImportResource注解的处理，@Import注解的处理，@Bean注解的处理

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：R语言剔除离群值的方法 r语言离群值检测

下一篇：java page 设置不分页 java分页插件pagehelper

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯