前言
上一节中简要说明了下springboot自动化配置的关键，那么本节看下springboot真正的初始化过程，如何创建上下文并解析配置，加载我们注册到容器管理中的类。上节已经成功的创建了SpringApplication，那我们就看下其run方法究竟做了些什么
正文
我们从SpringApplication的run方法开始入手，只看核心代码，其他省略
public ConfigurableApplicationContext run(String... args) {
...//省略代码
//声明spring上下文
ConfigurableApplicationContext context = null;
try {
..//省略代码
//2.新建应用上下文
context = createApplicationContext();
..//省略代码
//3.刷新上下文
refreshContext(context);
//4.完成刷新上下文后调用(目前空白)
afterRefresh(context, applicationArguments);
..//省略代码
}
return context;
}通过上面我们可以发现，run方法核心步骤就是创建ApplicatonContext，这儿主要的步骤有两个 1.创建应用上下文 2.刷新上下文。我们从创建开始看
1.创建spring的核心 ApplicationContext
查看createApplicationContext方法
public static final String DEFAULT_WEB_CONTEXT_CLASS = "org.springframework.boot."
+ "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";
protected ConfigurableApplicationContext createApplicationContext() {
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch (this.webApplicationType) {
case SERVLET:
//我们使用这个
contextClass = Class.forName(DEFAULT_WEB_CONTEXT_CLASS);
break;
case REACTIVE:
contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
break;
default:
contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
}
}
..//省略
}
//反射生成实例
return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}这儿其实看着是很简单的逻辑，就是根据类型，选择与一个合适的创建，这儿我们就用常见的servlet来说明。servlet对应的上下文为AnnotationConfigServletWebServerApplicationContext。然后最后会根据反射来生成一个实例并返回。我们可以看下这个上下文的类图
相信这个类继承结构大家都看着比较头痛，毕竟作为核心类。这儿就挑两个个重要的说下。
第一。 其最终实现了BeanFactory接口，并继承了GenericApplicationContext。并且我们查看其构造函数会传入一个BeanFactory
public AnnotationConfigServletWebServerApplicationContext(DefaultListableBeanFactory beanFactory) {
super(beanFactory);
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}最终在GenericApplicationContext中有如下代码
private final DefaultListableBeanFactory beanFactory;
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
public GenericApplicationContext(DefaultListableBeanFactory beanFactory) {
Assert.notNull(beanFactory, "BeanFactory must not be null");
this.beanFactory = beanFactory;
}会发现上下文不论如何都会持有一个beanFactory，很多人被问到过ApplicationContext和beanFactory的区别与联系。其实这儿就能看出来是一个很典型的静态代理的案例。既然是代理，就说明了肯定ApplicationContext在保持Beanfactory的原有功能时又扩展了很多功能。这样就可以做到既兼容旧版本，又增强很多功能。当然了，具体的区别有兴趣的可以去看下二者的源代码。
第二。我们在AnnotationConfigServletWebServerApplicationContext的构造函数中发现了有如下步骤
this.reader = new AnnotatedBeanDefinitionReader(this);这儿新建了一个注解bean的解析器。我们一路跟着源码看下
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);
}这儿我们会发现该方法最后会为registry注册一些解析器，我们看下AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);该方法会为Beanfactory设置一系列的BeanDefinition，以及其他的一些东西，
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(4);
// 处理@Configuration @ComponentScans @Component @Bean等注解 @PropertySources @ImportResource 等
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 处理 @Autowired @Value 等
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));
}
// 处理@Required @
if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 处理类似@PostConstruct 和@PreDestroy
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的话这里有处理的 例如@Selevt
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));
}
// 处理类似@EventListener的注解
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}
return beanDefs;
}ConfigurationClassPostProcessor，AutowiredAnnotationBeanPostProcessor这两可以说是相当核心的两个后置处理器，在后面spring进行配置解析的时候会相当的有用。
到此，创建ApplicationContext就完成了，我们看系统刷新上下文的时候做了些什么
2. refreshContext spring的核心加载方法
该方法可以说占据了springboot启动的绝大部分时间，也是springboot启动中最为核心的方法。
private void refreshContext(ConfigurableApplicationContext context) {
refresh(context);
if (this.registerShutdownHook) {
try {
context.registerShutdownHook();
}
catch (AccessControlException ex) {
// Not allowed in some environments.
}
}
}
protected void refresh(ApplicationContext applicationContext) {
Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
((AbstractApplicationContext) applicationContext).refresh();
}跟着代码一路走，发现其最终调用的是上下文的refresh方法。由于其被强转为AbstractApplicationContext，所以我们直接看其refresh方法，到此就进入ApplicationContext类中了。
3.ApplicationContext中refresh方法
该方法里面有很多初始化方法，我们也选择核心的说明
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//初始化之前的一些准备，例如设置开始标记等
prepareRefresh();
// 获取到上面提到的beanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 初始注册一些要用到的类
prepareBeanFactory(beanFactory);
try {
// 添加一些BeanFactory的postProcess
postProcessBeanFactory(beanFactory);
// 执行BeanFactory的PostProcessors
invokeBeanFactoryPostProcessors(beanFactory);
// 注册一些BeanPostProcessors
registerBeanPostProcessors(beanFactory);
../略过
// 一些特殊的操作，例如
//本案例中是AnnotationConfigServletWebServerApplicationContext 那么这儿会开始创建servlet容器
onRefresh();
../略过
// 实例化容器中未设置懒加载的类
finishBeanFactoryInitialization(beanFactory);
../略过
}
}
}这儿我们我们主要看两个方法 一是invokeBeanFactoryPostProcessors，该方法会找出所有需要加载的bean。然后是finishBeanFactoryInitialization方法，该方法会将需要加载的bean进行实例化并装载属性。
4.invokeBeanFactoryPostProcessors方法
该方法我们跟着源代码走，最终会走到PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors方法，由于该方法过长。所以我们分段说明
4.1 无所不在的PostProcesser
不得不说spring将切面应用到了极致啊。。基本每初始化某个东西都会有其对应的PostProcessor，虽然看着略显繁琐，但是却极大的增加了我们的扩展点
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
//将我们的BeanFactory强转为BeanDefinitionRegistry
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();
//循环我们传入的BeanFactoryPostProcessor 如果其是BeanDefinitionRegistryPostProcessor
//那么这儿执行其postProcessBeanDefinitionRegistry方法
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}上述代码也是执行了传入的Proccessor类型为BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法。
4.2 第一级BeanDefinitionRegistryPostProcessor执行(即实现了PriorityOrdered接口)
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 找到系统所有实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor接口实现类
// 这儿会找到我们刚刚的 ConfigurationClassPostProcessorString[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
//排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//将刚找到的BeanDefinitionRegistryPostProcessor加入registryProcessors
registryProcessors.addAll(currentRegistryProcessors);
//执行刚找到的BeanDefinitionRegistryPostProcessor
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//清空
currentRegistryProcessors.clear();这儿即找实现了BeanDefinitionRegistryPostProcessor，PriorityOrdered的类。而我们在第一节中最后提到的ConfigurationClassPostProcessor刚好是满足的，我们可以在回顾一下
这儿我们进入invokeBeanDefinitionRegistryPostProcessors方法看下
private static void invokeBeanDefinitionRegistryPostProcessors(
Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
postProcessor.postProcessBeanDefinitionRegistry(registry);
}
}重中之重，所以篇幅较长
4.2.1 校验并为本次解析设置id，防止重复加载
第一步则是设置了本次解析的id，防止重复解析
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
//得到registry的hash码作为id
int registryId = System.identityHashCode(registry);
//校验id
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);
//正式解析
processConfigBeanDefinitions(registry);
}
4.2.2 正式解析
这儿我们依旧一段一段的看
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
//找到该registry所有的candidateNames 也就是我们第一步结尾添加的那些
String[] candidateNames = registry.getBeanDefinitionNames();
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
//isFullConfigurationClass 判断是否是带有@Configuration
//isLiteConfigurationClass 判断是否带有@Component，@ComponentScan，@Import，@ImportResource，@Bean 5个注解中的任一个
// 具体可以查看
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
// 这儿由于我们的主启动类中@SpringbootApplication带@Configuration注解 所以主类满足
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
if (configCandidates.isEmpty()) {
return;
}
// 排序configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});这儿会将BeanFactory中已经存在的BeanDefinitionName全部查出来并获取其BeanDefinition，由于我们的启动类@SpringbootApplication中已经带有@Configuration 所以这里是满足的(第一节中讲组合注解的时候讲过)
然后接下来会有查看是否有BeanNameGenerator和environment
SingletonBeanRegistry sbr = null;
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 也就是解析器
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
//拿到我们解析的配置类 这儿的话是主启动类
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
//已经解析的ConfigurationClass集合
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
//开始解析
parser.parse(candidates);
//验证
parser.validate();
//找到本次解析后发现的所有ConfigurationClass
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
//移除掉已经解析的
configClasses.removeAll(alreadyParsed);
// 如果没有 则创建一个新的ConfigurationClassBeanDefinitionReader
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
//将这些发现的找到本次解析后发现的所有ConfigurationClass再次解析掉
this.reader.loadBeanDefinitions(configClasses);
//将其添加到已解析的集合中
alreadyParsed.addAll(configClasses);
//清空candidates
candidates.clear();
//如果registry中的BeanDefinition数量大于candidateNames 也就是一开始进入方法时的数量
//即找到的新的需要加入容器的bean了
if (registry.getBeanDefinitionCount() > candidateNames.length) {
//拿到所有的已经存在的BeanDefinitionName
String[] newCandidateNames = registry.getBeanDefinitionNames();
//初始进来的BeanDefinitionName
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
//创建已经解析的Class的名字的集合
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
//将已经解析的添加到集合中
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
//循环遍历 所有的BeanDefinition 看看有没有configuration被遗漏的
for (String candidateName : newCandidateNames) {
//即不是初始化进来时的BeanDefinition
if (!oldCandidateNames.contains(candidateName)) {
//拿到这个BeanDefinition
BeanDefinition bd = registry.getBeanDefinition(candidateName);
//如果该BeanDefinition也是一个配置类并且没有存在于alreadyParsed 即被遗漏了
//那么将其添加到candidates方法 然后再进行
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
//则再将其添加进去 循环进行解析
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());这段代码较长，逻辑还是较为清晰，其实通过这段代码我们就大概明白了springboot进行配置加载的流程了。即根据主启动类进行配置解析，并且将所有遇到的ConfigurationClass全部返回，然后再进行二次解析，最后对所有的BeanDefinition进行校验，如果发现其为ConfigurationClass但是却没有在已解析的集合中，那么久循环一下，再次进行解析。
下一篇， 解析完第一级BeanDefinitionRegistryPostProcessor后我们开始解析第二级
4.3 第二级BeanDefinitionRegistryPostProcessor(即实现了Ordered接口)
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//过滤了第一级中存在的
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();可以发现其流程和第一级几乎一致，只是增加了一个过滤掉了第一级，所以这儿不讲，如果有自定义的BeanDefinitionRegistryPostProcessor可以测试一下。
4.4 第三级BeanDefinitionRegistryPostProcessor
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}处理流程也和前两级几乎一致，这儿也不讲了
4.4 BeanFactoryPostProcessor的执行
即找到系统存在的BeanFactoryPostProcessor，同样按照三级的形式根据优先级来执行。具体的逻辑也和上面详细讲的那个一级是一致的。
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
//找到所有的BeanFactoryPostProcessor 并根据其级别进行归类
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 执行优先级最高的 即实现了PriorityOrdered接口的
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 执行第二级的的 即实现了Ordered接口的
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 执行第三级的的 即啥都没实现的
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
//清除缓存
beanFactory.clearMetadataCache();
到此，refresh方法中的两个重要方法第一个 invokeBeanFactoryPostProcessors，已经完成，而其中的ConfigurationClassPostProcessor(也就是BeanDefinitionRegistryPostProcessor的一种)负责了最为核心的容器类加载，也就是主要分析的类也分析完成。(详细的类解析过程篇幅问题放在下章)
总结
本文主要分为了两个部分，创建Spring应用上下文，和执行了其refresh方法中的invokeBeanFactoryPostProcessors方法。
创建应用上下文的同时也会创建一个DefaultListableBeanFactory，这个也是静态代理的体现。而在执行ApplicationContext的构造函数时，会创建一个AnnotatedBeanDefinitionReader，而这个类中会有一个BeanDefinitionRegistry属性，并将我们一些必须的BeanDefinition添加进去，例如最为核心的 ConfigurationClassPostProcessor也就是在这个时候被添加进去的。
执行invokeBeanFactoryPostProcessors方法则主要分为三个步骤
- 执行所有传入的BeanFactoryPostProcessor(如果为BeanFactoryPostProcessor)的postProcessBeanDefinitionRegistry方法
- 找到BeanFactory中所有的BeanDefinitionRegistryPostProcessor类型的类并按照三级标准执行(实现了PriorityOrdered接口，实现了Ordered接口，啥都没实现 )；
- 找到BeanFactory中所有的BeanFactoryPostProcessor类型的类并按照三级标准执行(实现了PriorityOrdered接口，实现了Ordered接口，啥都没实现 )；
而其第二步则执行了核心的ConfigurationClassPostProcessor，并且是以最优先级执行，该processer会加载系统中所有需要加入容器的类，并且会解析所有的Configuration class
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
