之前的文章：
2、深入理解Spring IOC(二) 、从xml到BeanDefinition
1.BeanDefinition的注册
在我们之前的文章中，我们已经把xml中的信息解析成了BeanDefiniton，然后我们需要注册他，其实所谓的注册也就是把解析出来的BeanDefiniton放到一个容器中去，以便在后边实例化的时候进行统一实例化。我们来看看下面的代码：
代码块1
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// 1.我们前文所说过的XmlBeanDefinitionReader
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// 2.现在是在AbstractXmlApplicationContext，其父类既继承了DefaultResourceLoader的，也
// 实现了ResourcePatternResolver
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// 3.设置验证模型
initBeanDefinitionReader(beanDefinitionReader);
// 4.加载Resource
loadBeanDefinitions(beanDefinitionReader);
}
这断代码相信大家已经很熟悉了吧，我们可以看到这个代码块的1处new了一个XmlBeanDefinitionReader，我们注意到，new的同时传了一个DefaultListableBeanFactory，这个DefaultListableBeanFactory它实现了了BeanDefinitionRegistry接口，换句话说，它也是一个BeanDefinitionRegistry的实例，这个东西起到了什么作用呢？我们来看看下面的中的第2处中代码调用方法的参数：
代码块2
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// 1.解析默认标签下的自定义标签
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 2.注册beanDefiniton实例.
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
这也是之前文章中的代码了，第2处调用的方法的第二个参数这个getReaderContext().getRegistry()方法返回的，就是上面DefaultListableBeanFactory的实例，我们直接点进2处BeanDefinitionReaderUtils的registerBeanDefinition方法来看：
代码块3
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// 1.注册beanDefinition
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// 2.注册别名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String aliase : aliases) {
registry.registerAlias(beanName, aliase);
}
}
}
我们着重看1处，之前也说过，这个registry实际上就是个DefaultListableBeanFactory的实例，因此我们顺着这个类来找到DefaultListableBeanFactory里 的registerBeanDefinition方法：
代码块4
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
// 1.校验，主要是校验method-override 和 factory-method（这两个不能共存）
((AbstractBeanDefinition) beanDefinition).validate();
}catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition oldBeanDefinition;
// 为什么要synchronized，因为其实ConcurrentHashMap并非绝对的线程安全
synchronized (this.beanDefinitionMap) {
oldBeanDefinition = this.beanDefinitionMap.get(beanName);
if (oldBeanDefinition != null) {
// 2.allowBeanDefinitionOverriding默认是true
if (!this.allowBeanDefinitionOverriding) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + oldBeanDefinition + "] bound.");
// 3. bean的role 表示beanDefiniton的种类，是个int类型的变量，你可以理解成这个数字越大其代表的beanDefinition就越底层
// 例如 1是用户定义的，2和3就都是配置相关的，只是配置级别不一样
} else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
" with a framework-generated bean definition ': replacing [" +
oldBeanDefinition + "] with [" + beanDefinition + "]");
}
} else {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean '" + beanName +
"': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
}
}
} else {
// 把beanName放到专门用于存bean名称的集合用于后续创建对象用
this.beanDefinitionNames.add(beanName);
this.frozenBeanDefinitionNames = null;
}
// 4. 真真正正的注册，其实就是将这个beanDefinition放到一个map中
this.beanDefinitionMap.put(beanName, beanDefinition);
}
if (oldBeanDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
我们可以看到，在4这个地方，将所有的解析好的BeanDefinition放到了一个Map容器中，到这里，完成了BeanDefinition的注册。
2.AbstractApplicationContext的refresh
可总算是到这里了，因为很多人看spring源码就是从这里开始的，也有很多人可能也就知道这个方法。总之今天会让你知道更多，我们直接到refresh方法这里：
代码块5
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 1.加载前的准备工作
prepareRefresh();
// 2.获取一个全新的beanFactory实例
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 3.初始化beanFactory，给它设置各种
prepareBeanFactory(beanFactory);
try {
// （空方法，让子类重写的）允许对beanFactory中的东西做一些前置的修改，可以是增加个BeanFactoryPostProcessors
// 这种的，也可以给增加个BeanDefinition，也可以增加一些让beanFactory在自动装配时候忽略掉的接口，也可以增加一些特定场景使用的bean，
// 比如有的后代就增加了新的scope bean 等等。但是重点是，我刚才说的这些都是基于一种具体场景的，因此这个抽象类里，
// 这个方法是空的(不弄成抽象的原因是不强迫子类去实现)
postProcessBeanFactory(beanFactory);
// 4.触发调用所有的BeanFactoryPostProcessors（后边会讲这是个啥）
invokeBeanFactoryPostProcessors(beanFactory);
// 5.注册所有的BeanPostProcessor（后边会说）
registerBeanPostProcessors(beanFactory);
// 6.初始化支持国际化的东东
initMessageSource();
// 7. 初始化事件广播器
initApplicationEventMulticaster();
// 8. 初始化其他特殊的bean
onRefresh();
// 9. 注册监听器
registerListeners();
// 10. 实例化bean（ 重点 ）
finishBeanFactoryInitialization(beanFactory);
finishRefresh();
} catch (BeansException ex) {
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;
}
}
}
尽管上面每一步都有注释，但是你肯定还是很懵逼，也不知道里面的方法到底都干了什么，为了容易一点让你理解，在这篇文章里，每一个大的部分都会被拆成很多小的部分讲，接下来我们针对上面代码块的每一个注释，展开说，每个细节都不放过。
在说之前有个需要大家注意的，我是基于之前那篇开始的代码debug，也就是说我们此时还是在用ClassPathXmlApplicationContext这个ApplicationContext的实现类，很多讲源码的文章都是直接说refresh方法，说真的，不基于使用场景去讲这个真的感觉像是在耍流氓。好了，吐槽的话说完了，我们开始
5.1
代码块5中1处调用的prepareRefresh主要是做的加载前的准备工作，我们直接来看prepareRefresh方法都做了什么
代码块6
protected void prepareRefresh() {
// 1. 记录下容器开始刷新的时间
this.startupDate = System.currentTimeMillis();
// 2. 把容器标为激活状态
synchronized (this.activeMonitor) {
this.active = true;
}
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
// 3. ClassPathXmlApplicationContext的时候调的是个空方法，跳过～
initPropertySources();
// 4. 调用StandardEnvironment中的validateRequiredProperties方法
getEnvironment().validateRequiredProperties();
}
上面的1、2、3处很容易理解，我们直接看4处的validateRequiredProperties方法，这块的这个代码其实是在AbstractEnvironment中：
代码块7
@Override
public void validateRequiredProperties() throws MissingRequiredPropertiesException {
this.propertyResolver.validateRequiredProperties();
}
这里的这个propertyResolver是个PropertySourcesPropertyResolver的实例，这个玩意是用来解析存放一些环境变量以及配置用的（比如springboot的properties和yml的属性最后都会存放到这里面的propertySources中），我们直接来看PropertySourcesPropertyResolver的validateRequiredProperties方法,其实它是直接继承的AbstractPropertyResolver的这个方法：
代码块8
@Override
public void validateRequiredProperties() {
// 先new个异常
MissingRequiredPropertiesException ex = new MissingRequiredPropertiesException();
// 如果需要的属性为空那么就把上一句new出来的异常抛出去
for (String key : this.requiredProperties) {
if (this.getProperty(key) == null) {
ex.addMissingRequiredProperty(key);
}
}
if (!ex.getMissingRequiredProperties().isEmpty()) {
throw ex;
}
}
但是哈，debug的时候这个this.requiredProperties其实是空的，这是因为在创建StandardEnvironment的时候并没有去调用setRequiredProperties去添加必须属性，所以这个方法其实在我们讲的这个背景下p都没有干，但是我们还是需要注意PropertySourcesPropertyResolver（你最少要知道它是什么），因为这玩意在SpringBoot中是很重要的。
5.2
代码块5中2处这里主要的目的是获取一个全新的DefaultListableBeanFactory，并且，把xml中对应的信息加载成BeanDefinition放到这里面去。加载的过程我们之前文章就是专门讲的这个，这里不再赘述。
5.3
这里主要还是一些初始化工作
代码块9
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
//设置类加载器：存在则直接设置/不存在则新建一个默认类加载器
beanFactory.setBeanClassLoader(getClassLoader());
//设置EL表达式解析器（Bean初始化完成后填充属性时会用到）
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
//设置属性注册解析器PropertyEditor
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
// 将当前的ApplicationContext对象交给ApplicationContextAwareProcessor类来处理，
// 从而在Aware接口实现类中的注入applicationContext
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//设置忽略自动装配的接口
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
// 注册可以解析的自动装配
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
//如果当前BeanFactory包含loadTimeWeaver Bean，说明存在类加载期织入AspectJ，
//则把当前BeanFactory交给类加载期BeanPostProcessor实现类LoadTimeWeaverAwareProcessor来处理，
//从而实现类加载期织入AspectJ的目的。
// 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()));
}
//注册当前容器环境environment组件Bean
// Register default environment beans.
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
//注册系统配置systemProperties组件Bean
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
//注册系统环境systemEnvironment组件Bean
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
虽然能给的注释我都给了，但是我估计你看到这个还是一脸懵逼，根本不知道这些东西是干什么用的，实在不明白，可以先混个脸熟，等后边看完了再返回到这里看。
5.4
这里是触发所有的BeanFactoryPostProcessor，关于BeanFactoryPostProcessor，接下来会有一篇扩展篇，专门说这个。我们在这里，可以先看这里的代码，因为这块其实很容易理解。
代码块10
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
}
我们可以看到，又是个delegate，那我们就直接去delegate里面去看：
代码块11
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// 已经实例化过的processor的集合
Set<String> processedBeans = new HashSet<String>();
// 首先调用BeanDefinitionRegistryPostProcessors
// 因为参数中的beanFactory是DefaultListableBeanFactory的实例，而DefaultListableBeanFactory实现了
// BeanDefinitionRegistry，因此，if的条件是true
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// regularPostProcessors 是放普通的BeanFactoryPostProcessor的
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
// 而这个registryPostProcessors是放BeanDefinitionRegistryPostProcessor的
// 注意：BeanDefinitionRegistryPostProcessor接口继承了BeanFactoryPostProcessor
List<BeanDefinitionRegistryPostProcessor> registryPostProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
// 如果BeanFactoryPostProcessor是BeanDefinitionRegistryPostProcessor，
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryPostProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
// 执行BeanDefinitionRegistryPostProcessor，并加入registryPostProcessors集合
registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
registryPostProcessors.add(registryPostProcessor);
// 否则只加入regularPostProcessors集合
} else {
regularPostProcessors.add(postProcessor);
}
}
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 首先调用实现了 PriorityOrdered 的 BeanDefinitionRegistryPostProcessors
List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 注意，这里实例化了BeanDefinitionRegistryPostProcessor
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 这个排序呢，其实是为了调整好那种既实现了PriorityOrdered，和Ordered的BeanDefinitionRegistryPostProcessor
// 因为实现了PriorityOrdered也可以同时实现Ordered（虽然PriorityOrdered继承了Ordered，）在同时实现这两个接口的情况
// 下，如果不排序，但是你的BeanDefinitionRegistryPostProcessor又需要这种执行顺序时候，在下面invoke的时候就会有问题
// 接下来的排序也是这个道理
OrderComparator.sort(priorityOrderedPostProcessors);
// 把实现了 PriorityOrdered 的放到之前的 registryPostProcessors 中
registryPostProcessors.addAll(priorityOrderedPostProcessors);
// 执行实现了 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor
invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
// 然后调用实现了 Ordered 的 BeanDefinitionRegistryPostProcessors
// 为什么要重新拿这个数组呢？因为实现了 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor 可以给你注册了实现
// Ordered 和什么排序接口都没有的 BeanDefinitionRegistryPostProcessor
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
for (String ppName : postProcessorNames) {
// 执行过的跳过不执行
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
OrderComparator.sort(orderedPostProcessors);
registryPostProcessors.addAll(orderedPostProcessors);
invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
// 最后调用实现了其他的BeanDefinitionRegistryPostProcessors
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 外层之所以是个while循环，是因为BeanDefinitionRegistryPostProcessor可以再给你
// 注册个BeanDefinitionRegistryPostProcessor进来，所以要循环执行，只要你的for循环可以进来
// reiterate这个是否循环的flag就是true
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
registryPostProcessors.add(pp);
processedBeans.add(ppName);
pp.postProcessBeanDefinitionRegistry(registry);
reiterate = true;
}
}
}
// 都是调用BeanFactoryPostProcessor的方法postProcessBeanFactory
invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}else {
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 这里有个很大的注意点哦：上面的逻辑都是在调用入参的BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor
// 而接下来的是调用beanFactory容器中的BeanFactoryPostProcessor，逻辑和上面类似，也是按实现PriorityOrdered，Ordered
// 和普通的来调用。至于为什么要先调用BeanDefinitionRegistryPostProcessors然后调用BeanFactoryPostProcessor呢？这是因为
// BeanDefinitionRegistryPostProcessors也可以注册新的BeanFactoryPostProcessor进来
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 三个优先级的BeanFactoryPostProcessor的集合
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
// 如果已经被解析过则跳过
if (processedBeans.contains(ppName)) {
// 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 {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 排序并调用高优先级的BeanFactoryPostProcessor
OrderComparator.sort(priorityOrderedPostProcessors);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 初始化一般优先级BeanFactoryPostProcessor并排序调用
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
OrderComparator.sort(orderedPostProcessors);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 初始化普通的BeanFactoryPostProcessor并排序调用
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
}
代码比较长，但是思路还是很清晰的，总体也就是先按顺序调用BeanDefinitionRegistryPostProcessor，然后按同样的顺序调用BeanFactoryPostProcessor。
5.5
这里是注册所有的BeanPostProcessor的，注意哈，不会调用的，因为这个BeanPostProcessor必须等到Bean初始化之后才可以被调用。我会在和BeanFactoryPostProcessor同一篇文章中去说这个BeanPostProcessor。我们同样的可以直接来看注册BeanPostProcessor的源码（因为简单），还是在和上面代码块相同的一个类中，只不过是另外一个方法：
代码块12
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 拿到所有的BeanPostProcessor名称
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 优先注册一个BeanPostProcessorChecker的实例,这玩意是用作在BeanPostProcessor初始化的这个过程
// 做检查用的，检查内容见扩展篇
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 还是熟悉的套路，将三种优先级别的BeanPostProcessor分开
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
// 先实例化实现了PriorityOrdered的，并加入集合
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
// 如果是MergedBeanDefinitionPostProcessor，则加入internalPostProcessors
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
} else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 排序并注册
OrderComparator.sort(priorityOrderedPostProcessors);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 接着注册实现了Ordered的
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
OrderComparator.sort(orderedPostProcessors);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 再注册普通的
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
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的（为了移动到处理链路的最后一个）
// 不明白什么是处理链路的先往下看，到后边自然会明白
OrderComparator.sort(internalPostProcessors);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 重新注册ApplicationListenerDetector（也是为了移动到处理链路的最后一个）
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
实际上和之前注册BeanFactoryPostProcessor的方式类似，这里不做过多的解释，看注释即可。
代码块5的6、7、8、9这四处代码不属于核心流程，我们暂时不关注这些。至此，实例化bean的前期准备工作已经做完。我们总结一下，使用xml的这种情况下，在refresh方法中bean实例化之前，主要干了这么几件事，首先需要把所有的BeanDefinition加载进BeanFactory容器这个是在refresh的第二步做的，接下来是需要在prepareBeanFactory中率先初始化一些基本的bean，然后是调用所有的BeanFactoryPostProcessor去对BeanDefinition做后置处理，接着去注册所有的BeanPostProcessor，再下来是国际化、事件广播器以及监听器的初始化。在这其中，最重要的，是加载BeanDefinition这步以及调用BeanFactoryPostProcessor的这步，因为这两步中，我们都是可以插手去做扩展的。