- 一、容器的刷新
- 1. prepareRefresh()
- 2. obtainFreshBeanFactory()
- 3. prepareBeanFactory(beanFactory)
- 4. postProcessBeanFactory(beanFactory)
- 5. invokeBeanFactoryPostProcessors(beanFactory)
- 二、说明
经过前面的分析，下面进入到了这行代码：
// 刷新容器，初始化Spring环境
annotationConfigApplicationContext.refresh();
刷新容器这一步骤非常非常重要！！！也最复杂，所有Bean创建都在这个里面，下面逐个方法来分析。
需要注意的是，这个refresh()是在AbstractApplicationContext类中，它是AnnotationConfigApplicationContext的父类。
下面来看一下这个名声在外的refresh()方法：
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 准备工作，包括设置Spring容器启动时间，是否激活标识位，初始化属性源(property source)配置
prepareRefresh();
// 返回一个factory工厂， 为什么需要返回一个工厂？ 因为要对工厂进行初始化
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 准备工厂，会添加两个BeanPostProcessor:ApplicationContextAwareProcessor/ApplicationListenerDetector
prepareBeanFactory(beanFactory);
try {
// 这个方法在当前版本的spring是没用任何代码的，可能spring期待在后面的版本中去扩展吧
postProcessBeanFactory(beanFactory);
// 调用BeanFactoryPostProcessors的后置处理器
// 设置执行程序员自定义的BeanFactoryPostProcessors和Spring内部自己定义的
invokeBeanFactoryPostProcessors(beanFactory);
//-------------------此篇文章也就分析到此处！！---------------------------
//-------------------到此Spring工厂完成创建工作--------------------------
//-------------------下面的部分作为《容器的刷新-下》----------------------
// 注册BeanPostProcessor后置处理器
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
// 初始化应用事件广播器
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
} catch (BeansException ex) {
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
} finally {
resetCommonCaches();
}
}
}
上面简单的给出了每个方法的作用，下面来逐个方法研究。
1. prepareRefresh()这个方法主要的作用是：准备工作，包括设置Spring容器启动时间，是否激活标识位，初始化属性源(property source)配置，可以忽略。
这个方法返回的是一个ConfigurableListableBeanFactory容器工厂，就是之前创建的DefaultListableBeanFactory容器工厂，知道就好。
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 刷新BeanFactory,这个BeanFactory就是之前创建的DefaultListableBeanFactory
refreshBeanFactory();
// 将之前创建的DefaultListableBeanFactory返回
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
return beanFactory;
}
这个方法是对工厂做一些准备工作，比如设置：Bean表达式解释器、添加两个会BeanPostProcessor:ApplicationContextAwareProcessor/ApplicationListenerDetector等。
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
beanFactory.setBeanClassLoader(getClassLoader());
// bean表达式解释器，后面说 能够获取bean当中的属性在前台页面
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 对象与string类型的转换
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 往beanPostProcessors集合中添加一个后置处理器，ApplicationContextAwareProcessor，能够在bean中获得到各种*Aware
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
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.class，就用beanFactory替换
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 往beanPostProcessors集合中添加一个后置处理器 ApplicationListenerDetector
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// Register default environment beans.
// 意思是如果自定义的Bean中没有名为"systemProperties"和"systemEnvironment"的Bean，
// 则注册两个Bean，Key为"systemProperties"和"systemEnvironment"，Value为Map，这两个Bean就是一些系统配置和系统环境信息
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());
}
}
将三个环境变量systemEnvironment、environment、systemProperties放入到singletonObjects中，即实例化好！！！这个singletonObjects是干嘛的呢？就是存放完全初始化好的 Bean，可以从该Map中取出的，Bean可以直接使用。
这个singletonObjects里面存放的是已经实例化好的Bean所对应的对象，是个Map。 
这个方法在当前版本的Spring是没用任何代码的，可能Spring期待在后面的版本中去扩展吧，忽略。
5. invokeBeanFactoryPostProcessors(beanFactory)重头戏来啦，就是这个方法，这个方法的作用就是：调用BeanFactoryPostProcessors的后置处理器。
还记得容器中，现在有多少个BeanFactoryPostProcessors的后置处理器吗？答案就只有一个
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 这个地方需要注意getBeanFactoryPostProcessors()方法是获取手动给Spring容器中添加的BeanFactoryPostProcessor
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
这个getBeanFactoryPostProcessors()方法是获取程序员手动给Spring容器中添加的BeanFactoryPostProcessor。这句话什么意思呢？
第一，这里的BeanFactoryPostProcessor必须是程序员自己创建的，第二，创建完BeanFactoryPostProcessor后程序员是怎么放到容器中的？程序员可以在类上加@component注解修饰，如果用@component注解修饰，是要被Spring容器扫描后，容器中才会有的，但源码分析到目前为止，还并没有进行扫描操作，所以这种自定义方式的BeanFactoryPostProcessor，这地方并没有获取到。
所以这个getBeanFactoryPostProcessors()方法此处拿到的是：程序员自己手动调用AnnotationConfigApplicationContext.addBeanFactoryPostProcessor();方法add进去的！！！
getBeanFactoryPostProcessors()这个方法代码中是直接获取一个list，这个list是在AnnotationConfigApplicationContext被定义的
public List getBeanFactoryPostProcessors() {
return this.beanFactoryPostProcessors;
}
Debug断点调试图： 
程序员自己手动添加BeanFactoryPostProcessor代码及断点调试图如下：
public static void main(String[] args) {
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
ac.register(AppConfig.class);
// 手动添加BeanFactoryPostPorcessor
ac.addBeanFactoryPostProcessor(new TestBeanFactoryPostPorcessor());
ac.refresh();
IndexDao dao = ac.getBean(IndexDao.class);
dao.query();
}
Debug断点调试已经数据：
----------------------------------------上面知识点，没理解的话，再多读两遍--------------------------------------------
好了，下面接着分析PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()这个方法了，这个地方会很难，是Spring扩展点之一，也是核心所在，比较难理解，慢慢来吧~
// 如果程序员没有自己手动添加，方法的第二个参数beanFactoryPostProcessors传进来为null
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory,
List beanFactoryPostProcessors) {
// 定义一个Set,用于存放已经执行过的Bean的名字
Set processedBeans = new HashSet();
// 这地方条件为真，因为DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，所以进入
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 定义两个List，一个存放BeanFactoryPostProcessor，一个存放BeanDefinitionRegistryPostProcessor
// 此List是存放程序员自定义的BeanFactoryPostProcessor
List regularPostProcessors = new ArrayList();
// 这个里面存放的是程序员自定义的和Spring容器提供的BeanDefinitionRegistryPostProcessor
List registryProcessors = new ArrayList();
// 程序员自定义的beanFactoryPostProcessors,此处传进来为null
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
// 执行BeanDefinitionRegistryProcessor的postProcessBeanDefinitionRegistry方法（此处是自定义的）
registryProcessor.postProcessBeanDefinitionRegistry(registry);
// 加入到registryProcessors集合中
registryProcessors.add(registryProcessor);
} else {
// 如果不是BeanDefinitionRegistryPostProcessor这种类型，加入到regularPostProcessors集合中
regularPostProcessors.add(postProcessor);
}
}
// 这个currentRegistryProcessors 存放的是Spring内部自己实现了BeanDefinitionRegistryPostProcessor接口的对象
List currentRegistryProcessors = new ArrayList();
// 从容器中获取BeanDefinitionRegistryPostProcessor类型，这地方只有一个ConfigurationClassPostProcessor，
// 因为只有它实现了BeanDefinitionRegistryPostProcessor接口
// 还记得这个类是什么时候加到Spring容器中的么？是Spring默认在最开始自己创建reader读取器的时候注册的
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 这个ConfigurationClassPostProcessor有哪些功能呢？这个类就非常非常重要了
// Spring工厂需要去解析、去扫描等等功能，而这些功能都是需要在Spring工厂初始化完成之前执行
// 要么在工厂最开始的时候、要么在工厂初始化之中，反正不能在之后，因为如果在之后就没有意义，因为那个时候已经需要使用工厂了
// 所以Spring在一开始就注册了一个BeanFactoryPostProcessor，用来插手Spring工厂的实例化过程
for (String ppName : postProcessorNames) {
// ConfigurationClassPostProcessor实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 此处的getBean()里面执行了ConfigurationClassPostProcessor的实例化
// 此处的beanFactory.getBean()方法又是重点！！！！在AbstractBeanFactory类中
// 此处另起一篇分析AbstractBeanFactory中的getBean()方法
// 如果不知道是在这个getBean()方法进行ConfigurationClassPostProcessor的实例化的，那下面就会很困惑，因为下面104行代码已经开始调用它的方法了
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 排序不重要，况且currentRegistryProcessors这里也只有一个数据
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 合并list，不重要(为什么要合并，因为还有程序员自己定义的)
registryProcessors.addAll(currentRegistryProcessors);
// 最重要！！！注意这里是方法调用，执行currentRegistryProcessors中所有的BeanDefinitionRegistryPostProcessor
// 也就是ConfigurationClassPostProcessor中的postProcessBeanDefinitionRegistry()方法
// 此处另起一篇分析ConfigurationClassPostProcessor中的postProcessBeanDefinitionRegistry()方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 执行完成了所有BeanDefinitionRegistryPostProcessor，这个list只是一个临时变量，故而要清除
currentRegistryProcessors.clear();
// 到此处已经完成了所有类的扫描工作，因为扫描工作是在ConfigurationClassPostProcessor中的postProcessBeanDefinitionRegistry()方法完成的！！！！
// 程序员可能自己有创建了BeanDefinitionRegistryPostProcessor类，是用@Component注解修饰的，
// 所以这个地方被容器扫码到了，所以又去拿一遍，如果程序员没有自己创建，
// 那还是拿到了ConfigurationClassPostProcessor这个类
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 并没有实现Ordered接口，所以不会执行，PriorityOrdered继承了Ordered
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 此处currentRegistryProcessors为空，所以代码并没有啥意思，但这地方是不是Spring的一个扩展点呢？实现Ordered.class接口？
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
boolean reiterate = true;
while (reiterate) {
reiterate = false;
// 还是拿到这个ConfigurationClassPostProcessor,但processedBeans集合里已经包含这个类啦，所以也不会执行
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// processedBeans集合里已包含，所以条件不成立
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();
}
// 前面执行的BeanFactoryPostProcessor的子类BeanDefinitionRegistryPostProcessor中postProcessBeanDefinitionRegistry()方法
// 这里是执行的是BeanFactoryPostProcessor的postProcessBeanFactory中postProcessBeanFactory()方法
// 这个registryProcessors里面存的是啥？程序员自定义的和Spring内部添加的BeanDefinitionRegistryPostProcessor
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// 这里调用的是程序员自定义的BeanFactoryPostProcessor，这集合里并没有数据
// 这个regularPostProcessors里面存的是啥？程序员自定义的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
} else {
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 此处拿到的是实现BeanFactoryPostProcessor接口的类，也只有ConfigurationClassPostProcessor
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 存放实现了PriorityOrdered接口的BeanFactoryPostProcessor
List priorityOrderedPostProcessors = new ArrayList();
// 存放实现了Ordered接口的BeanFactoryPostProcessor
List orderedPostProcessorNames = new ArrayList();
// 存放没有实现任何排序接口的BeanFactoryPostProcessor
List nonOrderedPostProcessorNames = new ArrayList();
for (String ppName : postProcessorNames) {
// 此处processedBeans里面已经包含了org.springframework.context.annotation.internalConfigurationAnnotationProcessor，已经执行过了
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
} else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
} else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 调用实现了PriorityOrdered接口的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List 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 nonOrderedPostProcessors = new ArrayList();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
小结：invokeBeanFactoryPostProcessors(beanFactory);方法
前提，执行到这个方法时，如果程序员自己没有手动往BeanFactory中添加其他Bean，此刻，BeanFactory中只有以下七个，前6个是在实例化reader读取器的时候添加进去的，最后一个是在ac.register(AppConfig.class)时添加进去。但只有第一个是实现了BeanDefinitionRegistryPostProcessor接口的。
org.springframework.context.annotation.internalConfigurationAnnotationProcessor（只有这个满足） org.springframework.context.annotation.internalAutowiredAnnotationProcessor org.springframework.context.annotation.internalRequiredAnnotationProcessor org.springframework.context.annotation.internalCommonAnnotationProcessor org.springframework.context.event.internalEventListenerProcessor org.springframework.context.event.internalEventListenerFactory appConfig
首先，会从BeanFactory中拿程序员自己手动添加到BeanFactory中的BeanFactoryPostProcessor；
然后，会从BeanFactory中获取实现了BeanDefinitionRegistryPostProcessor接口的类，如果程序员没有自己手动往BeanFactory中添加，这里只能获取到一个：ConfigurationClassPostProcessor，因为只有它实现了BeanDefinitionRegistryPostProcessor这个接口；
其次，获取到这个ConfigurationClassPostProcessor后，判断是否实现了PriorityOrdered.class接口，满足的话，调用beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)方法实例化ConfigurationClassPostProcessor这个类；
ConfigurationClassPostProcessor实现BeanDefinitionRegistryPostProcessor、PriorityOrdered接口。
接着，开始调用ConfigurationClassPostProcessor中的postProcessBeanDefinitionRegistry()方法；
接着，再去BeanFactory中获取实现了BeanDefinitionRegistryPostProcessor接口的类，并判断是否实现Ordered.class接口，且没有被执行过，有的话，继续调用postProcessBeanDefinitionRegistry()方法；
接着，再去BeanFactory中获取实现了BeanDefinitionRegistryPostProcessor接口的类，这次的唯一条件是没有被执行过，有的话，继续调用postProcessBeanDefinitionRegistry()方法；
再接着，开始调用实现了BeanFactoryPostProcessor接口的postProcessBeanFactory()方法，（同样，这地方先调用程序员自己手动添加的哦！）这地方怎么理解呢？看一下BeanDefinitionRegistryPostProcessor接口声明，可以得到，只要实现了BeanDefinitionRegistryPostProcessor这个接口，必然要实现BeanFactoryPostProcessor这个接口，所以此次要执行BeanFactoryPostProcessor接口中的方法；
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) ;
}
接下来，再去BeanFactory中获取实现了BeanFactoryPostProcessor接口的类，有的话，调用那个postProcessBeanFactory()方法；
这个方法就是调用实现了BeanDefinitionRegistryPostProcessor接口和BeanFactoryPostProcessor接口的类，这地方如果程序员自己没有手动添加到BeanFactory中，那么只有一个类符合，这个就是大名鼎鼎的ConfigurationClassPostProcessor！！！！这个了非常非常终于，会单独成篇。
总结一下：
-
先执行程序员自定义的BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry()方法
-
再执行Spring自己提供的BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry()方法（只有一个）
-
然后再执行被Spring扫描到的BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry()方法
-
接着再执行程序员自定义和Spring自己提供的实现BeanDefinitionRegistryPostProcessor接口中的BeanFactoryPostProcessors()，但不包括扫描到的，因为是拿的registryProcessors集合里的
-
再执行程序员自定义的BeanFactoryPostProcessors，拿的regularPostProcessors集合里的
-
最后再执行被扫描到的BeanFactoryPostProcessors
这个方法执行完，Spring工厂的创建创建工作就完成了，此处为refresh()方法的上半部分，refresh()方法接下来的部分为下半部分，另起一篇。这个invokeBeanFactoryPostProcessors(beanFactory)方法里还有三个知识点没说明白，接下来就说它们吧，还记得哪三个知识点嘛？
- 调用
beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)方法实例化ConfigurationClassPostProcessor知识点； ConfigurationClassPostProcessor类的postProcessBeanDefinitionRegistry()方法调用；ConfigurationClassPostProcessor类的postProcessBeanFactory()方法调用；
