剑指Spring源码之IOC源码解析

前言

最近工作之余有时间和精力，加上本人对源码比较感兴趣，就斗胆开始领略Spring源码的魅力，为加深印象和理解，适时进行文档输出。如有理解或表述错误，还望各位大佬不吝指正。

我看的是Spring5.2的源码，从同性社区下载下来后编译，然后看源码、写注释、一步一步debug，先尝试理解，再debug验证和更正理解。
一开始想着将所有调用到的方法都贴上来写上注释进行一番解析，后来发现不现实，而且也不好写，所以只能贴主要逻辑代码，其他的可以私下交流。
本人能力和理解都有限，不可能写一篇博客就完全领略到Spring的精髓，相信我，Spring源码自己看了真的会上瘾。

由于基于注解的开发是现在比较主流的开发模式，SpringBoot又将猿猿们从搭建开发环境的繁琐工作中解脱出来，专注于业务代码的开发，那么就从 AnnotationConfigApplicationContext 开始看起。

废话不多说，闲话不多聊，一起看代码吧。

类的体系结构

源码解析

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AmbitionConfig.class);

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {

	private final AnnotatedBeanDefinitionReader reader;
	
	private final ClassPathBeanDefinitionScanner scanner;

	public AnnotationConfigApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

	public  AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		/**
		 * 由于继承了父类，这里会先去调用父类的构造方法，然后调用自身的构造方法
		 *
		 * this.classLoader = ClassUtils.getDefaultClassLoader();
		 * this.beanFactory = new DefaultListableBeanFactory();
		 *
		 * 其实就是实例化 DefaultListableBeanFactory 和 ClassLoader
		 */
		this();
	
		/**
		 * 将传入的 @Configuration 配置类转换为 BeanDefinition
		 * 并添加到 DefaultListableBeanFactory 工厂的 BeanDefinitionMap 中
		 */
		register(annotatedClasses);
	
		refresh();
	}
	
	public void register(Class<?>... annotatedClasses) {
		Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
		// 用实例化的读取器注册注解类
		this.reader.register(annotatedClasses);
	}
}

由于AnnotationConfigApplicationContext继承了GenericApplicationContext，所以执行this()方法之前会先去执行父类的构造函数，代码如下：

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
	private final DefaultListableBeanFactory beanFactory;
	public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}
}

可以看到父类的构造函数实例化了一个DefaultListableBeanFactory，这就是Spring的BeanFactory，也可以说是Spring容器。

然后执行this()方法，这里实例化了一个ClassPathBeanDefinitionScanner扫描器，先说一下，实际负责Spring扫描工作的并不是这个对象，Spring在后面又实例化了一个这个扫描器，然后把属性值都拷贝过去，再执行扫描工作，这里只是为了提供一个ClassPathBeanDefinitionScanner对象的scanner()的API供外部调用。

还实例化了一个AnnotatedBeanDefinitionReader读取器，这里比较关键，Spring可以处理外部的注解，但是也需要相应的组件来处理，而这些组件不可能通过加@Component注解的方式加载进来，所以就需要硬编码将组件加载进来，加载Spring内部组件的逻辑就包含在这里面。

ClassPathScanningCandidateComponentProvider

public class ClassPathScanningCandidateComponentProvider implements EnvironmentCapable, ResourceLoaderAware {

	// 包含过滤器
	private final List<TypeFilter> includeFilters = new LinkedList<>();

	// 排除过滤器
	private final List<TypeFilter> excludeFilters = new LinkedList<>();

	// 为@Component注解组件注册默认的过滤器
	protected void registerDefaultFilters() {
		// 为包含过滤器集合添加 @Component 注解过滤器
		this.includeFilters.add(new AnnotationTypeFilter(Component.class));
		ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
		try {
			// 为包含过滤器集合添加 @ManagedBean 注解过滤器以支持 JSR-250 规范
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
			logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {
			// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
		}
		try {
			// 为包含过滤器集合添加 @Named 注解过滤器以支持 JSR-330 规范
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
			logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {
			// JSR-330 API not available - simply skip.
		}
	}
}

ClassPathBeanDefinitionScanner

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
		this(registry, true);
	}
	
	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry,
										  boolean useDefaultFilters) {
		this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
	}

	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry,
										  boolean useDefaultFilters,
										  Environment environment) {
		this(registry, useDefaultFilters, environment,
				(registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
	}
	
	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry,
										  boolean useDefaultFilters,
										  Environment environment,
										  @Nullable ResourceLoader resourceLoader) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;

		// 如果使用默认的扫描过滤器
		if (useDefaultFilters) {
			// 注册默认的扫描过滤器
			registerDefaultFilters();
		}
		setEnvironment(environment);
		setResourceLoader(resourceLoader);
	}
}

ClassPathBeanDefinitionScanner的父类ClassPathScanningCandidateComponentProvider有两个属性List<TypeFilter> includeFilters和List<TypeFilter> excludeFilters，指定了扫描器的扫描规则，registerDefaultFilters()方法就是注册Spring默认的扫描规则，如果不想使用默认的，可以通过addIncludeFilter()和addExcludeFilter()自定义扫描规则。

AnnotatedBeanDefinitionReader

public class AnnotatedBeanDefinitionReader {
	// BeanName 生成器，用来为扫描到的组件起名称，默认使用AnnotationBeanNameGenerator
	private BeanNameGenerator beanNameGenerator = AnnotationBeanNameGenerator.INSTANCE;

	// 条件评估器
	private ConditionEvaluator conditionEvaluator;
	
	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
		this(registry, getOrCreateEnvironment(registry));
	}

	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry,
										 Environment environment) {
		this.registry = registry;
		// 实例化条件评估器
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
		// 最重要的工作
	 	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

	// 注册注解类
	public void register(Class<?>... annotatedClasses) {
		Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
		this.reader.register(annotatedClasses);
	}

	public void registerBean(Class<?> annotatedClass) {
		doRegisterBean(annotatedClass, null, null, null, null);
	}
}

实例化读取器最重要的工作就是将Spring内部的注解后置处理器组件手动注册到 BeanDefinitionRegistry 中，即AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)这个方法。

AnnotationConfigUtils

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

	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry,
																			   @Nullable Object source) {
		// 获取 BeanFactory
		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());
			}
		}

		// 存放所有辅助Spring初始化的类
		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

		/**
		 * BeanDefinition 的注册，很重要，需要理解注册的每个 Bean 的类型和作用
		 *
		 * 1.ConfigurationClassPostProcessor             类型是 BeanFactoryPostProcessor
		 *
		 * 2.AutowiredAnnotationBeanPostProcessor        类型是 BeanPostProcessor
		 *
		 * 3.CommonAnnotationBeanPostProcessor           类型是 BeanPostProcessor
		 *
		 * 4.PersistenceAnnotationBeanPostProcessor      类型是 BeanPostProcessor
		 *
		 * 5.EventListenerMethodProcessor                类型是 BeanFactoryPostProcessor
		 *
		 * 6.DefaultEventListenerFactory                 类型是 EventListenerFactory
		 */

		/**
		 * BeanName 是否包含 org.springframework.context.annotation.internalConfigurationAnnotationProcessor
		 *
		 * BeanClass 是 ConfigurationClassPostProcessor，类型是 BeanFactoryPostProcessor
		 */
		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));
		}

		/**
		 * BeanName 是否包含 org.springframework.context.annotation.internalAutowiredAnnotationProcessor
		 *
		 * BeanClass 是 AutowiredAnnotationBeanPostProcessor，类型是 BeanPostProcessor，用来处理@Autowired注解
		 */
		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-250 支持，存在则添加 CommonAnnotationBeanPostProcessor
		 *
		 * BeanName 是否包含 org.springframework.context.annotation.internalCommonAnnotationProcessor
		 *
		 * BeanClass 是 CommonAnnotationBeanPostProcessor，类型是 BeanPostProcessor，用来处理@Resource注解
		 */
		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 支持，存在则添加 PersistenceAnnotationBeanPostProcessor
		 *
		 * BeanName 是否包含 org.springframework.context.annotation.internalPersistenceAnnotationProcessor
		 *
		 * BeanClass 是 PersistenceAnnotationBeanPostProcessor，类型是 BeanPostProcessor
		 */
		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));
		}

		/**
		 * BeanName 是否包含 org.springframework.context.event.internalEventListenerProcessor
		 *
		 * BeanClass 是 EventListenerMethodProcessor，类型是 BeanFactoryPostProcessor
		 */
		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));
		}

		/**
		 * BeanName 是否包含 org.springframework.context.event.internalEventListenerFactory
		 *
		 * BeanClass 是 DefaultEventListenerFactory，类型是 EventListenerFactory
		 */
		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;
	}

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

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

	public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
		processCommonDefinitionAnnotations(abd, abd.getMetadata());
	}

	static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd,
												   AnnotatedTypeMetadata metadata) {
		AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
		if (lazy != null) {
			abd.setLazyInit(lazy.getBoolean("value"));
		}
		else if (abd.getMetadata() != metadata) {
			lazy = attributesFor(abd.getMetadata(), Lazy.class);
			if (lazy != null) {
				abd.setLazyInit(lazy.getBoolean("value"));
			}
		}

		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}
		AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
		if (dependsOn != null) {
			abd.setDependsOn(dependsOn.getStringArray("value"));
		}

		AnnotationAttributes role = attributesFor(metadata, Role.class);
		if (role != null) {
			abd.setRole(role.getNumber("value").intValue());
		}
		AnnotationAttributes description = attributesFor(metadata, Description.class);
		if (description != null) {
			abd.setDescription(description.getString("value"));
		}
	}
}

Spring 在初始化 ApplicationContext 和 BeanFactory 时，在 BeanFactory 中注册了很多辅助初始化工作的类，这里的逻辑就是添加这些类，如果支持JPA就是6个辅助类，不需要就是5个。
特别注意ConfigurationClassPostProcessor这个类，辅助初始化工作主要由这个类来完成。

这一步执行完，可以看到BeanFactory中多了5个BeanDefinition，因为我这里没有JPA的组件，所以不需要JPA的辅助初始化类。

这样this()方法就执行完了，然后执行register(annotatedClasses)方法，代码跟进去可以看到最后调用的是AnnotatedBeanDefinitionReader的doRegisterBeandoRegisterBean()方法，AnnotatedBeanDefinitionReader就是之前实例化的读取器。
Spring的命令规范真的很形象易懂，看方法名字就可以知道代码的功能，而且几乎完全遵守了设计规范，将很多逻辑拆分成小的代码块，有专门的类负责，完全符合了设计模式的单一职责原则。

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

	// 根据指定的 Bean 创建一个 AnnotatedGenericBeanDefinition
	AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
	// 用之前实例化的条件评估器，根据 @Conditional 注解确定是否应跳过注册
	if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
		return;
	}

	abd.setInstanceSupplier(supplier);
	// 解析类的作用域元数据
	ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
	abd.setScope(scopeMetadata.getScopeName());
	// 如果为空则用之前实例化的 AnnotationBeanNameGenerator 生成主要的 BeanName
	String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

	/**
	 * 处理类当中的通用注解
	 * 主要处理 @Lazy @DependsOn @Primary @Role @Description 注解
	 * 处理完成之后将值赋给 AnnotatedGenericBeanDefinition 对应的属性中
	 */
	AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
	// 为空不执行
	if (qualifiers != null) {
		for (Class<? extends Annotation> qualifier : qualifiers) {
			if (Primary.class == qualifier) {
				// 设置 primary 属性值
				abd.setPrimary(true);
			}
			else if (Lazy.class == qualifier) {
				// 设置 lazyInit 属性值
				abd.setLazyInit(true);
			}
			else {
				/**
				 * 如果使用了除 @Primary 和 @Lazy 以外的其他注解
				 * 则为该 Bean 添加一个根据名字自动装配的限定符
				 */
				abd.addQualifier(new AutowireCandidateQualifier(qualifier));
			}
		}
	}

	// 为空不执行
	if (customizers != null) {
		for (BeanDefinitionCustomizer customizer : customizers) {
			customizer.customize(abd);
		}
	}

	/**
	 * 获取 BeanDefinitionHolder 持有者容器
	 * 里面包含的属性值有 beanName， beanDefinition 和 aliases 别名集合
	 */
	BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
	// 解析作用域代理模型
	definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
	/**
	 * 将最终获取到的 BeanDefinitionHolder 持有者容器中包含的信息注册给 BeanDefinitionRegistry
	 *
	 * AnnotationConfigApplicationContext 在初始化的时候通过调用父类的构造方法，实例化了一个 DefaultListableBeanFactory
	 * 这一步就是把 BeanDefinitionHolder 这个数据结构中包含的信息注册到 DefaultListableBeanFactory 中
	 *
	 * DefaultListableBeanFactory 实现了 BeanDefinitionRegistry
	 *
	 * 此时传入的 @Configuration 配置类已经注册到 DefaultListableBeanFactory 工厂中
	 */
	BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

这一步执行完，通过AnnotationConfigApplicationContext构造器传进来的配置类就注册到BeanFactory中了。

BeanDefinitionReaderUtils

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

		// 用类的主要名称注册 BeanDefinition
		String beanName = definitionHolder.getBeanName();
		// 注册 BeanDefinition
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// 如果有别名则注册别名
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				// 注册别名
				registry.registerAlias(beanName, alias);
			}
		}
	}

AbstractApplicationContext

然后就到了大名鼎鼎的refresh()方法了，逻辑过分复杂，只能挑两个重要的方法进行解析。

public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		/**
		 * 准备刷新上下文，设置其启动日期和活动标志以及执行属性源的任何初始化
		 *
		 * 设置刷新前的准备参数
		 * 校验启动参数
		 * 创建收集 ApplicationEvent 的集合
		 */
		prepareRefresh();

		/**
		 * 通知子类刷新内部的 bean 工厂
		 * 得到创建的 DefaultListableBeanFactory 工厂
		 * DefaultListableBeanFactory 实现了 ConfigurableListableBeanFactory
		 * 接下来对工厂进行初始化
		 */
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		/**
		 * 配置工厂的标准上下文特征
		 *
		 * 这里添加了 2 个 BeanPostProcessor
		 * 1、ApplicationContextAwareProcessor
		 * 2、ApplicationListenerDetector
		 */
		prepareBeanFactory(beanFactory);

		try {
			/**
			 * 允许在上下文子类中对 bean 工厂进行后置处理
			 *
			 * 当前版本的 Spring 代码中没有任何作用，可能是 Spring 为了在后面的版本中方便扩展
			 */
			postProcessBeanFactory(beanFactory);
			/**
			 * 第一重要的方法
			 *
			 * 完成扫描和解析操作
			 *
			 * 比较重要的一个是 ConfigurationClassPostProcessor
			 * 实例化 AnnotationConfigApplicationContext 时初始化了一个 AnnotatedBeanDefinitionReader
			 * AnnotatedBeanDefinitionReader 的构造方法中将 ConfigurationClassPostProcessor 注册到 BeanDefinition 中
			 *
			 * Spring 会先执行 BeanDefinitionRegistryPostProcessor
			 * 的所有实现类【ConfigurationClassPostProcessor】的 postProcessBeanDefinitionRegistry 方法完成扫描
			 * {@link org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry(BeanDefinitionRegistry)}
			 * 扫描后 转换为 BeanDefinition 并放入 BeanFactory 的 beanDefinitionMap 中
			 * 再执行 Spring 内部的和外部扩展的 BeanFactoryPostProcessor 修改 BeanFactory 的数据
			 * {@link BeanFactoryPostProcessor#postProcessBeanFactory(ConfigurableListableBeanFactory)}
			 */
			invokeBeanFactoryPostProcessors(beanFactory);
			/**
			 * 注册 BeanPostProcessor，Spring AOP 就是在这里进行注册的
			 * 这里注意 1 个 BeanPostProcessor : BeanPostProcessorChecker
			 **/
			registerBeanPostProcessors(beanFactory);
			/**
			 * 初始化此上下文的消息源
			 **/
			initMessageSource();
			/**
			 * 初始化应用事件广播器【SpringBoot 的启动源码中与该方法有很大关系】
			 *
			 * 初始化 ApplicationEventMulticaster
			 * 如果 BeanFactory 中不存在 applicationEventMulticaster 则初始化一个 SimpleApplicationEventMulticaster
			 * 并注册其为单例到 BeanFactory 中
			 **/
			initApplicationEventMulticaster();
			/**
			 * 开放式方法，在特定的上下文子类中初始化其他特殊 Bean
			 * 【启动 Spring Boot，Tomcat】
			 **/
			onRefresh();
			/**
			 * 检查监听器 Bean 并注册它们
			 **/
			registerListeners();
			/**
			 * 第二重要的方法
			 * 实例化所有剩余（非延迟初始化）单例类
			 */
			finishBeanFactoryInitialization(beanFactory);
			/**
			 * 最后一步：发布相应的事件
			 * 【EUREKA 服务就是在这里启动的】
			 */
			finishRefresh();
		}
		catch (BeansException ex) {
			/**
			 * 摧毁已经创建的单例 Bean 以避免悬空资源
			 */
			destroyBeans();
			/**
			 * 重置 active 属性值
			 */
			cancelRefresh(ex);
			
			throw ex;
		}
		finally {
			resetCommonCaches();
		}
	}
}

/**
 * 实例化并调用所有注册的 BeanFactoryPostProcessor Bean，并遵循显式顺序（如果给定的话）
 * 必须在单例实例化之前调用
 */
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	/**
	 * 执行所有
	 * {@link org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor#postProcessBeanFactory(ConfigurableListableBeanFactory)}
	 * 再执行所有
	 * {@link BeanFactoryPostProcessor#postProcessBeanFactory(ConfigurableListableBeanFactory)}
	 **/
	PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

	......
}

/**
 * 完成此上下文的 BeanFactory 的初始化，初始化所有剩余的单例 Bean
 */
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	/**
	 * 初始化此上下文的转换服务
	 */
	if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME)
			&& beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
		beanFactory.setConversionService(
				beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
	}

	/**
	 * 如果之前没有注册 beanPostProcessor（例如 PropertyPlaceholderConfigurer）
	 * 则注册默认的嵌入值解析器：此时主要用于注释属性值的解析
	 */
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// 获取 LoadTimeWeaverAware 的 BeanName 集合
	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
	for (String weaverAwareName : weaverAwareNames) {
		// 初始化 LoadTimeWeaverAware 以允许尽早注册其变换器
		getBean(weaverAwareName);
	}

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

	// 允许缓存所有 BeanDefinition 元数据，此时不再允许进一步的更改
	beanFactory.freezeConfiguration();

	// 实例化所有不是懒加载的单例对象
	beanFactory.preInstantiateSingletons();
}	
	

第一个重要且复杂的方法是PostProcessorRegistrationDelegate的invokeBeanFactoryPostProcessors()，第二个重要且复杂的方法是DefaultListableBeanFactory的preInstantiateSingletons()方法，请做好防护，保护我方头发，非战斗人员自行撤离，这不是演习。

PostProcessorRegistrationDelegate

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory,
											  	   List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
	/**
	 * beanFactory 是 DefaulLisableBeanFactory
	 * beanFactoryPostProcessors 集合大小为0，只有通过外部API添加才会有值
	 **/
	 
	/**
	 * 如果有的话，首先调用 BeanDefinitionRegistryPostProcessors
	 * 存放所有的 BeanDefinitionRegistryPostProcessors
	 **/
	Set<String> processedBeans = new HashSet<>();

	/**
	 * 如果是 BeanDefinitionRegistry 的子类
	 *
	 * beanFactory 是 DefaultListableBeanFactory
	 * DefaultListableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry
	 */
	if (beanFactory instanceof BeanDefinitionRegistry) {

		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
	
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		/**
		 * BeanDefinitionRegistryPostProcessor 继承了 BeanFactoryPostProcessor
		 */
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

		/**
		 * 区分 BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor，初始化集合元素
		 *
		 * 此时还没有任何元素，只有通过 API 添加了 BeanFactoryPostProcessor 才会执行
		 * {@link AbstractApplicationContext#addBeanFactoryPostProcessor(org.springframework.beans.factory.config.BeanFactoryPostProcessor)}
		 * 这种情形很少，一般是通过注解来添加一个 BeanFactoryPostProcessor
		 * 所以下面这个循环很少会执行
		 **/
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			/**
			 * 实现了 BeanDefinitionRegistryPostProcessor
			 *
			 * 这里只有一个 ConfigurationClassPostProcessor
			 *
			 * public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor
			 * 这里 Spring 需要保证自己内置的先执行，为了和外部扩展的区分，进行了判断
			 **/
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {

				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				/**
				 * 执行完后添加到集合中，稍后执行其父类的方法
				 **/
				registryProcessors.add(registryProcessor);
			}
			// 实现了 BeanFactoryPostProcessor
			else {
				/**
				 * 直接添加到集合中，稍后执行其父类的方法
				 **/
				regularPostProcessors.add(postProcessor);
			}
		}
		
		/**
		 * 将实现 PriorityOrdered，Ordered 和其余的 BeanDefinitionRegistryPostProcessors 分开执行
		 *
		 * 存放当前正在注册的 BeanDefinitionRegistryPostProcessor
		 * 临时变量，分别找到实现 PriorityOrdered、Ordered 和其他的 BeanDefinitionRegistryPostProcessor
		 * 执行其 postProcessBeanDefinitionRegistry 方法
		 */
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		/**
		 * 根据类型从 List<String> beanDefinitionNames 和 Set<String> manualSingletonNames 中获取名称
		 *
		 * 获取 BeanDefinitionRegistryPostProcessor bean 名称
		 *
		 * 此时至少包含了一个 ConfigurationClassPostProcessor
		 * ConfigurationClassPostProcessor 实现了 BeanDefinitionRegistryPostProcessor
		 * 名称为 internalConfigurationAnnotationProcessor
		 */
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

		/**
		 * ConfigurationClassPostProcessor 最重要的类
		 */
		for (String ppName : postProcessorNames) {
			/**
			 * 首先，调用实现 PriorityOrdered 的 BeanDefinitionRegistryPostProcessors
			 *
			 * ConfigurationClassPostProcessor 实现了 PriorityOrdered
			 */
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				/**
				 * 获取该 Bean，并添加到集合中
				 *
				 * beanFactory.getBean() 方法做了两件事
				 * 首先从容器中获取，获取到则返回
				 * 否则会实例化这个 Bean
				 **/
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		// 排序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		/**
		 * 调用 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry 方法【重要】
		 * 扫描配置类并注册所有符合条件的 BeanDefinition
		 *
		 * 集合中的元素包含 ConfigurationClassPostProcessor
		 * {@link ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry(org.springframework.beans.factory.support.BeanDefinitionRegistry)}
		 *
		 * 此时 Spring 已经加载完所有辅助初始化的内部类，开始构建和解析配置类
		 */
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		/**
		 * 执行完成，清空当前注册的处理器集合数据
		 *
		 * 至少清除包含的 ConfigurationClassPostProcessor
		 **/
		currentRegistryProcessors.clear();

		/**
		 * 获取 BeanDefinitionRegistryPostProcessor BeanName
		 * 下面的代码理论上不会执行，只是 Spring 确保初始化过程中没有新的类被添加进来
		 **/
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		/**
		 * 接下来，调用实现 Ordered 的 BeanDefinitionRegistryPostProcessors
		 */
		for (String ppName : postProcessorNames) {
			// 不在 processedBeans 中且实现了 Ordered 的 BeanDefinitionRegistryPostProcessors
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
				// 获取该 bean，并添加到集合中
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		// 排序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		/**
		 * 调用 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry 方法
		 */
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		// 执行完成，清空集合数据
		currentRegistryProcessors.clear();

		/**
		 * 最后，调用所有剩余的 BeanDefinitionRegistryPostProcessors
		 * 直到不再出现其他 BeanDefinitionRegistryPostProcessors
		 */
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			// 获取 BeanDefinitionRegistryPostProcessor 名称
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 不在 processedBeans 中的 BeanDefinitionRegistryPostProcessors
				if (!processedBeans.contains(ppName)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
					/**
					 * 已经添加的 BeanDefinitionRegistryPostProcessor 可能还会产生新的 BeanDefinitionRegistryPostProcessor
					 * {@link BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry(org.springframework.beans.factory.support.BeanDefinitionRegistry)}
					 * 有了 BeanDefinitionRegistry 变量可以往 beanDefinitionMap 中添加新的元素
					 * 所以将 reiterate 置为 true 表示再找一遍
					 **/
					reiterate = true;
				}
			}
			// 排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			/**
			 * 调用 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry 方法
			 */
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			// 执行完成，清空集合数据
			currentRegistryProcessors.clear();
		}
		
		/**
		 * 执行所有 BeanDefinitionRegistryPostProcessor 的 postProcessBeanFactory 方法
		 */
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		/**
		 * 执行所有 BeanFactoryPostProcessor 的 postProcessBeanFactory 方法
		 **/
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}
	else {
		/**
		 * 调用在上下文实例中注册的工厂处理器
		 */
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}

	/**
	 * 获取 BeanFactoryPostProcessor 名称
	 * 此时至少有两个元素：
	 *      org.springframework.context.annotation.internalConfigurationAnnotationProcessor
	 *      org.springframework.context.event.internalEventListenerProcessor
	 *
	 * 需要保留所有未初始化的常规 bean，以使 bean 工厂后处理器适用于这些 bean
	 */
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	/**
	 * 分隔实现了 PriorityOrdered，Ordered 和其余的 BeanFactoryPostProcessors
	 */
	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
		}
		// 实现了 PriorityOrdered
		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
		}
		// 实现了 Ordered
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		// 普通类
		else {
			// org.springframework.context.event.internalEventListenerProcessor 是普通类
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	/**
	 * 首先，调用实现 PriorityOrdered 的 BeanFactoryPostProcessors
	 */
	// 排序
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	/**
	 * 调用 BeanFactoryPostProcessor#postProcessBeanFactory 方法
	 **/
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	/**
	 * 接下来，调用实现 Ordered 的 BeanFactoryPostProcessors
	 */
	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
	for (String postProcessorName : orderedPostProcessorNames) {
		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	// 排序
	sortPostProcessors(orderedPostProcessors, beanFactory);
	/**
	 * 调用 BeanFactoryPostProcessor#postProcessBeanFactory 方法
	 **/
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
	/**
	 * 最后，调用所有其他 BeanFactoryPostProcessors
	 */
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	/**
	 * 调用 BeanFactoryPostProcessor#postProcessBeanFactory 方法
	 **/
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
	/**
	 * 清除缓存的合并 bean 定义，因为后处理器可能已经修改了原始元数据，例如，替换值中的占位符
	 */
	beanFactory.clearMetadataCache();
}

这段代码很长，很复杂，其实主要做了这么几件事：
1.首先找外部通过API添加的BeanFactoryPostProcessor，将其和BeanDefinitionRegistryPostProcessor区分开（因为虽然BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor，但是它们有不同的行为）。如果外部添加了，是BeanDefinitionRegistryPostProcessor，则执行其postProcessBeanDefinitionRegistry()方法，并加入到集合中。如果是BeanFactoryPostProcessor，则直接加入到集合中。

2.接着从Spring容器中获取BeanDefinitionRegistryPostProcessor类型的组件（这里就有之前硬编码注册到容器中的ConfigurationClassPostProcessor），调用beanFactory.getBean()方法实例化，这里beanFactory.getBean()方法又是一个极其复杂的过程，涉及到三级缓存、解循环依赖、推断构造方法、属性填充等，后面会一起说明。
然后执行invokeBeanDefinitionRegistryPostProcessors()方法，其实就是执行ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry()方法，基于配置类的注册表构建并验证配置模型，将符合条件（指定扫描包下加了@Component、@Bean注解、@Import注解等）的类注册到BeanFactory中。

3.此时Spring内部的组件和外部用户的组件都注册到Spring容器中了，然后再从Spring容器中获取BeanDefinitionRegistryPostProcessor类型的组件
，没有处理过且实现了Ordered接口的会调用其postProcessBeanDefinitionRegistry()方法。

4.再从Spring容器中获取BeanDefinitionRegistryPostProcessor类型的组件，这次只要没有处理就会调用beanFactory.getBean()实例化，并执行其postProcessBeanDefinitionRegistry()方法，直到不再有新的组件被找到。其实就是Spring防止在执行过程中又有新的组件被添加进来了，毕竟Spring提供了很多开放式的接口和API供外部调用，所以要确保全部处理完成。

5.执行所有找到的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法。

6.执行所有找到的BeanFactoryPostProcessor的postProcessBeanFactory()方法。

7.从Spring容器中获取BeanFactoryPostProcessor类型的组件，没有处理过的，将其按实现了PriorityOrdered、Ordered和普通的进行区分，调用其postProcessBeanFactory()方法，这里有一个之前硬编码注册进去的EventListenerMethodProcessor。

ConfigurationClassPostProcessor

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {

	// 存放候选配置类的 BeanDefinitionHolder 集合
	List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
	/**
	 * 获取容器中注册的所有 BeanDefinition 名称
	 *
	 * 此时包括 AnnotatedBeanDefinitionReader 扫描的 5 个或者 6 个
	 * 和初始化 Spring 上下文环境时传入的一个配置类
	 */
	String[] candidateNames = registry.getBeanDefinitionNames();

	/**
	 * 遍历获取需要解析的类，即获取配置类
	 *
	 * 只有加了 @Configuration 注解的配置类才有 configurationClass 属性值
	 **/
	for (String beanName : candidateNames) {
		// 获取 BeanDefinition
		BeanDefinition beanDef = registry.getBeanDefinition(beanName);
		/**
		 * 如果 BeanDefinition 中的 configurationClass 属性为 full 或者 lite，则表示已经解析过了，直接跳过
		 *
		 * 因为解析过的话，Spring 会将 configurationClass 属性值设为 full 或者 lite
		 * {@link ConfigurationClassUtils#checkConfigurationClassCandidate(org.springframework.beans.factory.config.BeanDefinition, org.springframework.core.type.classreading.MetadataReaderFactory)}
		 */
		if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
			if (logger.isDebugEnabled()) {
				logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
			}
		}
		/**
		 * 否则判断是否是 @Configuration 注解配置类，加了则通过校验，没加再判断是否加了以下注解
		 *
		 * candidateIndicators.add(Component.class.getName());
		 * candidateIndicators.add(ComponentScan.class.getName());
		 * candidateIndicators.add(Import.class.getName());
		 * candidateIndicators.add(ImportResource.class.getName());
		 *
		 * 如果加了 @Configuration 注解，会在后面再解析其他注解；如果没加，只会单独解析相应的注解
		 *
		 * 此时只有传进来的配置类会执行
		 */
		else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
			// 有的话就添加到 BeanDefinitionHolder 集合中【此时传入的配置类会添加进集合中】
			configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
		}
	}

	// 没有发现未处理的 @Configuration 类则返回
	if (configCandidates.isEmpty()) {
		return;
	}

	......

	/**
	 * 实例化 ConfigurationClassParser 对象，用于解析 @Configuration 类
	 **/
	ConfigurationClassParser parser = new ConfigurationClassParser(
			this.metadataReaderFactory,
			this.problemReporter,
			this.environment,
			this.resourceLoader,
			this.componentScanBeanNameGenerator,
			registry
	);

	/**
	 * 定义两个集合
	 * candidates 集合用于将之前加入的候选配置类进行去重，因为可能有重复的
	 * alreadyParsed 用于存放已解析过的配置类
	 */
	Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
	// 因为用 do-while 循环进行解析，所以初始容量为 configCandidates.size()
	Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
	do {
		/**
		 * 解析配置类【重要】
		 *
		 * 只注册包扫描器扫描到的 BeanDefinition
		 */
		parser.parse(candidates);
		/**
		 * 验证配置类
		 *
		 * 主要验证 @Configuration 的 @Bean 方法是否是静态和可覆盖的
		 * 静态则跳过验证
		 * @Configuration 类中的实例 @Bean 方法必须可以覆盖才能容纳 CGLIB
		 */
		parser.validate();

		/**
		 * 去重
		 *
		 * 此时加了注解的普通类已经注册完成，包括 @Configuration 配置类
		 * @Bean 方法定义的类不在里面，
		 * @Import 引入的类在里面
		 * 可以认为注册了所有加了 @Component 注解的组件
		 */
		Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
		// 移除所有已解析的
		configClasses.removeAll(alreadyParsed);

		/**
		 * 读取模型并根据其内容创建 BeanDefinition
		 **/
		if (this.reader == null) {
			// 实例化 ConfigurationClassBeanDefinitionReader 读取器，用于创建 BeanDefinitions
			// 之前实例化的是 AnnotatedBeanDefinitionReader 读取器
			this.reader = new ConfigurationClassBeanDefinitionReader(
					registry,
					this.sourceExtractor,
					this.resourceLoader,
					this.environment,
					this.importBeanNameGenerator,
					parser.getImportRegistry()
			);
		}
		/**
		 * 加载 BeanDefinitions 存入集合中【重要】
		 *
		 * 注册 @Bean，ImportSelector，@ImportResource，ImportBeanDefinitionRegistrar 的 BeanDefinition
		 **/
		this.reader.loadBeanDefinitions(configClasses);
		// 全部标记为已处理
		alreadyParsed.addAll(configClasses);
		// 清空候选者集合，后面保存经过校验存在是配置类的候选者 并且 没有处理过
		candidates.clear();

		/**
		 * 处理后工厂内的 BeanDefinition 数量大于处理前的数量
		 *
		 * 判断是否已解析完，candidateNames.length 为 6 或者 7
		 **/
		if (registry.getBeanDefinitionCount() > candidateNames.length) {
			// 处理后 BeanFactory 中 beanDefinitionNames 数据
			String[] newCandidateNames = registry.getBeanDefinitionNames();
			// 处理前 BeanFactory 中 beanDefinitionNames 数据
			Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));

			/**
			 * alreadyParsed + oldCandidateNames = newCandidateNames
			 */
			Set<String> alreadyParsedClasses = new HashSet<>();

			// 已解析的 @Component 注解组件类添加到 alreadyParsedClasses 集合中
			for (ConfigurationClass configurationClass : alreadyParsed) {
				alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
			}

			/**
			 * 循环遍历处理后的 beanDefinitionNames
			 */
			for (String candidateName : newCandidateNames) {
				/**
				 * 过滤出处理后的候选者中存在于处理前的候选者，即 alreadyParsed 中候选者
				 *
				 * 为什么不直接遍历 alreadyParsed 集合，而是通过这种方式？
				 * 可能是 Spring 怕当前正在解析的时候，又手动添加了新的需要解析的类
				 **/
				if (!oldCandidateNames.contains(candidateName)) {
					BeanDefinition bd = registry.getBeanDefinition(candidateName);
					// 再次检查 BeanDefinition 是否是配置类的候选者 并且 没有处理过
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory)
							&& !alreadyParsedClasses.contains(bd.getBeanClassName())) {
						candidates.add(new BeanDefinitionHolder(bd, candidateName));
					}
				}
			}
			// 标记所有候选者已处理完成
			candidateNames = newCandidateNames;
		}
	}
	// 全部解析完结束循环
	while (!candidates.isEmpty());

	......
}

又是一段又长又复杂的代码块，细分一下主要做了一下几件事：
1.获取容器中所有已注册的BeanDefinitionName，遍历获取未处理过的配置类，将其封装为BeanDefinitionHolder并添加到集合中。

2.实例化ConfigurationClassParser对象，用于解析 @Configuration 配置类。

3.循环执行解析、验证、加载等操作，直到所有的候选类都处理完成。

可以看到最重要的就是parser.parse()方法。

ConfigurationClassParser

public void parse(Set<BeanDefinitionHolder> configCandidates) {
	for (BeanDefinitionHolder holder : configCandidates) {
		// 获取 BeanDefinition
		BeanDefinition bd = holder.getBeanDefinition();
		try {
			// 是 AnnotatedBeanDefinition 的子类
			if (bd instanceof AnnotatedBeanDefinition) {
				/**
				 * 解析注解对象，并存入 Map<ConfigurationClass, ConfigurationClass> 集合中
				 */
				parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
			}
			// 是 AbstractBeanDefinition 的子类 并且 指定了 Bean 类
			else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
				parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
			}
			// 其他情况
			else {
				parse(bd.getBeanClassName(), holder.getBeanName());
			}
		}
		catch (BeanDefinitionStoreException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanDefinitionStoreException(
					"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
		}
	}
	// 执行延迟导入选择器处理逻辑
	this.deferredImportSelectorHandler.process();
}

protected final void parse(AnnotationMetadata metadata,
						   String beanName) throws IOException {
	processConfigurationClass(new ConfigurationClass(metadata, beanName));
}

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
	// 判断是否需要跳过
	if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
		return;
	}

	/**
	 * 先尝试从缓存中获取
	 */
	ConfigurationClass existingClass = this.configurationClasses.get(configClass);
	if (existingClass != null) {
		// 如果当前类通过别的类导入进来，则做如下处理
		if (configClass.isImported()) {
			if (existingClass.isImported()) {
				// 合并
				existingClass.mergeImportedBy(configClass);
			}
			// 否则忽略新导入的配置类; 现有的非导入类会覆盖它
			return;
		}
		else {
			// 找到显式 BeanDefinition，可能替换导入，则删除旧的并使用新的
			this.configurationClasses.remove(configClass);
			this.knownSuperclasses.values().removeIf(configClass::equals);
		}
	}

	/**
	 * 递归处理配置类及其超类层次结构
	 */
	SourceClass sourceClass = asSourceClass(configClass);
	do {
		/**
		 * 真正的解析配置类
		 **/
		sourceClass = doProcessConfigurationClass(configClass, sourceClass);
	} while (sourceClass != null);
	// 存入缓存中
	this.configurationClasses.put(configClass, configClass);
}

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass,
															SourceClass sourceClass) throws IOException {

	// 是否加了 @Component 注解，@Configuration 注解同样适用
	if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
		/**
		 * 首先递归处理任何成员（嵌套）类
		 */
		processMemberClasses(configClass, sourceClass);
	}

	/**
	 * 处理 @PropertySource 注解
	 */
	Set<AnnotationAttributes> annotationAttributes = AnnotationConfigUtils.attributesForRepeatable(
			sourceClass.getMetadata(),
			PropertySources.class,
			org.springframework.context.annotation.PropertySource.class
	);
	for (AnnotationAttributes propertySource : annotationAttributes) {
		if (this.environment instanceof ConfigurableEnvironment) {
			// 处理给定的 @PropertySource 注释元数据
			processPropertySource(propertySource);
		}
	}

	/**
	 * 处理 @ComponentScan 注解
	 * 扫描路径下加了 @Component 注解的类，并存入 BeanDefinitionMap 中
	 */
	Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
			sourceClass.getMetadata(),
			ComponentScans.class,
			ComponentScan.class
	);
	// 不为空 且 需要处理
	if (!componentScans.isEmpty()
			&& !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
		// 是个集合，循环遍历
		for (AnnotationAttributes componentScan : componentScans) {
			/**
			 * 配置类加了 @ComponentScan 注解，则立即执行扫描操作
			 *
			 * 扫描 @ComponentScan 路径下符合过滤器和候选者条件的类
			 * 转换为 BeanDefinitionHolder，并注册到 BeanFactory 中
			 *
			 * 可以理解为扫描 @ComponentScan 路径下加了 @Component 注解的类
			 */
			Set<BeanDefinitionHolder> scannedBeanDefinitions =
					this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());

			for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
				// 获取原始 BeanDefinition
				BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
				if (bdCand == null) {
					bdCand = holder.getBeanDefinition();
				}
				// 检查配置类候选者
				if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
					// 解析配置类
					parse(bdCand.getBeanClassName(), holder.getBeanName());
				}
			}
		}
	}

	/**
	 * 处理 @Import 注解
	 * 可以引入 @Configuration 类，ImportSelector 类，ImportBeanDefinitionRegistrar 类
	 *
	 * 解析 @Import 注解引入的类，ImportSelector 类、ImportBeanDefinitionRegistrar 类和 @Configuration 类作相应的处理
	 * ImportSelector 类需要递归处理
	 * ImportBeanDefinitionRegistrar 类存入 Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> importBeanDefinitionRegistrars 集合中
	 * @Configuration 类存入 Map<ConfigurationClass, ConfigurationClass> configurationClasses 集合中
	 *
	 * ImportSelector 的实现类可以动态实例化一个 BeanDefinition 到 IOC 容器中
	 *
	 * SpringBoot 很多 EnableXXX 都是基于 @Import 注解来实现灵活配置的
	 */
	processImports(
			configClass,
			sourceClass,
			// 获取 @Import 注解的 value 值
			getImports(sourceClass),
			true
	);

	/**
	 * 处理 @ImportResource 注解
	 **/
	AnnotationAttributes importResource =
			AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
	if (importResource != null) {
		String[] resources = importResource.getStringArray("locations");
		Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
		for (String resource : resources) {
			String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
			configClass.addImportedResource(resolvedResource, readerClass);
		}
	}

	/**
	 * 处理每个 @Bean 注解方法
	 *
	 * 获取所有 @Bean 方法的元数据
	 **/
	Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
	for (MethodMetadata methodMetadata : beanMethods) {
		// 封装成 BeanMethod，添加到其配置类中
		configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
	}

	/**
	 * 处理接口上的默认方法
	 **/
	processInterfaces(configClass, sourceClass);

	/**
	 * 如果有父类则处理
	 **/
	if (sourceClass.getMetadata().hasSuperClass()) {
		String superclass = sourceClass.getMetadata().getSuperClassName();
		// 父类排除 java.lang.Object 且不存在于 knownSuperclasses 集合中
		if (superclass != null && !superclass.startsWith("java") &&
				!this.knownSuperclasses.containsKey(superclass)) {
			this.knownSuperclasses.put(superclass, configClass);
			// 找到超类，返回其注释元数据并递归
			return sourceClass.getSuperClass();
		}
	}

	// 没有父类，处理完成
	return null;
}

又是一段复杂的代码，源码虐我千百遍，我待源码如初恋。
这段代码主要做了这么几件事：
1.首先处理成员或嵌套类，比如加了@Import注解引入的类，会作为配置类进行解析。

2.处理@PropertySource注解

3.处理@ComponentScan注解，扫描 @ComponentScan路径下符合过滤器和候选者条件的类，转换为BeanDefinitionHolder，并注册到 BeanFactory中。然后校验配置候选者是否引入了其他配置类，有的话将其作为配置类进行解析。
Spring用了configurationClass这个属性值来标记，加了@Configuration（@Component注解加@Pointcut注解也有，注意这个现象）的候选类有 configurationClass属性值，且值为full；不是接口且加了@Component，@ComponentScan，@Import ，@ImportResource注解或是被@Bean注解标注的方法的候选类也有configurationClass属性值，但值为lite。
扫描注册完后，Spring会对configurationClass为full的配置类进行CGLIB代理增强，即加了@Configuration注解的对象会变成一个CGLIB代理对象，保证其包含的@Bean方法产生的对象只实例化一次，不会因为互相调用而实例化多次。

4.解析@Import注解。这里又做了这么几件事：
判断引入的是判断是 ImportSelector，ImportBeanDefinitionRegistrar还是其他的普通类

• 如果是ImportSelector类型，则将其实例化，如果是DeferredImportSelector延迟导入选择器则保存，否则调用selectImports()方法，获取导入的类全限定名数组，递归解析。
• 如果是ImportBeanDefinitionRegistrar类型，则实例化后放入集合保存，因为可能会有多个ImportBeanDefinitionRegistrar且不需要递归处理，只需要执行一下委托其注册BeanDefinition即可。
• 普通类则作为配置类进行解析。

parser.parse()方法执行完毕，所有的组件都解析出来了，接着进行验证，然后执行ConfigurationClassBeanDefinitionReader的loadBeanDefinitions()对解析出来的组件进行BeanDefinition的注册，代码下面有，注释也很清晰，就不赘述了。

那么第一个重要的方法就解析完毕了，后面接着解析第二个重要的finishBeanFactoryInitialization()方法。

ComponentScanAnnotationParser

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan,
										   final String declaringClass) {

	/**
	 * 此时又实例化了一个 ClassPathBeanDefinitionScanner
	 * 并没有使用 AnnotationConfigApplicationContext 构造方法中实例化的 ClassPathBeanDefinitionScanner
	 *
	 * 为什么不用构造方法实例化的 ClassPathBeanDefinitionScanner 呢？
	 * 可能是因为那个只是为了让外部能够调用 API 所提供的，外部不能够进行配置修改
	 * Spring 内部的可以进行修改
	 *
	 * @ComponentScan 提供了 useDefaultFilters、includeFilters 和 excludeFilters 等配置
	 */
	ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(
			this.registry,
			componentScan.getBoolean("useDefaultFilters"),
			this.environment,
			this.resourceLoader
	);

	// 获取 BeanNameGenerator
	Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
	boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
	scanner.setBeanNameGenerator(useInheritedGenerator ?
			this.beanNameGenerator : BeanUtils.instantiateClass(generatorClass));

	// 处理代理模型
	ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
	if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
		scanner.setScopedProxyMode(scopedProxyMode);
	}
	else {
		Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
		scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
	}

	scanner.setResourcePattern(componentScan.getString("resourcePattern"));

	/**
	 * 遍历 @ComponentScan 中的 includeFilters
	 * 获取符合组件扫描的条件的类型
	 * Filter[] includeFilters() default {};
	 */
	for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
		for (TypeFilter typeFilter : typeFiltersFor(filter)) {
			// 添加包含过滤器
			scanner.addIncludeFilter(typeFilter);
		}
	}
	/**
	 * 遍历 @ComponentScan 中的 excludeFilters
	 * 获取不符合组件扫描的条件的类型
	 * Filter[] excludeFilters() default {};
	 */
	for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
		for (TypeFilter typeFilter : typeFiltersFor(filter)) {
			// 添加排除过滤器
			scanner.addExcludeFilter(typeFilter);
		}
	}

	/**
	 * 获取 @ComponentScan 中的 lazyInit
	 * 默认不是懒加载
	 * 如果是懒加载，则修改 BeanDefinitionDefaults 的懒加载属性值为 True，而不是修改 BeanDefinition 的懒加载属性值为 True
	 * 为后面应用默认值提供便利
	 * boolean lazyInit() default false;
	 */
	boolean lazyInit = componentScan.getBoolean("lazyInit");
	if (lazyInit) {
		scanner.getBeanDefinitionDefaults().setLazyInit(true);
	}

	// 去重存储扫描的包路径
	Set<String> basePackages = new LinkedHashSet<>();
	/**
	 * 获取 @ComponentScan 中的 basePackages()
	 * String[] basePackages() default {};
	 */
	String[] basePackagesArray = componentScan.getStringArray("basePackages");
	for (String pkg : basePackagesArray) {
		// 处理逗号、分号、回车和换行符
		String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
		Collections.addAll(basePackages, tokenized);
	}
	/**
	 * 获取 @ComponentScan 中的 basePackageClasses
	 * Class<?>[] basePackageClasses() default {};
	 */
	for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
		basePackages.add(ClassUtils.getPackageName(clazz));
	}

	// 如果没有注明扫描路径，则默认扫描 @Configuration 类所在包及其子包
	if (basePackages.isEmpty()) {
		basePackages.add(ClassUtils.getPackageName(declaringClass));
	}

	scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
		@Override
		protected boolean matchClassName(String className) {
			return declaringClass.equals(className);
		}
	});
	// 上面都是设置扫描器的属性值，这一步才是真正的扫描
	return scanner.doScan(StringUtils.toStringArray(basePackages));
}

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {

	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();

	// 循环扫描 basePackage 路径下的文件，即 @ComponentScan 注解的 value 或 basePackages 值
	for (String basePackage : basePackages) {
		/**
		 * 扫描类路径查找候选组件
		 *
		 * AnnotatedGenericBeanDefinition 或 ScannedGenericBeanDefinition
		 * AnnotatedGenericBeanDefinition 和 ScannedGenericBeanDefinition 都是 AbstractBeanDefinition 的子类
		 * 这里都转换成了 ScannedGenericBeanDefinition
		 */
		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);

		for (BeanDefinition candidate : candidates) {
			// 解析 Scope 属性
			ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
			candidate.setScope(scopeMetadata.getScopeName());
			/**
			 * 使用之前初始化的 BeanName 生成器为候选者生成一个 BeanName
			 **/
			String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
			/**
			 * 如果这个类是 AbstractBeanDefinition 的子类
			 *
			 * 此时会进入这个判断
			 *
			 * 而被 @ComponentScan 注解扫描后的类都变成了 ScannedGenericBeanDefinition 或 AnnotatedGenericBeanDefinition
			 *
			 * 基本上都是 AbstractBeanDefinition 的子类
			 * 即先将 BeanDefinitionDefaults 的值赋给候选 BeanDefinition
			 */
			if (candidate instanceof AbstractBeanDefinition) {
				/**
				 * 应用如下默认值：
				 *      setLazyInit(lazyInit);
				 *      setAutowireMode(defaults.getAutowireMode());
				 *      setDependencyCheck(defaults.getDependencyCheck());
				 *      setInitMethodName(defaults.getInitMethodName());
				 *      setEnforceInitMethod(false);
				 *      setDestroyMethodName(defaults.getDestroyMethodName());
				 *      setEnforceDestroyMethod(false);
				 */
				postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
			}

			/**
			 * 如果这个类是 AnnotatedBeanDefinition 的子类
			 *
			 * ScannedGenericBeanDefinition 或 AnnotatedGenericBeanDefinition 也是 AnnotatedBeanDefinition 的子类
			 *
			 * 这个判断也会进，即跑完上一步时已经具有了默认值，但是用户可能单独为这个类配置了注解值
			 * 再将扫描到的注解值赋给候选 BeanDefinition
			 */
			if (candidate instanceof AnnotatedBeanDefinition) {
				/**
				 * 处理自定义注解的值
				 * 包含的注解有 @Lazy，@Primary，@DependsOn，@Role，@Description
				 */
				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
			}

			/**
			 * 检查给定候选者的 beanName
			 *
			 * 1、是否存在于 BeanFactory 中，如果不存在则直接返回为 True
			 * 2、校验存在的和现有的 BeanDefinition 是否兼容，兼容则返回 False
			 * 3、抛异常
			 *
			 * 此时刚进行扫描，并没有注册到 BeanFactory 中，所以一般会进
			 */
			if (checkCandidate(beanName, candidate)) {
				// 转换为 BeanDefinitionHolder
				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
				// 应用代理模式
				definitionHolder =
						AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
				beanDefinitions.add(definitionHolder);
				/**
				 * 由 Bean 的主要名称和别名注册 BeanDefinition
				 *
				 * 将 BeanDefinition 加入 Map<String, BeanDefinition>【主名】 和 Map<String, String>【别名】 集合中
				 */
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
	}

	return beanDefinitions;
}

ConfigurationClassBeanDefinitionReader

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
	TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
	for (ConfigurationClass configClass : configurationModel) {
		loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
	}
}

private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass,
														  TrackedConditionEvaluator trackedConditionEvaluator) {
	// 跳过注册
	if (trackedConditionEvaluator.shouldSkip(configClass)) {
		String beanName = configClass.getBeanName();
		if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
			this.registry.removeBeanDefinition(beanName);
		}
		this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
		return;
	}

	// 是被导入的，包括 @Import 和 ImportSelector 导入的
	if (configClass.isImported()) {
		// 为导入的配置类注册 BeanDefinition
		registerBeanDefinitionForImportedConfigurationClass(configClass);
	}

	// 包含 @Bean 方法
	for (BeanMethod beanMethod : configClass.getBeanMethods()) {
		// 为 BeanMethod 注册 BeanDefinition
		loadBeanDefinitionsForBeanMethod(beanMethod);
	}

	/**
	 * 为 @ImportResource 导入资源注册 BeanDefinition
	 **/
	loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
	/**
	 * 委托 ImportBeanDefinitionRegistrar 进行注册
	 **/
	loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

ConfigurationClassUtils

abstract class ConfigurationClassUtils {
	
	public static final String CONFIGURATION_CLASS_FULL = "full";

	public static final String CONFIGURATION_CLASS_LITE = "lite";
	
	public static final String CONFIGURATION_CLASS_ATTRIBUTE =
			Conventions.getQualifiedAttributeName(ConfigurationClassPostProcessor.class, "configurationClass");

	private static final Set<String> candidateIndicators = new HashSet<>(8);

	static {
		candidateIndicators.add(Component.class.getName());
		candidateIndicators.add(ComponentScan.class.getName());
		candidateIndicators.add(Import.class.getName());
		candidateIndicators.add(ImportResource.class.getName());
	}
}

public static boolean checkConfigurationClassCandidate(BeanDefinition beanDef,
														   MetadataReaderFactory metadataReaderFactory) {

	String className = beanDef.getBeanClassName();
	if (className == null || beanDef.getFactoryMethodName() != null) {
		return false;
	}

	// 获取 BeanDefinition 的注解元数据
	AnnotationMetadata metadata;
	/**
	 * 是 AnnotatedBeanDefinition 的子类并且类的全类名一致
	 * 即不能是内部类或者导入的类
	 *
	 * AnnotatedGenericBeanDefinition 和 ScannedGenericBeanDefinition 都是 AnnotatedBeanDefinition 的子类
	 * 这意味着被注解标注的和被扫描到的都可能是一个候选配置类
	 **/
	if (beanDef instanceof AnnotatedBeanDefinition
			&& className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) {
		// 复用来自给定 BeanDefinition 的预先解析的元数据
		metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
	}
	/**
	 * 是 AbstractBeanDefinition 的子类并且指定 Bean 类
	 **/
	else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass()) {
		Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
		if (BeanFactoryPostProcessor.class.isAssignableFrom(beanClass) ||
				BeanPostProcessor.class.isAssignableFrom(beanClass) ||
				AopInfrastructureBean.class.isAssignableFrom(beanClass) ||
				EventListenerFactory.class.isAssignableFrom(beanClass)) {
			return false;
		}
		metadata = AnnotationMetadata.introspect(beanClass);
	}
	/**
	 * 既不是 AnnotatedBeanDefinition 的子类也不是 AbstractBeanDefinition 的子类
	 **/
	else {
		try {
			MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
			metadata = metadataReader.getAnnotationMetadata();
		}
		catch (IOException ex) {
			return false;
		}
	}

	Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());
	/**
	 * 校验 proxyBeanMethods 属性值是否满足
	 **/
	if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
		/**
		 * 设置 configurationClass 属性值为 full【重要】
		 **/
		beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
	}
	/**
	 * 校验配置应该具有的特征
	 *
	 * 不是接口
	 * 加了 @Component @ComponentScan @Import @ImportResource 注解
	 * 有被 @Bean 注解标注的方法
	 **/
	else if (config != null || isConfigurationCandidate(metadata)) {
		/**
		 * 设置 configurationClass 属性值为 lite【重要】
		 **/
		beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
	}
	else {
		return false;
	}

	// 获取 @Order 注解值
	Integer order = getOrder(metadata);
	if (order != null) {
		// 设置 order 属性值为注解值
		beanDef.setAttribute(ORDER_ATTRIBUTE, order);
	}

	return true;
}

DefaultListableBeanFactory

public void preInstantiateSingletons() throws BeansException {
	......
	// 所有已注册的 BeanName 集合
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	for (String beanName : beanNames) {
		// 获取合并的本地 BeanDefinition
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		// 不是抽象的 且 是单例 且 不是懒加载的 Bean
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			// 判断该 Bean 是否是一个 FactoryBean
			if (isFactoryBean(beanName)) {
				/**
				 * 获取该 FactoryBean 实例
				 *
				 * 如果是 FactoryBean 则需要加上 '&' 符号才能实例化该 Bean
				 * 否则实例化的是该 FactoryBean 产生的对象
				 */
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				// 再次确认是 FactoryBean 的子类
				if (bean instanceof FactoryBean) {
					// 转换为 FactoryBean
					final FactoryBean<?> factory = (FactoryBean<?>) bean;
					// 标记是否迫切需要初始化
					boolean isEagerInit;
					/**
					 * SecurityManager 不为空 且 是 SmartFactoryBean 的子类
					 *
					 * SmartFactoryBean 的子类有 EagerInitFactory 和 NonPrivilegedFactoryBean
					 */
					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) {
						getBean(beanName);
					}
				}
			}
			// 不是 FactoryBean 则直接实例化
			else {
				getBean(beanName);
			}
		}
	}
	......
}

开始解析第二个重要且复杂的方法，不跟进去其实还不算复杂。
这是初始化单例对象前的预处理，主要是遍历所有已注册的BeanDefinitionName集合，先获取合并的本地BeanDefinition，判断不是抽象的且是单例且不是懒加载的：

• 是一个FactoryBean，则在BeanName前加上&号获取该FactoryBean实例
  • 再次确认该FactoryBean实例是FactoryBean类型，因为我们可以给Bean起名字，完全可以加上&符号
    • 逻辑判断是否迫切需要被初始化，是则初始化，不是则什么也不做
• 不是则直接初始化

终于来到了极其重要但是极其复杂的getBean()方法了。

AbstractBeanFactory

protected <T> T doGetBean(final String name,
						  @Nullable final Class<T> requiredType,
						  @Nullable final Object[] args,
						  boolean typeCheckOnly) throws BeansException {

		/**
		 * 获取规范的 BeanName
		 *
		 * 这里不使用 name 直接作为 BeanName 有两个原因：
		 *  1.name 可能会以 & 字符开头，表明调用者想获取 FactoryBean 对象本身的实例，
		 *    而非 FactoryBean 实现类所创建的 Bean 对象实例。
		 *    在 BeanFactory 中，FactoryBean 的实现类和其他的 Bean 存储方式是一致的，
		 *    即<BeanName, BeanInstance>，BeanName中是没有 & 这个字符的，
		 *    所以需要将 name 的首字符 & 移除，这样才能从缓存里取到 FactoryBean 创建的实例
		 *  2.该 Bean 对象可能存在别名
		 */
		final String beanName = transformedBeanName(name);
		Object bean;
		/**
		 * 解决循环依赖问题【通过两次重载的 getSingleton() 方法和一次后置处理器方法的调用来解决循环依赖】
		 */

		/**
		 * 第一次调用 getSingleton() 方法，检查单个缓存以手动注册单例
		 *
		 * 获取在给定名称下注册的（原始）单例对象
		 **/
		Object sharedInstance = getSingleton(beanName);
		// 已经创建过该实例对象
		if (sharedInstance != null && args == null) {
			// 获取给定 Bean 实例的对象，如果是 FactoryBean，则为 Bean 实例本身或其创建的对象
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
		// 没有创建过该实例对象
		else {
			/**
			 * 如果已经创建了这个 Bean 实例，则会失败：我们可以在循环引用中完成
			 *
			 * 原型对象循环依赖则抛异常
			 * 原型为什么不能循环依赖？
			 * Spring 解决循环依赖借助了三级缓存，原型对象不会存入缓存，所以 Spring 无法解析
			 **/
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 获取父工厂，如果有就去父工厂中找
			BeanFactory parentBeanFactory = getParentBeanFactory();
			// 父工厂存在 且 当前容器【DefaultListableBeanFactory】没有注册该 beanName
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				
				String nameToLookup = originalBeanName(name);

				if (parentBeanFactory instanceof AbstractBeanFactory) {
					// 走AbstractBeanFactory父工厂的创建流程
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly
					);
				}
				else if (args != null) {
					// 使用显式 args 委托父级
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else if (requiredType != null) {
					// 没有参数，委托标准的 getBean() 方法
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
				else {
					// 其他情况
					return (T) parentBeanFactory.getBean(nameToLookup);
				}
			}

			if (!typeCheckOnly) {
				// 将 Bean 标记为已创建
				markBeanAsCreated(beanName);
			}

			try {
				/**
				 * 合并 BeanDefinition
				 *
				 * XML 中可以配置一个抽象的模板 Bean，可以供子类进行属性复用
				 **/
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 校验是否是抽象的
				checkMergedBeanDefinition(mbd, beanName, args);

				/**
				 * 初始化当前 Bean 依赖的 Bean【被 @DependsOn 注解指明需要依赖的 Bean】
				 **/
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						// 校验是否是相互依赖项【这里不是循环依赖】
						if (isDependent(beanName, dep)) {
							// 抛出相互依赖异常
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						// 为给定 Bean 注册依赖 Bean
						registerDependentBean(dep, beanName);
						try {
							// 获取给定的 Bean 实例
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							// 抛出依赖项缺失异常
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// 单例则进行创建
				if (mbd.isSingleton()) {
					// 第二次调用 getSingleton() 方法，解决循环依赖问题
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				// 原型则创建新的实例
				else if (mbd.isPrototype()) {
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
				// 其他
				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, () -> {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						});
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope '" + scopeName + "' is not active for the current thread; consider " +
										"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		......
		
		return (T) bean;
	}

梳理一下主要逻辑：
获取规范的BeanName后，先调用getSingleton()方法尝试从缓存中获取实例对象

• 获取到了，如果调用者想要的是FactoryBean生产的对象，则去创建，否则返回
• 没有获取到，如果有父工厂并且当前容器没有注册要获取的对象为BeanDefinition，则走父工厂的创建流程
• 否则合并BeanDefinition，先检查相互依赖项是否有缺失
• 根据其是单例、原型还是其他类型开始创建该实例

这里有一个解循环依赖的过程，有空单独写一篇博客来说明，这里就不细说了。
主要说一下单例的情况，两个getSingleton()方法代码和注释在下面，很容易理解，直接看AbstractAutowireCapableBeanFactory的createBean()方法。

DefaultSingletonBeanRegistry

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	// 先从 Map<String, Object> singletonObjects 单例缓存池【一级缓存】中获取
	Object singletonObject = this.singletonObjects.get(beanName);
	/**
	 * 单例缓存池中不存在 且 当前正在被创建
	 *
	 * 当存在循环依赖时
	 * 解析 A 类时，将 A 类标记为当前正在创建
	 * 填充 A 类的属性值时去获取并创建 B 类，此时将 B 类标记为当前正在创建
	 * 填充 B 类的属性值时去获取并创建 A 类，此时 A 类获取不到，但是被标记为正在创建
	 * 此时这个判断成立
	 **/
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {

		synchronized (this.singletonObjects) {
			// 再从早期单例池中获取
			singletonObject = this.earlySingletonObjects.get(beanName);

			/**
			 * 如果支持循环依赖，Spring 对 beanName 的操作如下：
			 *
			 * synchronized (this.singletonObjects) {
			 *     // 如果不在单例池中
			 *     if (!this.singletonObjects.containsKey(beanName)) {
			 * 	       this.singletonFactories.put(beanName, singletonFactory);
			 * 		   this.earlySingletonObjects.remove(beanName);
			 * 		   this.registeredSingletons.add(beanName);
			 *     }
			 * }
			 *
			 * beanName 不存在也没有存到 singletonObjects 当中
			 * 所以第一步获取不到，加锁之后再获取也获取不到
			 **/
			if (singletonObject == null && allowEarlyReference) {

				ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
				if (singletonFactory != null) {
					// 执行工厂方法，获取这个对象
					singletonObject = singletonFactory.getObject();
					// 存入三级缓存，以后就直接从三级缓存中获取，不用再执行对象工厂方法
					this.earlySingletonObjects.put(beanName, singletonObject);
					// 已经执行过工厂方法，获取到对象了，从二级缓存中移除
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}

	return singletonObject;
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	
	synchronized (this.singletonObjects) {
		// 从 Map<String, Object> singletonObjects 单例池中获取
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null) {
			// 当前正在销毁中，不允许创建，抛异常
			if (this.singletonsCurrentlyInDestruction) {
				throw new BeanCreationNotAllowedException();
			}
			
			// 如果不在创建检查排除 BeanName 集合中，则添加到当前正在创建的单例 BeanName 集合中
			beforeSingletonCreation(beanName);
			// 新单例对象
			boolean newSingleton = false;
			// 初始化异常列表
			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
			if (recordSuppressedExceptions) {
				this.suppressedExceptions = new LinkedHashSet<>();
			}
			try {
				singletonObject = singletonFactory.getObject();
				newSingleton = true;
			}
			catch (IllegalStateException ex) {
				singletonObject = this.singletonObjects.get(beanName);
				if (singletonObject == null) {
					throw ex;
				}
			}
			catch (BeanCreationException ex) {
				if (recordSuppressedExceptions) {
					for (Exception suppressedException : this.suppressedExceptions) {
						ex.addRelatedCause(suppressedException);
					}
				}
				throw ex;
			}
			finally {
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = null;
				}
				// 如果不在创建检查排除 BeanName 集合中，则从当前正在创建的单例 BeanName 集合中移除
				afterSingletonCreation(beanName);
			}
			if (newSingleton) {
				// 创建完后存入一级缓存，并从二三级缓存中移除
				addSingleton(beanName, singletonObject);
			}
		}

		return singletonObject;
	}
}

AbstractAutowireCapableBeanFactory

protected Object createBean(String beanName,
							RootBeanDefinition mbd,
							@Nullable Object[] args) throws BeanCreationException {
	
	RootBeanDefinition mbdToUse = mbd;

	......

	try {
		/**
		 * 给 BeanPostProcessors 一个返回代理而不是目标 Bean 实例的机会【重要】
		 * 但此时还没有创建代理对象，此时没有对象，只有 BeanDefinition
		 *
		 * 第一次调用后置处理器【跟 AOP 有关】
		 * @see org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization(java.lang.Object, java.lang.String)
		 *
		 * InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
		 * Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
		 *
		 * 此时对象还没有实例化，只有 BeanDefinition
		 * 无法进行代理，只是将切面找出来进行缓存
		 */
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	}
	catch (Throwable ex) {
		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
				"BeanPostProcessor before instantiation of bean failed", ex);
	}

	try {
		/**
		 * 真正实例化 Bean
		 **/
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		
		return beanInstance;
	}
	catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
		throw ex;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
	}
}

protected Object doCreateBean(final String beanName,
							  final RootBeanDefinition mbd,
							  final @Nullable Object[] args) throws BeanCreationException {
	
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		/**
		 * 第二次调用后置处理器【推断构造方法来实例化 Bean】
		 *
		 * SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
		 * Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
		 */
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}

	......

	// 允许后置处理器修改合并的 BeanDefinition
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				/**
				 * 第三次调用后置处理器
				 */
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex);
			}
			mbd.postProcessed = true;
		}
	}

	/**
	 * 急于缓存单例，以便即使在诸如 BeanFactoryAware 之类的生命周期接口触发时也能够解析循环引用
	 *
	 * 是单例 且 允许循环依赖 且 当前正在创建
	 **/
	boolean earlySingletonExposure = (mbd.isSingleton()
			// 默认为 True，除非修改了这个属性
			&& this.allowCircularReferences
			&& isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		/**
		 * 第四次调用后置处理器【Spring 借助了这一次后置处理器的调用外加两次重载的 getSingleton() 方法来解决循环依赖】
		 *
		 * 存入二级缓存，并添加到已经注册的单例集合中
		 */
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// 初始化 Bean 实例
	Object exposedObject = bean;
	try {
		/**
		 * 通过调用两个后置处理器的方法，完成 Bean 属性的填充【或者说自动注入】【非常重要】
		 *
		 * 第五次调用后置处理器【返回 True 才会进行属性填充，可以干预某个 Bean 的装配填充】
		 *
		 * 第六次调用后置处理器【完成属性填充】
		 */
		populateBean(beanName, mbd, instanceWrapper);
		/**
		 *  通过调用两次后置处理器，完成 Bean 的初始化
		 *
		 * 第七次调用后置处理器【BeanPostProcessor 的直接实现类调用】
		 *
		 * Object current = processor.postProcessBeforeInitialization(result, beanName);
		 *
		 * 第八次调用后置处理器【BeanPostProcessor 的直接实现类调用】
		 *
		 * Object current = processor.postProcessAfterInitialization(result, beanName);
		 */
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	catch (Throwable ex) {
		if (ex instanceof BeanCreationException
				&& beanName.equals(((BeanCreationException) ex).getBeanName())) {
			throw (BeanCreationException) ex;
		}
		else {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
		}
	}

	......
	
	try {
		/**
		 * 第九次调用后置处理器【销毁】
		 */
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException();
	}

	return exposedObject;
}

这里只看populateBean()方法和initializeBean()方法，一些还未完全确定的代码，等后续更新。

protected void populateBean(String beanName,
							RootBeanDefinition mbd,
							@Nullable BeanWrapper bw) {
	......

	/**
	 * 在设置属性之前，让任何 InstantiationAwareBeanPostProcessors 都有机会修改 Bean 的状态
	 * 这可以用来，例如，支持样式属性注入。
	 **/
	boolean continueWithPropertyPopulation = true;

	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				/**
				 * 第五次调用后置处理器
				 *
				 * 校验是否需要属性填充
				 **/
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					continueWithPropertyPopulation = false;
					break;
				}
			}
		}
	}

	if (!continueWithPropertyPopulation) {
		return;
	}

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

	int resolvedAutowireMode = mbd.getResolvedAutowireMode();
	/**
	 * 如果是四种自动装配模型中的 byName 或者是 byType
	 *
	 * @Autowired 和 @Resource 是装配技术，这里不会执行
	 **/
	if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
		/**
		 * 如果适用，根据名称添加基于自动装配的属性值
		 **/
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
		/**
		 * 如果适用，根据类型添加基于自动装配的属性值
		 **/
		if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}

		pvs = newPvs;
	}

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

	PropertyDescriptor[] filteredPds = null;
	if (hasInstAwareBpps) {
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		/**
		 * 获取所有的 BeanPostProcessor
		 *
		 * 1、ApplicationContextAwareProcessor
		 *
		 * 2、ImportAwareBeanPostProcessor
		 *
		 * 3、BeanPostProcessorChecker
		 *
		 * 4、CommonAnnotationBeanPostProcessor
		 * 处理被 @Resource 注解标注的属性
		 *
		 * 5、AutowiredAnnotationBeanPostProcessor
		 * 处理被 @Autowired 注解标注的属性
		 *
		 * 6、ApplicationListenerDetector
		 **/
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				/**
				 * 第六次调用后置处理器
				 *
				 * 完成属性填充
				 **/
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
				if (pvsToUse == null) {
					if (filteredPds == null) {
						filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
					}
					pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						return;
					}
				}
				pvs = pvsToUse;
			}
		}
	}
	if (needsDepCheck) {
		if (filteredPds == null) {
			filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		}
		checkDependencies(beanName, mbd, filteredPds, pvs);
	}

	if (pvs != null) {
		/**
		 * 应用给定的属性值
		 *
		 * 对应 XML 配置文件中这个标签：
		 * <property name="XXX" value="XXX" ref="XXX"/>
		 **/
		applyPropertyValues(beanName, mbd, bw, pvs);
	}
}

protected Object initializeBean(final String beanName,
								final Object bean,
								@Nullable RootBeanDefinition mbd) {
	// 回调 Aware 及其实现类的方法
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged(
				(PrivilegedAction<Object>) () -> {
					invokeAwareMethods(beanName, bean);
					return null;
				},
				getAccessControlContext());
	}
	else {
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		/**
		 * 关键字：执行
		 * 执行 BeanPostProcessor 直接实现类的 postProcessBeforeInitialization() 方法
		 *
		 * @PostConstruct 注解是在这里面进行处理的
		 */
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		/**
		 * 执行 Bean 生命周期回调中的 init 方法
		 *
		 * 实现 InitializingBean 接口并重写 afterPropertiesSet() 方法是在这里面进行处理的
		 */
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				(mbd != null ? mbd.getResourceDescription() : null),
				beanName, "Invocation of init method failed", ex);
	}
	if (mbd == null || !mbd.isSynthetic()) {
		/**
		 * 关键字：改变
		 * 执行 BeanPostProcessor 直接实现类的 postProcessAfterInitialization() 方法
		 *
		 * 产生 AOP 代理，事务的代理等
		 */
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

这里不得不说一下Bean生命周期涉及到的后置处理器，分别是InstantiationAwareBeanPostProcessor，SmartInstantiationAwareBeanPostProcessor，MergedBeanDefinitionPostProcessor，DestructionAwareBeanPostProcessor，和BeanPostProcessor的实现类。要想弄明白Bean的生命周期，那么这几个后置处理器，和九个方法调用时逃不过的坎。
写到这里，发现离开应用谈源码，太宽泛，没有针对性，很多想说的，展开的话就太多了，不说又感觉漏了，衔接不上，以后针对一些例子再具体解析一下，理清思路的同时，也验证自己的理解。

贴一张看书的时候看到的学习金字塔图，自己平时会花很多时间学习，但是都是被动的，忘的很快，通过写博客，进行文档输出，真的能加深理解。
IOC源码解析就到这里了，如果有表述不准确或者错误的地方，还请大佬不吝指正，下一篇再见。

转载：https://blog.csdn.net/CX610602108/article/details/105870957