Spring源码分析のregisterrefresh全过程（上）

文章目录 前言一、AnnotationConfigApplicationContext二、register三、refresh3.1、prepareRefresh3.2、obtainFreshBeanFactory3.3、prepareBeanFactory3.4、postProcessBeanFactory3.5、invokeBeanFactoryPostProcessors

---

前言

  本篇通过AnnotationConfigApplicationContext，介绍Spring在启动的全流程。AnnotationConfigApplicationContext是ApplicationContext的一个具体实现，支持配置类+注解模式。在构造AnnotationConfigApplicationContext时，主要涉及到:

调用父类的构造方法。register方法。refresh方法。

  本篇主要介绍register方法和refresh的部分源码。

一、AnnotationConfigApplicationContext

  在构造AnnotationConfigApplicationContext时，首先会 ，访问AnnotationConfigApplicationContext的另一个构造，在该构造里，主要做了：

创建 AnnotatedBeanDefinitionReader 读取器创建 ClassPathBeanDefinitionScanner 扫描器

  其中AnnotatedBeanDefinitionReader 读取器，主要用于从注解的类中解析 Bean 定义并注册到容器，ClassPathBeanDefinitionScanner 主要用于扫描指定包下的类，并自动注册为 Bean。

  并且在执行自身的逻辑之前，还会先去调用AnnotationConfigApplicationContext父类GenericApplicationContext的构造方法，设置一个默认的bean工厂：   再去调用GenericApplicationContext父类AbstractApplicationContext的构造方法，设置一个路径解析器，用于解析XML 配置文件、属性文件、类路径下的资源等。   也就是说，在调用了this方法之后，完成了bean工厂的初始化，并且具有了解析XML 配置文件、属性文件、类路径下的资源、从注解的类中解析 Bean 定义并注册到容器，以及扫描指定包下的类，并自动注册为 Bean的能力。

二、register

  register方法，主要的作用是：

调用在this中初始化的注解解析器，对传入的类信息进行解析。

  最终会调用到doRegisterBean，从register方法进入的doRegisterBean，除了第一个参数有值以外，其他参数都默认为null，这个方法主要是解析传入的beanClass对象，生成bean定义，并且将 bean定义注册到 BeanFactory。

private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier, @Nullable BeanDefinitionCustomizer[] customizers) { // 1. 创建一个AnnotatedGenericBeanDefinition，用于封装beanClass的元信息 AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass); // 2. 通过ConditionEvaluator判断是否需要跳过当前 Bean 的注册（比如@Conditional条件匹配失败） if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) { return; // 如果不符合条件，则直接返回，不注册该 Bean } // 3. 设置 Bean 的实例提供者（可以用于懒加载） abd.setInstanceSupplier(supplier); // 4. 解析该 Bean 的作用域 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd); abd.setScope(scopeMetadata.getScopeName()); // 5. 生成 Bean 的名称： //如果传入了name，使用传入的 name //没有传入，按照默认的规则生成bean的名称 例如:OrderService => orderService AService => AService A => A String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry)); // 6. 处理通用的 Spring 注解（如@Lazy、@Primary、@DependsOn、@Role） AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); // 7. 处理 qualifiers if (qualifiers != null) { for (Class<? extends Annotation> qualifier : qualifiers) { if (Primary.class == qualifier) { // 7.1 如果@Primary存在，则标记该 Bean 为主要 Bean abd.setPrimary(true); } else if (Lazy.class == qualifier) { // 7.2 如果@Lazy存在，则设置该 Bean 为懒加载 abd.setLazyInit(true); } else { // 7.3 其他的限定符，则作为AutowireCandidateQualifier添加（用于@Qualifier匹配） abd.addQualifier(new AutowireCandidateQualifier(qualifier)); } } } // 8. 如果传入了customizers，则对abd进行自定义配置 if (customizers != null) { for (BeanDefinitionCustomizer customizer : customizers) { customizer.customize(abd); } } // 9. 创建 BeanDefinitionHolder，封装刚刚初始化的bean定义和beanName //BeanDefinitionHolder 只是对 BeanDefinition 进行封装，附加上 Bean 名称。 BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName); // 10. 处理作用域代理模式（如果@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)，则应用代理） definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); // 11. 将definitionHolder注册到BeanFactory BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); } 三、refresh

  refresh方法描述了Spring的整个生命周期，此前bean的生命周期，就是refresh方法的一部分，refresh整体来看，有十二个部分：

@Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh"); // 前期准备工作，主要用于初始化环境 prepareRefresh(); // 获取 BeanFactory 并进行初始化 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 设置一些类加载器，解析器等 prepareBeanFactory(beanFactory); try { //子类扩展点，例如 AbstractRefreshableWebApplicationContext 会自定义 Web 相关 Bean postProcessBeanFactory(beanFactory); StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process"); // 调用所有的bean工厂后处理器 invokeBeanFactoryPostProcessors(beanFactory); //注册所有的bean后处理器 registerBeanPostProcessors(beanFactory); beanPostProcess.end(); //用于国际化 initMessageSource(); //用于事件发布 initApplicationEventMulticaster(); //子类扩展点，Web 容器可能会在这里初始化Web相关Bean onRefresh(); //注册监听器 registerListeners(); //实例化所有非懒加载的单例bean，并且在这一步触发 BeanPostProcessor finishBeanFactoryInitialization(beanFactory); //发布 ContextRefreshedEvent，通知所有监听器，启动 Lifecycle Bean（如 SmartLifecycle） finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex); } // Destroy already created singletons to avoid dangling resources. destroyBeans(); // Reset 'active' flag. cancelRefresh(ex); // Propagate exception to caller. throw ex; } finally { // Reset common introspection caches in Spring's core, since we // might not ever need metadata for singleton beans anymore... resetCommonCaches(); contextRefresh.end(); } } } 3.1、prepareRefresh

  prepareRefresh主要是做一些refresh的准备工作：

protected void prepareRefresh() { //...非关键代码 //允许子类自定义环境变量 initPropertySources(); //首先会初始化StandardEnvironment标准环境，然后进行校验 getEnvironment().validateRequiredProperties(); //第一次刷新时，存储当前的监听器列表 if (this.earlyApplicationListeners == null) { this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners); } else { // Reset local application listeners to pre-refresh state. this.applicationListeners.clear(); this.applicationListeners.addAll(this.earlyApplicationListeners); } // Allow for the collection of early ApplicationEvents, // to be published once the multicaster is available... this.earlyApplicationEvents = new LinkedHashSet<>(); }

如果当前环境中没有特定的需要的key，则抛出异常

  requiredProperties可以自己进行设置：

import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.core.env.ConfigurableEnvironment; public class MyApp { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); // 获取 ConfigurableEnvironment ConfigurableEnvironment environment = context.getEnvironment(); // 设置 requiredProperties environment.getPropertyResolver().setRequiredProperties("app.name", "app.version"); // 执行 refresh，触发环境变量校验 context.refresh(); // 如果 app.name 或 app.version 缺失，会抛出 MissingRequiredPropertiesException } } 3.2、obtainFreshBeanFactory

  obtainFreshBeanFactory主要用于获取 BeanFactory 并进行初始化：   其中refreshBeanFactory在不同的子类中有不同的实现，AnnotationConfigApplicationContext的实现如图：   限制了不能重复调用refresh方法，否则抛出异常：   而getBeanFactory在AnnotationConfigApplicationContext中最终调用的是GenericApplicationContext的getBeanFactory，即返回构造AnnotationConfigApplicationContext时创建的DefaultListableBeanFactory：

3.3、prepareBeanFactory

   在拿到3.2、obtainFreshBeanFactory的DefaultListableBeanFactory后，会通过prepareBeanFactory对其进行一些准备工作：

为 BeanFactory 设置必要的属性（如类加载器、表达式解析器等）；注册 Spring 上下文相关的回调接口（如 ApplicationContextAware）；为 BeanFactory 配置依赖解析规则，确保 Bean 可以正确注入 ApplicationContext、BeanFactory 等核心组件；处理 AOP 相关的 LoadTimeWeaver 组件；注册默认的环境 Bean（如 Environment、SystemProperties）。 protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { // 设置 BeanFactory 的类加载器，默认为当前 ApplicationContext 的类加载器， // 可以通过 context.setClassLoader() 方法自定义类加载器 beanFactory.setBeanClassLoader(getClassLoader()); // 如果未禁用 SpEL，则设置 BeanFactory 的 SpEL 表达式解析器， // 允许在 Bean 的属性中使用 SpEL 语法（如 #{...}） if (!shouldIgnoreSpel) { beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); } // 允许 Spring 解析属性值（如将字符串转换为 Resource 类型） beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); // 配置 BeanFactory 以支持 Spring 的回调机制 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); // 忽略特定的 Aware 接口依赖注入，防止它们被当作普通 Bean 进行处理 beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class); // 注册一些可解析的依赖，使某些类可以直接通过 Autowire 方式注入 //例如我在某个bean中直接@AutoWired注入ApplicationContext，明明没有自定义过ApplicationContextbean，为什么没有报错，就是因为下面的这一段代码。 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); beanFactory.registerResolvableDependency(ApplicationContext.class, this); // 添加 ApplicationListenerDetector 这个 BeanPostProcessor // 该处理器用于检测 ApplicationListener 类型的 Bean，并自动注册到事件发布器中 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); // 如果检测到 LoadTimeWeaver（用于类加载时织入，如 AspectJ），则进行相应的处理 if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { // 添加 LoadTimeWeaverAwareProcessor 处理器，使得 LoadTimeWeaverAware 类型的 Bean 能够感知 LoadTimeWeaver beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); // 设置一个临时类加载器，用于在 Bean 创建时进行类型匹配 beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } // 注册默认的环境相关 Bean，确保 Spring 上下文可以访问到 Environment 信息 if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); } if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); } if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); } if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) { beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup()); } } 3.4、postProcessBeanFactory

  postProcessBeanFactory是Spring的一个扩展点，允许子类去实现，也是模板方法模式的体现：   不同的实现，向beanFactory中添加不同的扩展内容。

3.5、invokeBeanFactoryPostProcessors

  invokeBeanFactoryPostProcessors的作用是找到并且执行所有的bean工厂后置处理器，bean工厂后置处理器有两个：

BeanDefinitionRegistryPostProcessor：继承自BeanFactoryPostProcessor，可以注册新bean，比BeanFactoryPostProcessor先执行。BeanFactoryPostProcessor：可以修改已有的bean定义. @Component public class MyBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor { @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { // 获取 BeanDefinition 并修改其 Scope BeanDefinition beanDefinition = beanFactory.getBeanDefinition("orderService"); beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE); System.out.println("修改 orderService 作用域为 prototype"); } @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { // 创建一个新的 BeanDefinition RootBeanDefinition beanDefinition = new RootBeanDefinition(UserService.class); registry.registerBeanDefinition("UserService", beanDefinition); System.out.println("动态注册了 UserService Bean"); } }

  invokeBeanFactoryPostProcessors方法：

参数一：bean工厂参数二：beanFactoryPostProcessors的集合，注意，此时的beanFactoryPostProcessors不是我们自定义的，因为我们自定义的在这一时刻还没有被扫描到。

  那么什么情况下，传入的beanFactoryPostProcessors不为空？可以在构造AnnotationConfigApplicationContext后自定义添加BeanFactoryPostProcessor

public class Test { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); context.addBeanFactoryPostProcessor(beanFactory -> { System.out.println("Executing custom BeanFactoryPostProcessor"); }); context.register(AppConfig.class); context.refresh(); } }

  以下是方法的详解，其总体的逻辑是：

先处理参数中的beanFactoryPostProcessors。执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor。执行实现了Ordered接口的BeanDefinitionRegistryPostProcessor。执行剩下的BeanDefinitionRegistryPostProcessor，这里使用了do…while循环，因为BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法可以注册新的bean，处理新的bean又继承了BeanDefinitionRegistryPostProcessor的特殊情况。如果有就会一直递归执行。执行实现了PriorityOrdered的BeanFactoryPostProcessor。执行实现了Ordered的BeanFactoryPostProcessor。执行剩下的BeanFactoryPostProcessor。 public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { Set<String> processedBeans = new HashSet<>(); // 记录已经处理过的 Bean，避免重复执行 // 判断当前 beanFactory 是否是 BeanDefinitionRegistry 类型（即是否支持注册 BeanDefinition） if (beanFactory instanceof BeanDefinitionRegistry) { BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; // 强制转换为 BeanDefinitionRegistry List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>(); // 存放普通的 BeanFactoryPostProcessor List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>(); // 存放 BeanDefinitionRegistryPostProcessor // 遍历传入的后置处理器列表 for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { // 如果是 BeanDefinitionRegistryPostProcessor，则执行 postProcessBeanDefinitionRegistry 方法 BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor; registryProcessor.postProcessBeanDefinitionRegistry(registry); // 处理 BeanDefinition 注册 registryProcessors.add(registryProcessor); // 加入 registryProcessors 列表 } else { regularPostProcessors.add(postProcessor); // 普通 BeanFactoryPostProcessor 处理器加入列表 } } List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>(); // 临时存储当前处理的 BeanDefinitionRegistryPostProcessor // 处理实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); // 获取所有 BeanDefinitionRegistryPostProcessor for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { // 判断是否实现了 PriorityOrdered 接口 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); // 获取 bean 并加入列表 processedBeans.add(ppName); // 记录已处理的 bean } } sortPostProcessors(currentRegistryProcessors, beanFactory); // 对处理器进行排序 registryProcessors.addAll(currentRegistryProcessors); // 加入总的 registryProcessors 列表 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup()); // 执行 postProcessBeanDefinitionRegistry 方法 currentRegistryProcessors.clear(); // 清空临时列表 // 处理实现了 Ordered 接口的 BeanDefinitionRegistryPostProcessor postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); // 再次获取所有 BeanDefinitionRegistryPostProcessor for (String ppName : postProcessorNames) { if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) { // 判断是否未处理并且实现了 Ordered 接口 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); // 获取 bean 并加入列表 processedBeans.add(ppName); // 记录已处理的 bean } } sortPostProcessors(currentRegistryProcessors, beanFactory); // 对处理器进行排序 registryProcessors.addAll(currentRegistryProcessors); // 加入总的 registryProcessors 列表 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup()); // 执行 postProcessBeanDefinitionRegistry 方法 currentRegistryProcessors.clear(); // 清空临时列表 // 处理剩下的 BeanDefinitionRegistryPostProcessor，直到不再有新的 boolean reiterate = true; while (reiterate) { reiterate = false; postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); // 再次获取所有 BeanDefinitionRegistryPostProcessor for (String ppName : postProcessorNames) { if (!processedBeans.contains(ppName)) { // 过滤已处理的 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); // 获取 bean 并加入列表 processedBeans.add(ppName); // 记录已处理的 bean reiterate = true; // 继续循环，直到所有都处理完 } } sortPostProcessors(currentRegistryProcessors, beanFactory); // 排序 registryProcessors.addAll(currentRegistryProcessors); // 加入总的 registryProcessors 列表 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup()); // 执行 postProcessBeanDefinitionRegistry 方法 currentRegistryProcessors.clear(); // 清空临时列表 } // 调用所有 BeanDefinitionRegistryPostProcessor 的 postProcessBeanFactory 方法 invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory); } else { // 如果 beanFactory 不是 BeanDefinitionRegistry，直接处理普通的 BeanFactoryPostProcessor invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); } // 处理所有 BeanFactoryPostProcessor String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); // 获取所有 BeanFactoryPostProcessor List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>(); // 存放 PriorityOrdered 类型的处理器 List<String> orderedPostProcessorNames = new ArrayList<>(); // 存放 Ordered 类型的处理器 List<String> nonOrderedPostProcessorNames = new ArrayList<>(); // 存放无序的处理器 for (String ppName : postProcessorNames) { if (processedBeans.contains(ppName)) { // 跳过已经处理过的 } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { // 处理 PriorityOrdered 类型 priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class)); } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { // 处理 Ordered 类型 orderedPostProcessorNames.add(ppName); } else { nonOrderedPostProcessorNames.add(ppName); // 处理无序类型 } } // 先执行 PriorityOrdered 的 BeanFactoryPostProcessor sortPostProcessors(priorityOrderedPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory); // 再执行 Ordered 的 BeanFactoryPostProcessor List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size()); for (String postProcessorName : orderedPostProcessorNames) { orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } sortPostProcessors(orderedPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory); // 最后执行无序的 BeanFactoryPostProcessor List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size()); for (String postProcessorName : nonOrderedPostProcessorNames) { nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory); // 清除 BeanFactory 的元数据缓存，防止后续 Bean 解析出现不一致 beanFactory.clearMetadataCache(); }

  在执行图上这一段代码前，在bean工厂里已经有了三个bean工厂后置处理器的bean定义： 第一个和扫描有关，后面两个和依赖注入有关

  至于是什么时候放进去的？追踪堆栈信息，是在构造AnnotationConfigApplicationContext时候，设置读取器的时候存入的：   只有ConfigurationClassPostProcessor是实现了BeanDefinitionRegistryPostProcessor和PriorityOrdered接口：   所以在invokeBeanFactoryPostProcessors的这一步，会拿到ConfigurationClassPostProcessor并且执行：   执行配置类扫描，单独开一篇笔记说明