[TOC]
1、XML方式BeanDefination注册流程
1.1、测试demo
// 方法一，已过期
String path = "spring/beans.xml";
Resource resource = new ClassPathResource(path);
// BeanDefination注册流程
XmlBeanFactory beanFactory = new XmlBeanFactory(resource );
// 方法二
String path = "spring/beans.xml";
// 创建DefaultListableBeanFactory工厂，这也就是Spring的基本容器
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// 创建BeanDefinition阅读器
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
// 进行BeanDefinition注册流程
reader.loadBeanDefinitions(path);
// 总结：两种方法最终都是通过XmlBeanDefinitionReader开启解析注册流程
// 方法三：通过高级容器进行创建
// 创建IoC容器，并进行初始化
ApplicationContext context = new ClassPathXmlApplicationContext("spring/spring-ioc.xml");
// 获取Bean的实例
Student bean = (Teacher) context.getBean(Teacher.class);
1.2、源码分析
【XmlBeanFactory】#构造方法
@@XmlBeanDefinitionReader
# loadBeanDefinitions(EncodedResource resource)
# doLoadBeanDefinitions(InputSource inputSource, Resource resource)
// 通过DOM4J加载解析XML文件，最终形成Document对象
#Document doc = doLoadDocument(inputSource, resource)
// 通过对Document对象的操作，完成BeanDefinition的加载和注册工作
# registerBeanDefinitions(doc, resource)
// 创建BeanDefinitionDocumentReader来解析Document对象，完成BeanDefinition解析
@@BeanDefinitionDocumentReader
//解析过程入口，BeanDefinitionDocumentReader只是个接口
# registerBeanDefinitions(doc, ..)
// 具体的实现过程在DefaultBeanDefinitionDocumentReader完成
@@DefaultBeanDefinitionDocumentReader
// 真正实现BeanDefinition解析和注册工作
# registerBeanDefinitions(doc, ..)
// 委托给BeanDefinitionParserDelegate
// 从Document的根元素开始进行BeanDefinition的解析
# doRegisterBeanDefinitions(doc.getDocumentElement())
# parseBeanDefinitions(Eleme(ele)nt root)
// bean标签、import标签、alias标签，则使用默认解析规则
# parseDefaultElement(Element ele)
# processBeanDefinition(ele)
@@BeanDefinitionParserDelegate
# parseBeanDefinitionElement(ele)
// 最终注册方法
#BeanDefinitionReaderUtils
#registerBeanDefinition
// 解析自定义标签，如：<aop:config>
#parseCustomElement()
// 委托给BeanDefinitionParserDelegate
@@BeanDefinitionParserDelegate
# parseCustomElement(..)
# BeanDefinitionParser(..)
#parse(Element element, ..)
...省略
// 最终注册方法
#BeanDefinitionReaderUtils
#registerBeanDefinition
【ClassPathXmlApplicationContext】#构造方法
# setConfigLocations(configLocations)
# refresh()
@@AbstractApplicationContext
# refresh()
public void refresh() {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
// STEP 1： 刷新预处理
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// STEP 2：
// a） 创建IoC容器（DefaultListableBeanFactory）
// b） 加载解析XML文件（最终存储到Document对象中）
// c） 读取Document对象，并完成BeanDefinition的加载和注册工作
ConfigurableListableBeanFactory beanFactory =
obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// STEP 3： 对IoC容器进行一些预处理（设置一些公共属性）
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory
// in context subclasses.
// STEP 4：
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans
// in the context.
// STEP 5： 调用BeanFactoryPostProcessor后置处理器
// 对BeanDefinition处理
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// STEP 6： 注册BeanPostProcessor后置处理器
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
// STEP 7： 初始化一些消息源（比如处理国际化的i18n等消息源）
initMessageSource();
// Initialize event multicaster for this context.
// STEP 8： 初始化应用事件广播器
initApplicationEventMulticaster();
// Initialize other special beans
// in specific context subclasses.
// STEP 9： 初始化一些特殊的bean
onRefresh();
// Check for listener beans and register them.
// STEP 10： 注册一些监听器
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
// STEP 11： 实例化剩余的单例bean（非懒加载方式）
// 注意事项：Bean的IoC、DI和AOP都是发生在此步骤
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
// STEP 12： 完成刷新时，需要发布对应的事件
finishRefresh();
} catch (BeansException ex) {
// Destroy already created singletons
// to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
...
} finally {
// Reset common introspection caches in Spring's core, since
// might not ever need metadata for singleton beans anymore
resetCommonCaches();
}
}
}
// 通过此方法来解析相关BeanDefinition, 还会完成其余附属功能
# obtainFreshBeanFactory()
@@AbstractRefreshableApplicationContext
// 如果之前有IoC容器，则销毁
# refreshBeanFactory()
// 创建IoC容器，也就是DefaultListableBeanFactory
# createBeanFactory()
// 设置工厂的属性：是否允许BeanDefinition覆盖和是否允许循环依赖
# customizeBeanFactory(beanFactory);
// 调用载入BeanDefinition的方法，在当前类中只定义了抽象的
// loadBeanDefinitions方法，具体的实现调用子类容器
# loadBeanDefinitions(beanFactory); //钩子方法
@@ AbstractXmlApplicationContext
# loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
@@XmlBeanDefinitionReader
// XML Bean读取器调用其父类
// AbstractBeanDefinitionReader读取定位的资源
@@ AbstractBeanDefinitionReader
# loadBeanDefinitions(configLocations)
...
// 委派调用其子类
// XmlBeanDefinitionReader的方法，实现加载功能
# loadBeanDefinitions(Resource resource)
// 至此，回到上面1或者2的流程处理
2、注解方式BeanDefination注册流程
2.1 测试代码
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.spring.test.ioc.annotation.po");
Teacher student = context.getBean(Teacher.class);
2.2 源码分析
【AnnotationConfigApplicationContext】#构造方法
# scan(basePackages);
# refresh();
@@AbstractApplicationContext
# refresh()
// 解析源码见1.2说明
3、IOC容器启动核心流程（12步）
3.1 prepareRefresh刷新预处理
protected void prepareRefresh() {
// 1、这个方法设置context的启动日期。
this.startupDate = System.currentTimeMillis();
// 2、设置context当前的状态，是活动状态还是关闭状态。
this.closed.set(false);
this.active.set(true);
// 3、初始化context environment（上下文环境）中的占位符属性来源。
// 扩展覆盖protected void initPropertySources()方法，加载自定义环境属性值
// 如：getEnvironment().getSystemProperties().put("name","bobo");
initPropertySources();
// 4、验证所有必需的属性。
// 如：上一步getEnvironment().setRequiredProperties("username");
// 则在当前方法会进行校验，不存在则抛出异常
getEnvironment().validateRequiredProperties();
// 5、创建一些监听器事件的集合
this.earlyApplicationEvents = new LinkedHashSet<>();
}
3.2 obtainFreshBeanFactory创建默认工厂
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 主要是通过该方法完成IoC容器的刷新
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
return beanFactory;
}
protected final void refreshBeanFactory() throws BeansException {
// 1、如果之前有IoC容器，则销毁
if (hasBeanFactory()) {
// 销毁bean
destroyBeans();
// 关闭bean工厂
closeBeanFactory();
}
// 2、创建IoC容器，也就是DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
// 3、设置工厂的属性：是否允许BeanDefinition覆盖和是否允许循环依赖
customizeBeanFactory(beanFactory);
// 4、调用载入BeanDefinition的方法，在当前类中只定义了抽象的loadBeanDefinitions方法，
// 具体的实现调用子类容器如：AnnotationConfigWebApplicationContext、
// AbstractXmlApplicationContext
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
// 5、将创建好的bean工厂的引用交给的context来管理。
this.beanFactory = beanFactory;
}
}
3.3 prepareBeanFactory 配置预处理容器
// 配置这个工厂的标准环境，比如context的类加载器和后处理器
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 1、设置beanFactory的类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 2、设置属性解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new
ResourceEditorRegistrar(this,getEnvironment()));
// 3、添加到后置处理器列表, 新创建的 ApplicationContextAwareProcessor
// 入参为当前 ApplicationContext, 为实现Aware接口的bean设置对应的对象
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 4、忽略自动属性装配/赋值，默认只有BeanFactoryAware被忽略，要忽略其他类型，需要单独设置
// 此处目的是为了交给用户自定义实现Aware功能，基于自定义后置处理器处理Bean依赖
// 忽略该接口的实现类中和接口setter方法入参类型相同的依赖。
// 这样的做法使得ApplicationContextAware和BeanFactoryAware中的ApplicationContext或 // BeanFactory依赖在自动装配时被忽略，而统一由框架设置依赖，如ApplicationContextAware接口 // 的设置会在ApplicationContextAwareProcessor类中完成.
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// 5、该方法的主要作用就是指定该类型接口，如果外部要注入该类型接口的对象，则会注入我们
// 指定的对象，而不会去管其他接口实现类（因为多个实现类不知道注入哪个，在这里明确指定）
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 6、用于处理实现ApplicationListener接口的bean,bean初始化后添加监听
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 7、增加对AspectJ的支持
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new
LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new
ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 8、给容器中注册Singleton组件,ConfigurableEnviroment,systemProperties,
// systemEnvironment，添加到singletonObjects（ConcurrentHashMap类型）中
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());
}
}
3.4 postProcessBeanFactory 重写自定义修改bean工厂方法
// 因为此方法的参数是BeanFactory，所以我们可以重写此方法，然后针对beanFactory进行一些修改。
@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// ServletContextAwareProcessor中拿到应用上下文持有的servletContext引用和servletConfig引用
// 1.添加ServletContextAwareProcessor处理器
beanFactory.addBeanPostProcessor(new
ServletContextAwareProcessor(this.servletContext, this.servletConfig));
// 在自动注入时忽略指定的依赖接口，通常被应用上下文用来注册以其他方式解析的依赖项
beanFactory.ignoreDependencyInterface(ServletContextAware.class);
beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
// 2.注册web应用的scopes
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory,
this.servletContext);
// 3.注册和环境有关的beans
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}
3.5 invokeBeanFactoryPostProcessors BeanFactory处理器
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory
beanFactory) {
// 1.getBeanFactoryPostProcessors(): 拿到当前应用上下文beanFactoryPostProcessors
// 变量中的值，默认为空的，除非自己手动调用 context.addBeanFactoryPostProcessor
// (beanFactoryPostProcessor)完成自定义添加
// 2.invokeBeanFactoryPostProcessors: 实例化并调用所有已注册的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()));
}
}
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor>
beanFactoryPostProcessors) {
Set<String> processedBeans = new HashSet<String>();
// 1. beanFactory为DefaultListableBeanFactory, DefaultListableBeanFactory实现了
// BeanDefinitionRegistry接口，判定为true
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 1.1 保存普通的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> regularPostProcessors = new
LinkedList<BeanFactoryPostProcessor>();
// 1.2 保存BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new
LinkedList<BeanDefinitionRegistryPostProcessor>();
// 2. 遍历入参中beanFactoryPostProcessors, 将BeanDefinitionRegistryPostProcessor
// 和普通BeanFactoryPostProcessor区分开
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
// 2.1. 如果是BeanDefinitionRegistryPostProcessor
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
// 2.2. 执行BeanDefinitionRegistryPostProcessor接口的
// postProcessBeanDefinitionRegistry方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
// 2.3. 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
registryProcessors.add(registryProcessor);
} else {
// 3.1. 普通的BeanFactoryPostProcessor添加到regularPostProcessors
// (用于最后执行postProcessBeanFactory方法)
regularPostProcessors.add(postProcessor);
}
}
// 保存本次要执行的所有BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new
ArrayList<BeanDefinitionRegistryPostProcessor>();
// 4. 找出所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类
// 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName
String[] postProcessorNames = beanFactory.getBeanNamesForType
(BeanDefinitionRegistryPostProcessor.class, true, false);
// 5. 遍历postProcessorNames
for (String ppName : postProcessorNames) {
// 5.1. 判定是否实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 5.2. 获取ppName对应的bean实例, 添加到currentRegistryProcessors中,
// beanFactory.getBean方法会触发创建ppName对应的bean实例
currentRegistryProcessors.add(beanFactory.getBean(ppName,
BeanDefinitionRegistryPostProcessor.class));
// 5.3. 将实现类名添加到processedBeans，防止重复
processedBeans.add(ppName);
}
}
// 6. 进行排序(根据是否实现PriorityOrdered、Ordered接口和order值来排序)
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 7. 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
registryProcessors.addAll(currentRegistryProcessors);
// 8. 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 9. 清空currentRegistryProcessors
currentRegistryProcessors.clear();
// 10. 找出所有实现BeanDefinitionRegistryPostProcessor接口的类,
// 重复查找是因为执行完上面的BeanDefinitionRegistryPostProcessor,
// 可能会新增了其他的BeanDefinitionRegistryPostProcessor
postProcessorNames = beanFactory.getBeanNamesForType
(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 校验是否实现了Ordered接口，并且还未执行过
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName,
Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName,
BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 11. 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// 12. 最后查找所有剩下的BeanDefinitionRegistryPostProcessors
boolean reiterate = true;
while (reiterate) {
reiterate = false;
// 12.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
postProcessorNames = beanFactory.getBeanNamesForType
(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 12.2 跳过已经执行过的
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName,
BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
// 12.3 如果有BeanDefinitionRegistryPostProcessor被执行,
// 则有可能会产生新的BeanDefinitionRegistryPostProcessor,
// 因此这边将reiterate赋值为true, 代表需要再循环查找一次
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 13. 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors,
registry);
currentRegistryProcessors.clear();
}
// 14. 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
// (BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor)
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// 15. 调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的
// postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
} else {
// 直接调用传过来的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 到这里入参beanFactoryPostProcessors和容器中的所BeanDefinitionRegistryPostProcessor
// 已经全部处理完毕,下面开始处理容器中的所有BeanFactoryPostProcessor
// 16.找出所有实现BeanFactoryPostProcessor接口的类
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 17. 保存实现了PriorityOrdered接口的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new
ArrayList<BeanFactoryPostProcessor>();
// 保存实现了Ordered接口的BeanFactoryPostProcessor的beanName
List<String> orderedPostProcessorNames = new ArrayList<String>();
// 保存普通BeanFactoryPostProcessor的beanName
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
// 18. 遍历postProcessorNames, 将BeanFactoryPostProcessor
// 按实现PriorityOrdered、实现Ordered接口、普通三种区分开
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// 18.1 跳过已经执行过的
} else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 18.2 添加实现了PriorityOrdered接口的BeanFactoryPostProcessor
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName,
BeanFactoryPostProcessor.class));
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 18.3 添加实现了Ordered接口的BeanFactoryPostProcessor的beanName
orderedPostProcessorNames.add(ppName);
} else {
// 18.4 添加剩下的普通BeanFactoryPostProcessor的beanName
nonOrderedPostProcessorNames.add(ppName);
}
}
// 19. 对priorityOrderedPostProcessors排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 20. 调用所有实现PriorityOrdered接口的BeanFactoryPostProcessor
// 遍历priorityOrderedPostProcessors, 执行postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 21. 调用所有实现Ordered接口的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> orderedPostProcessors = new
ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : orderedPostProcessorNames) {
// 21.1 获取postProcessorName对应的bean实例, 添加到orderedPostProcessors, 准备执行
orderedPostProcessors.add(beanFactory.getBean(postProcessorName,
BeanFactoryPostProcessor.class));
}
// 21.2 对orderedPostProcessors排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 21.3 遍历orderedPostProcessors, 执行postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 22.调用所有剩下的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new
ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
// 22.1 获取postProcessorName对应的bean实例, 添加到nonOrderedPostProcessors
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName,
BeanFactoryPostProcessor.class));
}
// 22.2 遍历nonOrderedPostProcessors, 执行postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// 23. 清除元数据缓存（mergedBeanDefinitions、allBeanNamesByType、
// singletonBeanNamesByType），
// 因为后处理器可能已经修改了原始元数据，例如: 替换值中的占位符
beanFactory.clearMetadataCache();
}
3.6 registerBeanPostProcessors 注册后置处理器
// 注册用来拦截bean创建的BeanPostProcessor bean.这个方法需要在所有的application bean初始化之前调、
// 用。把这个注册的任务委托给了PostProcessorRegistrationDelegate来完成。
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
public static void registerBeanPostProcessors(ConfigurableListableBeanFactory
beanFactory,AbstractApplicationContext applicationContext) {
// 1. 查找所有实现BeanPostProcessor的后置处理器名称
String[] postProcessorNames = beanFactory.getBeanNamesForType
(BeanPostProcessor.class, true, false);
// 2. 计算处理器总数
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 +
postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory,
beanProcessorTargetCount));
// 3. 对所有的BeanPostProcessor按照PriorityOrdered、Ordered和普通的进行分组存储
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName,
BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 4. 排序并注册所有实现了PriorityOrdered的后置处理器
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 5. 排序并注册所有实现了Ordered的后置处理器
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 6. 注册所有普通的后置处理器
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 排序并注册所有实现了MergedBeanDefinitionPostProcessor的应用处理器
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 重新注册用来自动探测内部ApplicationListener的post-processor，
// 这样可以将他们移到处理器链条的末尾
beanFactory.addBeanPostProcessor(new
ApplicationListenerDetector(applicationContext));
}
3.7 initMessageSource 初始化消息源
// 初始化MessageSource接口的一个实现类。这个接口提供了消息处理功能。主要用于国际化/i18n。
// 此部分代码不做详细阐述
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME,
MessageSource.class);
if (this.parent != null && this.messageSource
instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource)
this.messageSource;
if (hms.getParentMessageSource() == null) {
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
}
else {
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
}
}
3.8 initApplicationEventMulticaster 初始化应用事件广播器
// 为context初始化一个事件监听多路广播器（ApplicationEventMulticaster）
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 检查是否给context配了一个ApplicationEventMulticaster实现类
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,
ApplicationEventMulticaster.class);
}
else {
// 如果没有，就使用默认的实现类 SimpleApplicationEventMulticaster
this.applicationEventMulticaster = new
SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,
this.applicationEventMulticaster);
}
}
3.9 onRefresh初始化特殊的Bean
// 在AbstractApplicationContext的子类中初始化其他特殊的bean。其实就是初始化ThemeSource接口的实例。
// 这个方法需要在所有单例bean初始化之前调用。
protected void onRefresh() throws BeansException {
// 是个空壳方法，在AnnotationApplicationContex上下文中没有实现，
// 可能在spring后面的版本会去扩展。
}
@Override
protected void onRefresh() {
this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}
3.10 registerListeners 注册应用监听器
// 注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，这些监听器是注册到
// ApplicationEventMulticaster中的。这不会影响到其它监听器bean。在注册完以后，还会将其前期的事件发布
// 给相匹配的监听器。
protected void registerListeners() {
// 获取实现了ApplicationListener的监听器
for (ApplicationListener<?> listener : getApplicationListeners()) {
// 手动注册的监听器绑定到广播器
getApplicationEventMulticaster().addApplicationListener(listener);
}
// 取到监听器的名称
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true,
// 设置到广播器 false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// 如果存在早期应用事件，发布事件消息
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
3.11 finishBeanFactoryInitialization 实例化非懒加载Bean
// 完成bean工厂的初始化工作。这一步非常复杂，也非常重要，涉及到了bean的创建。第二步中只是完成了
// BeanDefinition的定义、解析、处理、注册。但是还没有初始化bean实例。这一步 实例化剩余的单例bean（非懒
// 加载方式）. 注意事项：Bean的IoC、DI和AOP都是发生在此步骤
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory
beanFactory) {
// 1. 初始化此上下文的转换服务
...
// 2. 如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：
// 主要用于注解属性值的解析。
...
// 3. 初始化LoadTimeWeaverAware Bean实例对象
String[] weaverAwareNames = beanFactory.getBeanNamesForType
(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// 4. 冻结所有bean定义，注册的bean定义不会被修改
// 或进一步后处理，因为马上要创建 Bean 实例对象了
beanFactory.freezeConfiguration();
// 实例化单例Bean， 将在第四节【Bean初始化流程分析】进行讲解
beanFactory.preInstantiateSingletons();
}
3.12 finishRefresh 完成刷新发布应用事件
// 完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件
//（ContextRefreshedEvent）。
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
clearResourceCaches();
// 为此上下文初始化生命周期处理器
// 初始化所有的 LifecycleProcessor
// 在 Spring 中还提供了 Lifecycle 接口， Lifecycle 中包含 start/stop 方法，
// 实现此接口后 Spring 会保证在启动的时候调用其 start 方法开始生命周期，
// 并在 Spring 关闭的时候调用 stop 方法来结束生命周期，通常用来配置后台程序，在启动后一直运行
// （如对 MQ 进行轮询等）。ApplicationContext 的初始化最后正是保证了这一功能的实现。
initLifecycleProcessor();
// 将刷新完成事件广播到生命周期处理器
getLifecycleProcessor().onRefresh();
// 广播上下文刷新完成事件
publishEvent(new ContextRefreshedEvent(this));
// 将spring容器注册到LiveBeansView
// 和MBeanServer和MBean有关的。相当于把当前容器上下文，注册到MBeanServer里面去。
// MBeanServer持有了容器的引用，就可以拿到容器的所有内容，也就让Spring支持到了MBean的相关功能
LiveBeansView.registerApplicationContext(this);
}
