Spring IOC （二）
refresh() 的全过程
前五个方法
refresh()
定义：
这个方法中，内置了13个方法，做了很多事情
方法：
| 方法 | 作用 |
|---|---|
| prepareRefresh() | 保存了容器的启动时间，启动标志等 |
| obtainFreshBeanFactory(); | 获得了DefaultListableBeanFactory |
| prepareBeanFactory(beanFactory); | 添加了两个后置处理器 忽略自动装配 和 允许自动装配 bean表达式解析器 |
| postProcessBeanFactory(beanFactory); | 空方法 |
| invokeBeanFactoryPostProcessors(beanFactory); | 执行自定义的BeanFactoryProcessor 和内置的BeanFactoryProcessor |
| registerBeanPostProcessors(beanFactory); | 注册BeanPostProcessor |
| initMessageSource(); | 初始化信息源 |
| initApplicationEventMulticaster(); | 初始化应用事件多播器 |
| onRefresh(); | 空方法 |
| registerListeners(); | 注册监听器，用于监听bean并注册他们 |
| finishBeanFactoryInitialization(beanFactory); | 初始化所有剩余的单例 bean |
| finishRefresh(); | 调用 生命周期处理器的onRefresh() 发布事件 |
| destroyBeans(); | 销毁所有单例池所有实例bean |
prepareRefresh()
定义：
这个方法主要做了一些刷新前的准备工作，和主流程关系不大，主要是保存了容器的启动时间，启动标志等
obtainFreshBeanFactory()
定义：
这个方法在注解配置类中，只是将beanFactory取出来而已。
prepareBeanFactory()
定义：
这个方法添加了两个后置处理器、设置自动装配、bean解析表达式
源码：
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 设置类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 设置bean表达式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 属性编辑器支持
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 添加一个后置处理器：ApplicationContextAwareProcessor
// 此后置处理处理器实现了BeanPostProcessor接口
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.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
//添加一个后置处理器：ApplicationListenerDetector，此后置处理器实现了BeanPostProcessor接口
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()));
}
//如果没有注册过bean名称为XXX，spring就自己创建一个名称为XXX的singleton 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());
}
}
主要做了如下的操作：
- 设置了类加载器
- 设置了bean表达式解析器
- 添加了属性编辑器的支持
- 添加了一个后置处理器：ApplicationContextAwareProcessor，实现了BeanPostProcessor接口
- 设置了一些忽略自动装配的接口
- 设置了一些允许自动装配的接口，并且进行了赋值操作
- 在容器中还没有XX的bean的时候，帮我们注册beanName为XX的singleton bean
postProcessBeanFactory(beanFactory)
定义：
空方法，留给扩展实现
invokeBeanFactoryPostProcessors(beanFactory)
定义：
重要方法，他执行了自定义和内置的 BeanFactoryPostProcessor，去解析配置类，扫描并注册 配置类下配置的包路径的所有bean，让他们变成beanDefinition，生成原料给beanFactory使用
源码：
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 1. getBeanFactoryPostProcessors 支持自定义添加beanFactoryPostProcessor
// context.addBeanFactoryPostProcessor(XXX);
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
小结：
这里的getBeanFactoryPostProcessors()正常情况，会返回空的list
这个接口是给用户自定义添加bean工厂后置处理器来用的，给用户扩展~
源码：
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors() 这个静态方法
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
Set<String> processedBeans = new HashSet<>();
// 1. beanFactory 默认是DefaultListableBeanFactory，是BeanDefinitionRegistry的实现类
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 2. regularPostProcessors 用来存放BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 3. registryProcessors 用来存放BeanDefinitionRegistryPostProcessor
//BeanDefinitionRegistryPostProcessor 扩展了 BeanFactoryPostProcessor，有自己独有方法
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 4. 【User自定义的bean工厂后置处理器】 手动添加 BeanFactoryPostProcessor
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
/**
* 5.
* 判断postProcessor是不是BeanDefinitionRegistryPostProcessor，
* 因为BeanDefinitionRegistryPostProcessor扩展了BeanFactoryPostProcessor，
* 所以这里先要判断是不是BeanDefinitionRegistryPostProcessor
* 是的话，直接执行postProcessBeanDefinitionRegistry()方法 **独有方法**
* 然后把对象装到注册后置处理器 registryProcessors
*/
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
// 6. 不是的话，就装到普通后置处理器 regularPostProcessors
regularPostProcessors.add(postProcessor);
}
}
// 7. 一个临时变量，用来装载BeanDefinitionRegistryPostProcessor
// 8. BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
/**
* 9. 【执行Spring内置的Bean定义注册后置处理器】 【最优先的！】
* 扫描BeanDefinition来获得实现BeanDefinitionRegistryPostProcessor接口的类
* 只能找到 BeanName = internalConfigurationAnnotationProcessor
* 并且装入数组postProcessorNames，【一般情况下，只会找到这一个】
* 大坑：自己创建一个实现BeanDefinitionRegistryPostProcessor接口的类 + @Component注解，配置类也加上了@Component注解，但是这里却没有拿到
* ==============================================================
* 因为直到这一步，Spring还没有去扫描我们配置的包路径啊啊啊，Spring靠的是解析配置类来找到包名，那它用什么来解析配置类的？靠的是ConfigurationClassPostProcessor类，其实也就是现在在实例化并执行的类
*
*/
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
/**
* 10.
* 内层方法getBean()作用：
* (1) 实例化BeanName为ppName，实现了BeanDefinitionRegistryPostProcessor接口的类
* (2) 返回一个ConfigurationClassPostProcessor类，它满足要求
*
* ConfigurationClassPostProcessor类作用：
* (1) 扫描@Bean，@Import，@ImportResouce等各种操作
* (2) 处理 full 和 lite 的两种配置类
*/
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 11. 标识集合，标识已经执行
processedBeans.add(ppName);
}
}
// 排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
/**
* 12. 合并
* 合并注册后置处理器，为什么要合并？
* 因为下面只是执行了**注册后置处理器** 特有的方法
* 它的父接口**bean工厂后置处理器** 的方法还没执行，所以加到注册后置处理器中，后面统一执行
*/
registryProcessors.addAll(currentRegistryProcessors);
/**
* 13. 可以理解为执行ConfigurationClassPostProcessor类的postProcessBeanDefinitionRegistry()方法
* 这里的作用将配置类注册到BeanDefinitionMap中
*/
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 14. 清空临时变量，给下面复用
currentRegistryProcessors.clear();
/**
* 15. 【执行User自定义的Bean定义注册后置处理器】 【优先的！】
* 扫描BeanDefinition来获得实现BeanDefinitionRegistryPostProcessor接口的类
* ==============================================================
* 这时候，能找到User自定义的Bean定义注册后置处理器了，为什么？
* (1) 因为上面的 *配置类后置处理器* 它invoke()了鸭！注册了我们写的所有bean！啊啊啊！
*
*/
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);
/**
* 19. 合并
* 再问一次！为什么要合并？？
* 因为等等下面只是执行了**注册后置处理器** 特有的方法鸭！
* 我们自定义的时候，重写了两个方法，下面才帮我们执行了一个，所以要存起来，一会儿统一执行！
*/
registryProcessors.addAll(currentRegistryProcessors);
// 20. 执行我们自定义的BeanDefinitionRegistryPostProcessor
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//清空临时变量
currentRegistryProcessors.clear();
// 上面的代码是执行了实现了Ordered接口的BeanDefinitionRegistryPostProcessor，
// 下面的代码就是执行没有实现Ordered接口的BeanDefinitionRegistryPostProcessor
/**
* 20.
* 上面的代码执行了 **上等人的注册后置处理器** 【实现Ordered接口】
* 轮也轮到 **下等人的注册后置处理器执行了吧！** 【没有实现Ordered接口的】
* ===========================================================
* 虽然没实现Ordered，但是不至于没资格执行噢！所以这里会执行都没实现的那些 **下等注册后置处理器**
*/
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();
}
/** 21. 上面的四个循环的作用：
* (1) 第一个循环是针对【User手动 **addBean工厂后置处理器** 的情况】，处理这种情况的。
* (2) 将上等人接口 【实现了PriorityOrdered类】 ConfigurationAnnotationProcessor 的注册方法执行了
* (3) 将中等人接口 【自定义实现了Ordered类】 的注册方法执行了
* (4) 将下等人接口 【两个都没实现的类】 的注册方法执行了
*======================================
* 现在该干嘛？？？？
* 当然是将他们爸爸 【BeanFactoryPostProcessor接口】 定义的方法执行啊！
*/
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
/**
* 22. 执行【BeanFactoryPostProcessor接口】的实现类的方法咯！
* 这个一般不会有值，【User手动 **addBean工厂后置处理器** 的情况才会有值】
*/
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// 一般不会走这里
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 23. 上面处理了
// (1)用户自定义的BeanFactoryPostProcessor
// (2) *USER和Spring* 都定义的 BeanDefinitionRegistryPostProcessor
// 24. 现在该处理 Spring定义的 BeanFactoryPostProcessor 了鸭！！
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 25. 像上面👆那样，按优先级分成 ==上中下三等人==
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 26. 循环BeanName数组
for (String ppName : postProcessorNames) {
// 已经被执行过，就跳过啦！
if (processedBeans.contains(ppName)) {
}
// 27. 上等人！实现了PriorityOrdered接口
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
// 28. 中等人！如果实现了Ordered接口
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
// 29. 下等人！既没有实现PriorityOrdered，也没有实现Ordered
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 30. 上等人先执行
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 31. 中等人要通过bean工厂先实例化bean，才有bean去执行！
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
// getBean() ==》 实例化bean
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 排序执行
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 32. 下等人要通过bean工厂先实例化bean，才有bean去执行！
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
// getBean() ==》 实例化bean
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 执行
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
beanFactory.clearMetadataCache();
}
小结
- 这个方法，最最最主要做了两件事，就是执行
-
接口
BeanFactoryPostProcessor的方法postProcessBeanFactory() -
接口
BeanDefinitionRegistryPostProcessor的方法postProcessBeanDefinitionRegistry()
为什么这么复杂？
因为这个B接口BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor，导致得先执行它自己特有的方法，最后才能去执行父类方法，就搞了很多循环
第一个循环：
第一个循环的目标是执行 用户add 的类实现BeanDefinitionRegistryPostProcessor的方法
-
对象 —— 用户自定义
-
接口 —— BeanDefinitionRegistryPostProcessor
-
父接口去向 —— **BeanFactoryPostProcessor **滚去集合List里面，等后面一起执行
-
执行的方法 —— postProcessBeanDefinitionRegistry()
**注意：**这里的用户add，是指当我们程序员在new 上下文的时候，自己去addBeanFactoryPostProcessor()，你add 多少个，就会有多少个在第一次循环的时候被读取，被放入那里噢！，等到后面再执行！
第二个循环：
第二个循环的目标是执行 Spring内置、上等人 的类实现BeanDefinitionRegistryPostProcessor的方法
- 对象 —— Spring内置
- 接口 —— BeanDefinitionRegistryPostProcessor
- 类别 —— 上等人 【PriorityOrdered.Class】
- 执行的方法 —— postProcessBeanDefinitionRegistry()
注意：这里Spring内置准确来说只有一个类 ConfigurationClassPostProcessor，只有它满足要求！
所以这里实例化了这个 配置类后置处理器，并且将它加入执行集合List
等到后面排序、执行，一连套操作给他执行接口独有的方法噢！ 【这个方法可以扫描配置类、注册bean】
第三个循环：
第三个循环的目标是执行 中等人 的类实现BeanDefinitionRegistryPostProcessor的方法
- 对象 —— 用户、Spring定义的都可以
- 接口 —— BeanDefinitionRegistryPostProcessor
- 类别 —— 中等人 【Ordered.Class】
- 执行的方法 —— postProcessBeanDefinitionRegistry()
注意： 在这里，我们可以扩展自己想要的 Bean定义注册后置处理器，只需要让他完成两件事：
（1）实现BeanDefinitionRegistryPostProcessor接口
（2）实现中等人接口 Ordered接口
第四个循环：
第四个循环的目标是执行 下等人 的类实现BeanDefinitionRegistryPostProcessor的方法
- 对象 —— 用户、Spring定义的都可以
- 接口 —— BeanDefinitionRegistryPostProcessor
- 类别 —— 下等人 【没有PriorityOrdered.Class、也没有Ordered.Class】
- 执行的方法 —— postProcessBeanDefinitionRegistry()
注意： 在这里，我们可以扩展自己想要的 Bean定义注册后置处理器，只需要让他完成一件事：
（1）实现BeanDefinitionRegistryPostProcessor接口
两个invoke
- 执行 用户add 的类实现 BeanFactoryPostProcessor 对应的方法
- 执行 **用户自定义和Spring **的类实现 BeanDefinitionRegistryPostProcessor 对应的父接口的方法
其实执行了同一个方法：postProcessBeanFactory()
最后的三个循环：
最后的三个循环，目标是执行 Spring内置和用户自定义 的类实现了BeanFactoryPostProcessor的方法
-
对象 —— Spring内置和用户自定义的类
-
接口 —— BeanFactoryPostProcessor
-
类别 —— 也分为 上中下三等
-
执行的方法 —— postProcessBeanFactory()
大总结：
注意区分 用户add() 和 用户自定义
-
用户add()是用户调用上下文手动add()后置处理器
context.addBeanFactoryPostProcessor() -
用户自定义是用户写了一个类，实现了BeanFactoryPostProcessor这个接口，并**@Component**加入IOC容器
第一种优先执行，而第二种要依赖于Spring内置的配置类后置处理器扫描注册，才能执行！
| 执行顺序 | 执行方法的接口 | 执行的方法 |
|---|---|---|
| 用户add() Bean工厂后置处理器 | BeanDefinitionRegistryPostProcessor 第一执行 | postProcessBeanDefinitionRegistry() |
| Spring内置 Bean定义注册后置处理器 | BeanDefinitionRegistryPostProcessor + PriorityOrdered 第二执行 | postProcessBeanDefinitionRegistry() |
| 用户自定义+Spring内置 Bean定义注册后置处理器 | BeanDefinitionRegistryPostProcessor + Ordered 第三执行 | postProcessBeanDefinitionRegistry() |
| 用户自定义+Spring内置 Bean定义注册后置处理器 | BeanDefinitionRegistryPostProcessor 第四执行 | postProcessBeanDefinitionRegistry() |
| Spring内置 Bean定义注册后置处理器 | BeanFactoryPostProcessor 第五执行 | postProcessBeanFactory() |
| 用户add() Bean工厂后置处理器 | BeanFactoryPostProcessor 第六执行 | postProcessBeanFactory() |
| 用户自定义+Spring内置 Bean工厂后置处理器 | BeanFactoryPostProcessor + PriorityOrdered 第七执行 | postProcessBeanFactory() |
| 用户自定义+Spring内置 Bean工厂后置处理器 | BeanFactoryPostProcessor + Ordered 第八执行 | postProcessBeanFactory() |
| 用户自定义+Spring内置 Bean工厂后置处理器 | BeanFactoryPostProcessor 第九执行 | postProcessBeanFactory() |
内置的配置类后置处理器
定义：
前面提到：第二执行的时候，是Spring内置的配置类后置处理器来执行扫描配置类和包下的bean的，也就是类 ConfigurationClassPostProcessor
方法：
他主要是通过方法 postProcessBeanDefinitionRegistry() 来对配置类解析，对它包下的bean进行扫描注册
接下来看看他是怎么解析的
源码：
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
// ...
// 1. 主要是通过这个方法来解析
processConfigBeanDefinitions(registry);
}
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
// 2. 获得candidateNames数组
String[] candidateNames = registry.getBeanDefinitionNames();
// 3. 循环【找配置类】
for (String beanName : candidateNames) {
// 4. 根据beanName获得BeanDefinition
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
/**
* 5. 内部有两个标记位来标记是否已经处理过了
* Full or Lite
* 注册配置类，有两种选择：
* (1) @Configuration
* (2) @Component、@ComponentScan、@Import、@ImportResource
* 第一种称为Full配置类，第二种称为Lite配置类
* =============================================
* Full类：getBean时会拿到CGlib动态代理的配置类
* Lite类：getBean时会拿到原来的bean配置类
*/
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
// 6. 检查bean定义它是不是配置类，如果是，给他打上标记！
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
// 7. 配置类入队，等待检查
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// 8. 循环过后，如果没有配置类，直接返回
if (configCandidates.isEmpty()) {
return;
}
// 9. 处理排序
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
SingletonBeanRegistry sbr = null;
// 10. DefaultListableBeanFactory最终会实现SingletonBeanRegistry接口
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
// 11. spring中可以修改默认的bean命名方式，用户没有改掉默认名时
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 parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
// 12. 保存循环出来得到的那些个等待解析的配置类
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
// 13. 解析配置类（传统意义上的配置类或者是普通bean，核心来了）
parser.parse(candidates);
parser.validate();
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
// 14. 把Import的类，@Bean @ImportRosource 转换成BeanDefinition
// 14.1 AOP通过这里进行注册为BeanDefinition
this.reader.loadBeanDefinitions(configClasses);
// 15. 加入到alreadyParsed，代表configClasses解析完毕
alreadyParsed.addAll(configClasses);
// 16. 循环得到的候选的配置类已经全部解析完毕！
candidates.clear();
// 获得注册器里面BeanDefinition的数量 和 candidateNames进行比较
// 18. 如果大于的话，说明有新的BeanDefinition注册进来了
if (registry.getBeanDefinitionCount() > candidateNames.length) {
// 19. 从注册器里面获得BeanDefinitionNames
String[] newCandidateNames = registry.getBeanDefinitionNames();
// 20. candidateNames转换set
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
// 21. 循环alreadyParsed，把类名加入到alreadyParsedClasses
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
// 22. 判断新来的bean定义是不是配置类
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
// 23. 将新来的配置类加入候选配置类，等待解析
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
// Clear cache in externally provided MetadataReaderFactory; this is a no-op
// for a shared cache since it'll be cleared by the ApplicationContext.
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
在第13点，有关键代码，通过parser类来对配置类进行解析
parse()源码：
public void parse(Set<BeanDefinitionHolder> configCandidates) {
this.deferredImportSelectors = new LinkedList<>();
// 1. 循环要解析的配置类
for (BeanDefinitionHolder holder : configCandidates) {
// 2. 获取配置类的bean定义
BeanDefinition bd = holder.getBeanDefinition();
try {
// 3. 如果是注解bean定义
if (bd instanceof AnnotatedBeanDefinition) {
// 4. 通过注解来解析
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
// 5. 如果是抽象bean定义，并且有bean的类对象
else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
// 6. 通过类对象来解析
parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
}
// 7. 通过bean的类名来解析
else {
parse(bd.getBeanClassName(), holder.getBeanName());
}
} catch (BeanDefinitionStoreException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
}
}
//执行DeferredImportSelector
processDeferredImportSelectors();
}
parse()有三种解析方式
- 根据注解来解析
- 根据类对象来解析
- 根据bean的类名来解析
根据注解解析
parse() —— 解析所有bean定义，找到@Component配置类
protected final void parse(AnnotationMetadata metadata, String beanName) {
processConfigurationClass(new ConfigurationClass(metadata, beanName));
}
protected void processConfigurationClass(ConfigurationClass configClass) {
// 1. 判断是否需要跳过
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {
if (configClass.isImported()) {
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
return;
} else {
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
SourceClass sourceClass = asSourceClass(configClass);
do {
// 2. 重点方法，去处理配置类
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
doProcessConfigurationClass() 在配置类中，解析@ComponentScan、@Import、@propertySource等等
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) {
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// 1. 递归处理内部类，一般不会写内部类
processMemberClasses(configClass, sourceClass);
}
// 2. 解析@PropertySource注解，@PropertySource注解用来加载properties文件
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
} else {
logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// 3. 解析@ComponentScan注解具体的内容，basePackage，includeFilters，excludeFilters等
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
// 4. 有@ComponentScans 并且 不应该跳过
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
// 5. 循环处理componentScans
for (AnnotationAttributes componentScan : componentScans) {
// 6. 扫描配置类，生成包下的 **所有bean定义** 【重要方法】
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// 7. 循环所有bean定义，有可能这些bean定义中又有**配置类**
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
// 8. 递归调用，刚刚扫出来的bean定义又有 **配置类**
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
//处理@Import注解
//@Import注解是spring中很重要的一个注解，Springboot大量应用这个注解
//@Import三种类，一种是Import普通类，一种是Import ImportSelector，还有一种是Import ImportBeanDefinitionRegistrar
//getImports(sourceClass)是获得import的内容，返回的是一个set
processImports(configClass, sourceClass, getImports(sourceClass), true);
// Process any @ImportResource annotations
//处理@ImportResource注解
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
//处理@Bean的方法，可以看到获得了带有@Bean的方法后，不是马上转换成BeanDefinition，而是先用一个set接收
// Process individual @Bean methods
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
processInterfaces(configClass, sourceClass);
// Process superclass, if any
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") &&
!this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse
return sourceClass.getSuperClass();
}
}
// No superclass -> processing is complete
return null;
}
通过==this.componentScanParser.parse()==来解析 ComponentScan 这个组件 —— 获得包路径
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
// 1. 扫描器，这里与构造方法那个扫描器是同一个类，但不是同一个实例
// 所以说构造方法那里创建的类路径bean定义扫描器没啥子用
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(
this.registry,
componentScan.getBoolean("useDefaultFilters"),
this.environment,
this.resourceLoader);
// 2. 判断是否重写了默认的命名规则
Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
BeanUtils.instantiateClass(generatorClass));
ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
scanner.setScopedProxyMode(scopedProxyMode);
}
else {
Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
}
scanner.setResourcePattern(componentScan.getString("resourcePattern"));
// 3. 处理includeFilters，仅仅是加入List而已，没做什么
for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addIncludeFilter(typeFilter);
}
}
// 4. 处理excludeFilters，仅仅是加入List而已，没做什么
for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addExcludeFilter(typeFilter);
}
}
// 5. 懒加载
boolean lazyInit = componentScan.getBoolean("lazyInit");
if (lazyInit) {
scanner.getBeanDefinitionDefaults().setLazyInit(true);
}
Set<String> basePackages = new LinkedHashSet<>();
String[] basePackagesArray = componentScan.getStringArray("basePackages");
for (String pkg : basePackagesArray) {
String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
Collections.addAll(basePackages, tokenized);
}
// 6. 获取包路径
for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
if (basePackages.isEmpty()) {
basePackages.add(ClassUtils.getPackageName(declaringClass));
}
// 7. 添加默认排除规则
// 这里就把注册类自身当作排除规则，真正执行匹配的时候，会把自身给排除
scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
@Override
protected boolean matchClassName(String className) {
return declaringClass.equals(className);
}
});
// 8. 调用扫描器扫描 basePackages
return scanner.doScan(StringUtils.toStringArray(basePackages));
}
调用scanner.doScan(StringUtils.toStringArray(basePackages)) —— 通过包路径，注册所有的bean定义
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
// 1. 循环处理basePackages
for (String basePackage : basePackages) {
// 2. 根据包名找到符合条件的BeanDefinition集合
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
// 3. 返回 **扫描bean定义** ，它实现了抽象Bean 和 注解Bean
if (candidate instanceof AbstractBeanDefinition) {
// 4. 内部会设置默认值
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
// 5. 如果是AnnotatedBeanDefinition，还会再设置一次值
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
- findCandidateComponents() —— 通过类路径获得所有Bean定义
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
// 1. 默认执行这里的方法
return scanCandidateComponents(basePackage);
}
}
- scanCandidateComponents —— 扫描类路径获得所有Bean定义
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
// 1. 将全限定类名转为路径名
// 即：com.xx=>classpath*:com/xx/**/*.class
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
// 2. 根据packageSearchPath，获得符合要求的文件资源
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
// 3. 循环资源
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
// 4. 判断资源是否可读，并且不是一个目录
if (resource.isReadable()) {
try {
// 5. metadataReader 元数据读取器，解析文件资源resource
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
//注册配置类自身会被排除，不会进入到这个if
if (isCandidateComponent(metadataReader)) {
// 6. 封装ScannedGenericBeanDefinition => 扫描Bean定义
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
// 7. 在isCandidateComponent方法内部匹配有没有资格成为一个bean
// 会真正执行匹配规则 【重要！】
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Identified candidate component class: " + resource);
}
candidates.add(sbd);
}
}
}catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
}
}
return candidates;
}
- isCandidateComponent —— 判断类是否有资格称为bean
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
AnnotationMetadata metadata = beanDefinition.getMetadata();
/**
* 1. bean要是一个独立的类或者静态内部类
* 满足1后，满足下列任一要求：
* - 它是一个具体类 【非接口非抽象】
* - 它是一个抽象类并且有@Lookup注解
*/
return (metadata.isIndependent() && (metadata.isConcrete() ||
(metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));
}
解析Import注解
processImports()方法解析Import注解
/**
* 这个方法调用有三种情况：
* 1. Import 普通类
* 2. Import ImportSelector接口
* 3. Import ImportBeanDefinitionRegistrar接口
============================================================================
* 情况一：
* 普通类
* 进入else，调用processConfigurationClass()方法
* 首先，processImports()方法 在processConfigurationClass()方法中被调用的
* 现在，我们在processImports()方法 调用processConfigurationClass()方法，属于递归调用！
* 为什么呢？
* 因为import的普通类，有可能被加了@ComponentScan注解、Import注解等等，所以需要再次解析
* 情况二：
* ImportSelector接口
* 进入第一个if，执行Aware接口方法
* 所以在实现ImportSelector接口时，还可以实现Aware接口
* 调用selectImports方法，获得全限定类名数组，转换成类的数组
* 然后再调用processImports()，属于递归调用！
*
* 情况三：
* ImportBeanDefinitionRegistrar接口
* 进入第二个if，执行Aware接口方法
* 将数据放到一个Map中
*/
private void processImports(ConfigurationClass configClass,
SourceClass currentSourceClass,
Collection<SourceClass> importCandidates,
boolean checkForCircularImports) {
if (importCandidates.isEmpty()) {
return;
}
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
} else {
this.importStack.push(configClass);
try {
for (SourceClass candidate : importCandidates) {
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports
Class<?> candidateClass = candidate.loadClass();
ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
ParserStrategyUtils.invokeAwareMethods(
selector, this.environment, this.resourceLoader, this.registry);
if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
this.deferredImportSelectors.add(
new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
} else {
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
processImports(configClass, currentSourceClass, importSourceClasses, false);
}
} else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
// Candidate class is an ImportBeanDefinitionRegistrar ->
// delegate to it to register additional bean definitions
Class<?> candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar =
BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
ParserStrategyUtils.invokeAwareMethods(
registrar, this.environment, this.resourceLoader, this.registry);
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
} else {
// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
// process it as an @Configuration class
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass));
}
}
} catch (BeanDefinitionStoreException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configClass.getMetadata().getClassName() + "]", ex);
} finally {
this.importStack.pop();
}
}
}
20万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
