解密请求交易串失败,山东历史名人,阳新论坛
上一篇看完了register方法的代码，继续跟后面代码
后面执行refresh方法，代码清单如下：
我要评论public void refresh() throws beansexception, illegalstateexception {
synchronized (this.startupshutdownmonitor) {
// prepare this context for refreshing.
/**
* 准备刷新上下文，设置其启动日期和活动标志以及执行属性源的任何初始化
*/
preparerefresh();
// tell the subclass to refresh the internal bean factory.
/**
* 通知子类刷新内部的 bean 工厂
* 得到创建的 defaultlistablebeanfactory 工厂
* defaultlistablebeanfactory 实现了 configurablelistablebeanfactory
* 接下来对工厂进行初始化
*/
configurablelistablebeanfactory beanfactory = obtainfreshbeanfactory();
// prepare the bean factory for use in this context.
/**
* 配置工厂的标准上下文特征
*/
preparebeanfactory(beanfactory);
try {
// allows post-processing of the bean factory in context subclasses.
/**
* 允许在上下文子类中对 bean 工厂进行后置处理
*
* 当前版本的 spring 代码中没有任何作用，可能是 spring 为了在后面的版本中方便扩展
*/
postprocessbeanfactory(beanfactory);
// invoke factory processors registered as beans in the context.
/**
* 第一重要的方法
*
* 在上下文中调用工厂处理器方法，注册为 bean
* 在 spring 的环境中去执行已经被注册的 beanfactorypostprocessors
* 注册自定义的 beanfactorypostprocessors 和 spring 内部定义的 beanfactorypostprocessors
*
* 比较重要的一个是 configurationclasspostprocessor
* 实例化 annotationconfigapplicationcontext 时初始化了一个 annotatedbeandefinitionreader
* annotatedbeandefinitionreader 的构造方法中将 configurationclasspostprocessor 注册到 beandefinition 中
*/
invokebeanfactorypostprocessors(beanfactory);
// register bean processors that intercept bean creation.
// 注册 beanpostprocessor，spring aop 就是在这里进行注册的
registerbeanpostprocessors(beanfactory);
// initialize message source for this context.
// 初始化此上下文的消息源
initmessagesource();
// initialize event multicaster for this context.
// 初始化应用事件广播器【springboot 的启动源码中与该方法有很大关系】
initapplicationeventmulticaster();
// initialize other special beans in specific context subclasses.
// 在特定的上下文子类中初始化其他特殊 bean
// 当前版本中也是什么都没做
onrefresh();
// check for listener beans and register them.
// 检查监听器 bean 并注册它们
registerlisteners();
// instantiate all remaining (non-lazy-init) singletons.
/**
* 第二重要的方法
*
* 实例化所有剩余（非延迟初始化）单例。
*/
finishbeanfactoryinitialization(beanfactory);
// last step: publish corresponding event.
/**
* 最后一步：发布相应的事件
*/
finishrefresh();
} catch (beansexception ex) {
if (logger.iswarnenabled()) {
logger.warn("exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// destroy already created singletons to avoid dangling resources.
/**
* 摧毁已经创建的单例 bean 以避免悬空资源
*/
destroybeans();
// reset 'active' flag.
/**
* 重置 active 属性值
*/
cancelrefresh(ex);
// propagate exception to caller.
throw ex;
} finally {
// reset common introspection caches in spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetcommoncaches();
}
}
}
这里就只讨论两个比较重要的方法，分别是 invokebeanfactorypostprocessors 方法和 finishbeanfactoryinitialization 方法
public static void invokebeanfactorypostprocessors(configurablelistablebeanfactory beanfactory,
list<beanfactorypostprocessor> beanfactorypostprocessors) {
/**
* 如果有的话，首先调用 beandefinitionregistrypostprocessors
*/
set<string> processedbeans = new hashset<>();
/**
* 如果 beanfactory 是 beandefinitionregistry
*
* beanfactory 是 defaultlistablebeanfactory
* defaultlistablebeanfactory implements configurablelistablebeanfactory, beandefinitionregistry
*/
if (beanfactory instanceof beandefinitionregistry) {
// 转换成 beandefinition 注册器
beandefinitionregistry registry = (beandefinitionregistry) beanfactory;
// bean 工厂后置处理器集合
// 存放手动添加的 beanfactorypostprocessor
list<beanfactorypostprocessor> regularpostprocessors = new arraylist<>();
// beandefinition 注册器后置处理器集合
/**
* beandefinitionregistrypostprocessor 继承了 beanfactorypostprocessor
* 存放所有需要注册的 beandefinitionregistrypostprocessor
*/
list<beandefinitionregistrypostprocessor> registryprocessors = new arraylist<>();
// 循环遍历手动添加的 beanfactorypostprocessor
for (beanfactorypostprocessor postprocessor : beanfactorypostprocessors) {
// 外部扩展的
if (postprocessor instanceof beandefinitionregistrypostprocessor) {
beandefinitionregistrypostprocessor registryprocessor =
(beandefinitionregistrypostprocessor) postprocessor;
// 调用 postprocessbeandefinitionregistry 方法，不是回调
registryprocessor.postprocessbeandefinitionregistry(registry);
// 存入集合
registryprocessors.add(registryprocessor);
}
// spring 内部的
else {
// 存入集合
regularpostprocessors.add(postprocessor);
}
}
/**
* 需要保留所有未初始化的常规 bean，以使 bean 工厂后置处理器适用于这些 bean
* 在实现 priorityordered，ordered 和其余的 beandefinitionregistrypostprocessors 之间分开
*
* 放 spring 内部的 beandefinitionregistrypostprocessor
*/
list<beandefinitionregistrypostprocessor> currentregistryprocessors = new arraylist<>();
/**
* 获取 beandefinitionregistrypostprocessor bean 名称
* beandefinitionregistrypostprocessor 是 beanfactorypostprocessor 的子类
*
* 此时至少包含了一个 configurationclasspostprocessor
* class configurationclasspostprocessor implements beandefinitionregistrypostprocessor
* 名称为 internalconfigurationannotationprocessor
*/
string[] postprocessornames =
beanfactory.getbeannamesfortype(beandefinitionregistrypostprocessor.class, true, false);
/**
* configurationclasspostprocessor 最重要的类
*/
for (string ppname : postprocessornames) {
/**
* 首先，调用实现 priorityordered 的 beandefinitionregistrypostprocessors
*/
if (beanfactory.istypematch(ppname, priorityordered.class)) {
// 实例化该 bean，并添加到集合中
currentregistryprocessors.add(beanfactory.getbean(ppname, beandefinitionregistrypostprocessor.class));
// 添加到集合中
processedbeans.add(ppname);
}
}
// 排序
sortpostprocessors(currentregistryprocessors, beanfactory);
// 合并
registryprocessors.addall(currentregistryprocessors);
/**
* 调用 beandefinitionregistrypostprocessor#postprocessbeandefinitionregistry 方法
*
* 集合中的元素包含 configurationclasspostprocessor
*/
invokebeandefinitionregistrypostprocessors(currentregistryprocessors, registry);
// 执行完成，清空集合数据
// 至少清除包含的 configurationclasspostprocessor
currentregistryprocessors.clear();
// 获取 beandefinitionregistrypostprocessor bean 名称
// 下面的代码理论上不会执行，只是 spring 确保初始化过程中没有新的类被添加进来
postprocessornames = beanfactory.getbeannamesfortype(beandefinitionregistrypostprocessor.class, true, false);
for (string ppname : postprocessornames) {
/**
* 接下来，调用实现 ordered 的 beandefinitionregistrypostprocessors
*
* 不在 processedbeans 中且实现了 ordered 的 beandefinitionregistrypostprocessors
*/
if (!processedbeans.contains(ppname) && beanfactory.istypematch(ppname, ordered.class)) {
// 实例化该 bean，并添加到集合中
currentregistryprocessors.add(beanfactory.getbean(ppname, beandefinitionregistrypostprocessor.class));
// 添加到集合中
processedbeans.add(ppname);
}
}
// 排序
sortpostprocessors(currentregistryprocessors, beanfactory);
// 合并
registryprocessors.addall(currentregistryprocessors);
/**
* 调用 beandefinitionregistrypostprocessor#postprocessbeandefinitionregistry 方法
*/
invokebeandefinitionregistrypostprocessors(currentregistryprocessors, registry);
// 执行完成，清空集合数据
currentregistryprocessors.clear();
/**
* 最后，调用所有其他 beandefinitionregistrypostprocessors
* 直到不再出现其他 beandefinitionregistrypostprocessors
*/
boolean reiterate = true;
while (reiterate) {
reiterate = false;
// 获取 beandefinitionregistrypostprocessor 名称
postprocessornames = beanfactory.getbeannamesfortype(
beandefinitionregistrypostprocessor.class,
true,
false
);
for (string ppname : postprocessornames) {
// 执行剩下的 beandefinitionregistrypostprocessors
if (!processedbeans.contains(ppname)) {
// 实例化该 bean，并添加到集合中
currentregistryprocessors.add(beanfactory.getbean(ppname, beandefinitionregistrypostprocessor.class));
processedbeans.add(ppname);
reiterate = true;
}
}
// 排序
sortpostprocessors(currentregistryprocessors, beanfactory);
// 合并
registryprocessors.addall(currentregistryprocessors);
/**
* 调用 beandefinitionregistrypostprocessor#postprocessbeandefinitionregistry 方法
*/
invokebeandefinitionregistrypostprocessors(currentregistryprocessors, registry);
// 执行完成，清空集合数据
currentregistryprocessors.clear();
}
/**
* 刚才执行完 configurationclasspostprocessor 的回调
* configurationclasspostprocessor implements beandefinitionregistrypostprocessor
* 现在调用到目前为止处理的所有 beanfactorypostprocessor#postprocessbeanfactory 方法的回调
*/
invokebeanfactorypostprocessors(registryprocessors, beanfactory);
invokebeanfactorypostprocessors(regularpostprocessors, beanfactory);
} else {
// invoke factory processors registered with the context instance.
/**
* 调用在上下文实例中注册的工厂处理器
*/
invokebeanfactorypostprocessors(beanfactorypostprocessors, beanfactory);
}
/**
* 获取 beanfactorypostprocessor 名称
* 此时至少有两个元素：
* org.springframework.context.annotation.internalconfigurationannotationprocessor
* org.springframework.context.event.internaleventlistenerprocessor
*
* 需要保留所有未初始化的常规 bean，以使 bean 工厂后处理器适用于这些 bean
*/
string[] postprocessornames =
beanfactory.getbeannamesfortype(beanfactorypostprocessor.class, true, false);
/**
* 分隔实现了 priorityordered，ordered 和其余的 beanfactorypostprocessors
*/
list<beanfactorypostprocessor> priorityorderedpostprocessors = new arraylist<>();
list<string> orderedpostprocessornames = new arraylist<>();
list<string> nonorderedpostprocessornames = new arraylist<>();
for (string ppname : postprocessornames) {
// 处理过则跳过
if (processedbeans.contains(ppname)) {
// skip - already processed in first phase above
}
// 实现了 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 {
// org.springframework.context.event.internaleventlistenerprocessor 是普通类
nonorderedpostprocessornames.add(ppname);
}
}
/**
* 首先，调用实现 priorityordered 的 beanfactorypostprocessors
*/
// 排序
sortpostprocessors(priorityorderedpostprocessors, beanfactory);
// 调用 beanfactorypostprocessor#postprocessbeanfactory 方法
invokebeanfactorypostprocessors(priorityorderedpostprocessors, beanfactory);
/**
* 接下来，调用实现 ordered 的 beanfactorypostprocessors
*/
list<beanfactorypostprocessor> orderedpostprocessors = new arraylist<>(orderedpostprocessornames.size());
for (string postprocessorname : orderedpostprocessornames) {
orderedpostprocessors.add(beanfactory.getbean(postprocessorname, beanfactorypostprocessor.class));
}
// 排序
sortpostprocessors(orderedpostprocessors, beanfactory);
// 调用 beanfactorypostprocessor#postprocessbeanfactory 方法
invokebeanfactorypostprocessors(orderedpostprocessors, beanfactory);
/**
* 最后，调用所有其他 beanfactorypostprocessors
*/
list<beanfactorypostprocessor> nonorderedpostprocessors = new arraylist<>(nonorderedpostprocessornames.size());
for (string postprocessorname : nonorderedpostprocessornames) {
nonorderedpostprocessors.add(beanfactory.getbean(postprocessorname, beanfactorypostprocessor.class));
}
// 调用 beanfactorypostprocessor#postprocessbeanfactory 方法
invokebeanfactorypostprocessors(nonorderedpostprocessors, beanfactory);
/**
* 清除缓存的合并 bean 定义，因为后处理器可能已经修改了原始元数据，例如，替换值中的占位符
*/
beanfactory.clearmetadatacache();
}
这里的 invokebeandefinitionregistrypostprocessors 方法比较重要，跟进去后最后调用的是 processconfigbeandefinitions 方法。
spring将处理 beandefinition 的工作委托给了 configurationclasspostprocessor 这个辅助类来完成
public void processconfigbeandefinitions(beandefinitionregistry registry) {
list<beandefinitionholder> configcandidates = new arraylist<>();
// 获取容器中注册的所有 beandefinition 名称
/**
* annotatedbeandefinitionreader 扫描的 6 个
* 和初始化 spring 上下文环境时传入的一个配置类
*/
string[] candidatenames = registry.getbeandefinitionnames();
/**
* 遍历获取需要解析的类
*/
for (string beanname : candidatenames) {
// 获取 beandefinition
beandefinition beandef = registry.getbeandefinition(beanname);
/**
* 如果 beandefinition 中的 configurationclass 属性为 full 或者 lite，则表示已经处理过了，直接跳过
*/
if (beandef.getattribute(configurationclassutils.configuration_class_attribute) != null) {
if (logger.isdebugenabled()) {
logger.debug("bean definition has already been processed as a configuration class: " + beandef);
}
}
// 否则判断是否是 @configuration 注解配置类，加了则通过校验，没加再判断是否加了以下注解
/**
* 如果加了 @configuration 注解，会在后面再解析其他注解；如果没加，只会单独解析相应的注解
*
* 此时只有传进来的配置类会执行
*/
/**
* candidateindicators.add(component.class.getname());
* candidateindicators.add(componentscan.class.getname());
* candidateindicators.add(import.class.getname());
* candidateindicators.add(importresource.class.getname());
*/
else if (configurationclassutils.checkconfigurationclasscandidate(beandef, this.metadatareaderfactory)) {
// 有的话就添加到 beandefinitionholder 集合中【此时传入的配置类会添加进集合中】
configcandidates.add(new beandefinitionholder(beandef, beanname));
}
}
// 如果没有发现其他的 @configuration 类就立即返回
if (configcandidates.isempty()) {
return;
}
// 按先前确定的 @order 值排序
configcandidates.sort((bd1, bd2) -> {
int i1 = configurationclassutils.getorder(bd1.getbeandefinition());
int i2 = configurationclassutils.getorder(bd2.getbeandefinition());
return integer.compare(i1, i2);
});
// detect any custom bean name generation strategy supplied through the enclosing application context
/**
* 检测通过封闭的应用程序上下文提供的任何自定义 bean 名称生成策略
*/
singletonbeanregistry sbr = null;
/**
* 如果 beandefinitionregistry 是 singletonbeanregistry 的子类
* 传入的是 defaultlistablebeanfactory 是 singletonbeanregistry 的子类
*/
if (registry instanceof singletonbeanregistry) {
// 强转
sbr = (singletonbeanregistry) registry;
// 没有自定义的 name
if (!this.localbeannamegeneratorset) {
// 获取 beanname 生成器
// singletonbeanregistry 中是否包含 beanname 为 internalconfigurationbeannamegenerator 的对象
beannamegenerator generator = (beannamegenerator) sbr.getsingleton(
annotationconfigutils.configuration_bean_name_generator);
// 有则使用，没有则使用 spring 默认的
if (generator != null) {
this.componentscanbeannamegenerator = generator;
this.importbeannamegenerator = generator;
}
}
}
// environment 为空则初始化为 standardenvironment
if (this.environment == null) {
this.environment = new standardenvironment();
}
// parse each @configuration class
// 实例化 configurationclassparser 对象，用于解析每个 @configuration 类
configurationclassparser parser = new configurationclassparser(
this.metadatareaderfactory, this.problemreporter, this.environment,
this.resourceloader, this.componentscanbeannamegenerator, registry);
/**
* 定义两个集合
* candidates 集合用于将之前加入的 configcandidates 进行去重，因为可能有重复的配置类
* alreadyparsed 用于判断是否解析过
*/
set<beandefinitionholder> candidates = new linkedhashset<>(configcandidates);
set<configurationclass> alreadyparsed = new hashset<>(configcandidates.size());
do {
/**
* 解析
*/
parser.parse(candidates);
/**
* 验证
*
* 主要验证 @configuration 的 @bean 方法是否是静态和可覆盖的
* 静态则跳过验证
* @configuration 类中的实例 @bean 方法必须可以覆盖才能容纳cglib
*/
parser.validate();
// 去重
/**
* 此时加了注解的普通类已经注册完成，包括 @configuration 配置类
*/
set<configurationclass> configclasses = new linkedhashset<>(parser.getconfigurationclasses());
// 移除所有已解析的
configclasses.removeall(alreadyparsed);
// read the model and create bean definitions based on its content
// 读取模型并根据其内容创建 beandefinition
if (this.reader == null) {
// 实例化 configurationclassbeandefinitionreader 阅读器，用于创建 beandefinitions
this.reader = new configurationclassbeandefinitionreader(
registry, this.sourceextractor, this.resourceloader, this.environment,
this.importbeannamegenerator, parser.getimportregistry());
}
// 加载 beandefinitions 存入集合中
this.reader.loadbeandefinitions(configclasses);
// 全部标记为已处理
alreadyparsed.addall(configclasses);
// 清空候选者集合，后面保存经过校验存在是配置类的候选者 并且 没有处理过
candidates.clear();
// 处理后工厂内的 beandefinition 数量大于处理前的数量
if (registry.getbeandefinitioncount() > candidatenames.length) {
// 处理后 beanfactory 中 beandefinitionnames 数据
string[] newcandidatenames = registry.getbeandefinitionnames();
// 处理前 beanfactory 中 beandefinitionnames 数据
set<string> oldcandidatenames = new hashset<>(arrays.aslist(candidatenames));
/**
* alreadyparsed + oldcandidatenames = newcandidatenames
*/
set<string> alreadyparsedclasses = new hashset<>();
// 已处理的普通类添加到 alreadyparsedclasses 集合中
for (configurationclass configurationclass : alreadyparsed) {
alreadyparsedclasses.add(configurationclass.getmetadata().getclassname());
}
/**
* 循环遍历处理后的 beandefinitionnames
*/
for (string candidatename : newcandidatenames) {
// 过滤出处理后的候选者中存在于处理前的候选者，即 alreadyparsed 中候选者
// 为什么不直接遍历 alreadyparsed 集合，而是通过这种方式？
// 可能是 spring 怕正在处理的时候，又手动添加了新的需要解析的类
if (!oldcandidatenames.contains(candidatename)) {
beandefinition bd = registry.getbeandefinition(candidatename);
// 再次检查 beandefinition 是否是配置类的候选者 并且 没有处理过
if (configurationclassutils.checkconfigurationclasscandidate(bd, this.metadatareaderfactory) &&
!alreadyparsedclasses.contains(bd.getbeanclassname())) {
candidates.add(new beandefinitionholder(bd, candidatename));
}
}
}
// 标记所有候选者已处理完成
candidatenames = newcandidatenames;
}
}
while (!candidates.isempty());
// register the importregistry as a bean in order to support importaware @configuration classes
/**
* 将 importregistry 注册为 bean 以支持 importaware 的 @configuration类
*/
if (sbr != null && !sbr.containssingleton(import_registry_bean_name)) {
sbr.registersingleton(import_registry_bean_name, parser.getimportregistry());
}
// 如果是 cachingmetadatareaderfactory 的子类，这里会进入判断
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.
// 清除外部提供的 metadatareaderfactory 缓存
// 这是一个无操作的共享缓存，因为它会通过applicationcontext中被清除
((cachingmetadatareaderfactory) this.metadatareaderfactory).clearcache();
}
}
解析的流程委托给了 configurationclassparser 这个类的parser方法来完成
public void parse(set<beandefinitionholder> configcandidates) {
// 此时只有我们传入的配置类这一个元素
// 根据 beandefinition 的类型做不同的处理
for (beandefinitionholder holder : configcandidates) {
// 获取 beandefinition
beandefinition bd = holder.getbeandefinition();
try {
// 是 annotatedbeandefinition 的子类
if (bd instanceof annotatedbeandefinition) {
/**
* 解析注解对象，并存入 map<configurationclass, configurationclass> 集合中
* 但是这里的 beandefinition 是普通的
* 什么是不普通的呢？比如加了 @bean 和各种 beanfactorypostprocessor 得到的 beandefinition 不在这里存放
* 但是在这里解析，只是不存放而已
*/
parse(((annotatedbeandefinition) bd).getmetadata(), holder.getbeanname());
}
// 是 abstractbeandefinition 的子类
else if (bd instanceof abstractbeandefinition && ((abstractbeandefinition) bd).hasbeanclass()) {
parse(((abstractbeandefinition) bd).getbeanclass(), holder.getbeanname());
} 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);
}
}
// 延迟导入处理类，执行流程暂时没跟，但是到后面的代码就重复了
this.deferredimportselectorhandler.process();
}
继续跟 parse 方法，最后执行的是 processconfigurationclass 方法，代码如下：
protected void processconfigurationclass(configurationclass configclass) throws ioexception {
// 判断是否需要跳过
if (this.conditionevaluator.shouldskip(configclass.getmetadata(), configurationphase.parse_configuration)) {
return;
}
/**
* 是否已存在
*
* map<configurationclass, configurationclass> configurationclasses
* 是存放类之间相互引入的关系集合
*/
configurationclass existingclass = this.configurationclasses.get(configclass);
if (existingclass != null) {
// 如果当前类被别的类 @import，则做如下处理
if (configclass.isimported()) {
if (existingclass.isimported()) {
existingclass.mergeimportedby(configclass);
}
// otherwise ignore new imported config class; existing non-imported class overrides it.
// 否则忽略新导入的配置类; 现有的非导入类会覆盖它
return;
} else {
// explicit bean definition found, probably replacing an import.
// let's remove the old one and go with the new one.
// 找到显式 beandefinition，可能替换导入，则删除旧的并使用新的
this.configurationclasses.remove(configclass);
this.knownsuperclasses.values().removeif(configclass::equals);
}
}
// recursively process the configuration class and its superclass hierarchy.
/**
* 递归处理配置类及其超类层次结构
*/
sourceclass sourceclass = assourceclass(configclass);
do {
sourceclass = doprocessconfigurationclass(configclass, sourceclass);
}
while (sourceclass != null);
this.configurationclasses.put(configclass, configclass);
}
这里循环处理配置类，doprocessconfigurationclass 代码如下：
protected final sourceclass doprocessconfigurationclass(configurationclass configclass, sourceclass sourceclass)
throws ioexception {
// 是否加了 @component 注解，@configuration 注解同样适用
if (configclass.getmetadata().isannotated(component.class.getname())) {
// recursively process any member (nested) classes first
/**
* 首先递归处理任何成员（嵌套）类
* 处理内部类
*/
processmemberclasses(configclass, sourceclass);
}
// process any @propertysource annotations
/**
* 处理 @propertysource 注解
*/
for (annotationattributes propertysource : annotationconfigutils.attributesforrepeatable(
sourceclass.getmetadata(), propertysources.class,
org.springframework.context.annotation.propertysource.class)) {
if (this.environment instanceof configurableenvironment) {
processpropertysource(propertysource);
} else {
logger.info("ignoring @propertysource annotation on [" + sourceclass.getmetadata().getclassname() +
"]. reason: environment must implement configurableenvironment");
}
}
// process any @componentscan annotations
/**
* 获取 @componentscan 注解数据
*
* 处理 @componentscan 注解
* 扫描路径下加了 @component 注解的类，并存入 beandefinitionmap 中
*/
set<annotationattributes> componentscans = annotationconfigutils.attributesforrepeatable(
sourceclass.getmetadata(), componentscans.class, componentscan.class);
// 判断是否需要处理
if (!componentscans.isempty() &&
!this.conditionevaluator.shouldskip(sourceclass.getmetadata(), configurationphase.register_bean)) {
// 是个集合，循环遍历
for (annotationattributes componentscan : componentscans) {
// the config class is annotated with @componentscan -> perform the scan immediately
/**
* 扫描 @componentscan 路径下符合过滤器和候选者条件的类
* 转换为 beandefinitionholder，并注册到 beanfactory 中
*
* 可以理解为扫描 @componentscan 路径下加了 @configuration、@component、@service 等的类
*/
set<beandefinitionholder> scannedbeandefinitions =
this.componentscanparser.parse(componentscan, sourceclass.getmetadata().getclassname());
// check the set of scanned definitions for any further config classes and parse recursively if needed
/**
* 检查扫描出来的类当中是否还有 configuration 类
*/
for (beandefinitionholder holder : scannedbeandefinitions) {
// 获取原始 beandefinition
beandefinition bdcand = holder.getbeandefinition().getoriginatingbeandefinition();
if (bdcand == null) {
bdcand = holder.getbeandefinition();
}
// 检查给定的 beandefinition 是否是配置类的候选者
if (configurationclassutils.checkconfigurationclasscandidate(bdcand, this.metadatareaderfactory)) {
parse(bdcand.getbeanclassname(), holder.getbeanname());
}
}
}
}
// process any @import annotations
// springboot 很多 enablexxx 都是基于 @import 注解来实现灵活配置的
/**
* 处理 @import 注解
* 可以引入 @configuration 类，importselector 类，importbeandefinitionregistrar 类
*
* 解析 @import 注解引入的类，importselector 类、importbeandefinitionregistrar 类和 @configuration 类作相应的处理
* importselector 类需要递归处理
* importbeandefinitionregistrar 类存入 map<importbeandefinitionregistrar, annotationmetadata> importbeandefinitionregistrars 集合中
* @configuration 类存入 map<configurationclass, configurationclass> configurationclasses 集合中
*
* importselector 的实现类可以动态实例化一个 beandefinition 到 ioc 容器中
*/
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);
}
}
// process individual @bean methods
// 处理每个 @bean 注解方法
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();
// 排除 java.lang.object 的父类且不存在于 knownsuperclasses 集合中
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 方法和 processimports 方法都是比较重要的方法，尤其是 processimports 方法。springboot很多enablexxx注解都是使用了spring的importbeandefinitionregistrar 这个类来实现动态注册的，这是spring提供的扩展点，以后会写一篇详细的博文和示例来说明，这里就先跳过，跟一下 this.componentscanparser.parse 方法：
public set<beandefinitionholder> parse(annotationattributes componentscan, final string declaringclass) {
/**
* 此时又实例化了一个 classpathbeandefinitionscanner
* 并没有使用 annotationconfigapplicationcontext 构造方法中实例化的 classpathbeandefinitionscanner
*/
classpathbeandefinitionscanner scanner = new classpathbeandefinitionscanner(this.registry,
componentscan.getboolean("usedefaultfilters"), this.environment, this.resourceloader);
// 获取 beanname 生成器
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"));
/**
* 遍历 @componentscan 中的 includefilters
* 获取符合组件扫描的条件的类型
* filter[] includefilters() default {};
*/
for (annotationattributes filter : componentscan.getannotationarray("includefilters")) {
for (typefilter typefilter : typefiltersfor(filter)) {
scanner.addincludefilter(typefilter);
}
}
/**
* 遍历 @componentscan 中的 excludefilters
* 获取不符合组件扫描的条件的类型
* filter[] excludefilters() default {};
*/
for (annotationattributes filter : componentscan.getannotationarray("excludefilters")) {
for (typefilter typefilter : typefiltersfor(filter)) {
scanner.addexcludefilter(typefilter);
}
}
/**
* 获取 @componentscan 中的 lazyinit
* 默认不是懒加载
* 如果是懒加载，则修改 beandefinitiondefaults 的懒加载属性值为 true，而不是修改 beandefinition 的懒加载属性值为 true
* 为后面应用默认值提供便利
* boolean lazyinit() default false;
*/
boolean lazyinit = componentscan.getboolean("lazyinit");
if (lazyinit) {
scanner.getbeandefinitiondefaults().setlazyinit(true);
}
// 去重存储扫描的包路径
set<string> basepackages = new linkedhashset<>();
/**
* 获取 @componentscan 中的 basepackages()
* string[] basepackages() default {};
*/
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);
}
/**
* 获取 @componentscan 中的 basepackageclasses
* class<?>[] basepackageclasses() default {};
*/
for (class<?> clazz : componentscan.getclassarray("basepackageclasses")) {
basepackages.add(classutils.getpackagename(clazz));
}
// 如果没有注明扫描路径，则默认扫描 @configuration 类所在包及其子包
if (basepackages.isempty()) {
basepackages.add(classutils.getpackagename(declaringclass));
}
scanner.addexcludefilter(new abstracttypehierarchytraversingfilter(false, false) {
@override
protected boolean matchclassname(string classname) {
return declaringclass.equals(classname);
}
});
return scanner.doscan(stringutils.tostringarray(basepackages));
}
话不多说，scanner.doscan 方法跟进去就完事了
protected set<beandefinitionholder> doscan(string... basepackages) {
set<beandefinitionholder> beandefinitions = new linkedhashset<>();
// 循环扫描 basepackage 路径下的文件，即 @componentscan 注解的 value 或 basepackages 值
for (string basepackage : basepackages) {
/**
* 加了注解且符合条件则转换为 beandefinition
*
* annotatedgenericbeandefinition 或 scannedgenericbeandefinition
* annotatedgenericbeandefinition 和 scannedgenericbeandefinition 都是 abstractbeandefinition 的子类
* 这里都转换成了 scannedgenericbeandefinition
*/
set<beandefinition> candidates = findcandidatecomponents(basepackage);
for (beandefinition candidate : candidates) {
// 解析 scope 属性
scopemetadata scopemetadata = this.scopemetadataresolver.resolvescopemetadata(candidate);
candidate.setscope(scopemetadata.getscopename());
// 使用 beanname 生成器获取候选者的 beanname
string beanname = this.beannamegenerator.generatebeanname(candidate, this.registry);
/**
* 如果这个类是 abstractbeandefinition 的子类
*
* 此时会进入这个判断
*
* public class scannedgenericbeandefinition extends genericbeandefinition implements annotatedbeandefinition
* public class annotatedgenericbeandefinition extends genericbeandefinition implements annotatedbeandefinition
* public class genericbeandefinition extends abstractbeandefinition
*
* 而被 @componentscan 注解扫描后的类都变成了 scannedgenericbeandefinition 或 annotatedgenericbeandefinition
*
* 基本上都是 abstractbeandefinition 的子类
* 即先将 beandefinitiondefaults 的值赋给候选 beandefinition
*/
if (candidate instanceof abstractbeandefinition) {
/**
* 应用如下默认值：
* setlazyinit(lazyinit);
* setautowiremode(defaults.getautowiremode());
* setdependencycheck(defaults.getdependencycheck());
* setinitmethodname(defaults.getinitmethodname());
* setenforceinitmethod(false);
* setdestroymethodname(defaults.getdestroymethodname());
* setenforcedestroymethod(false);
*/
postprocessbeandefinition((abstractbeandefinition) candidate, beanname);
}
/**
* 如果这个类是 annotatedbeandefinition 的子类
*
* scannedgenericbeandefinition 或 annotatedgenericbeandefinition 也是 annotatedbeandefinition 的子类
*
* 这个判断也会进，即跑完上一步时已经具有了默认值，但是用户可能单独为这个类配置了注解值
* 再将扫描到的注解值赋给候选 beandefinition
*/
if (candidate instanceof annotatedbeandefinition) {
/**
* 处理自定义注解的值
* 包含的注解有 @lazy，@primary，@dependson，@role，@description
*/
annotationconfigutils.processcommondefinitionannotations((annotatedbeandefinition) candidate);
}
/**
* 检查给定候选者的 beanname
*
* 1、是否存在于 beanfactory 中，如果不存在则直接返回为 true
* 2、校验存在的和现有的 beandefinition 是否兼容，兼容则返回 false
* 3、抛异常
*
* 此时刚进行扫描，并没有注册到 beanfactory 中，所以一般会进
*/
if (checkcandidate(beanname, candidate)) {
// 转换为 beandefinitionholder
beandefinitionholder definitionholder = new beandefinitionholder(candidate, beanname);
// 应用代理模式
definitionholder = annotationconfigutils.applyscopedproxymode(scopemetadata, definitionholder, this.registry);
beandefinitions.add(definitionholder);
/**
* 由 bean 的主要名称和别名注册 beandefinition
*
* 将 beandefinition 加入 map<string, beandefinition>【主名】 和 map<string, string>【别名】 集合中
*/
registerbeandefinition(definitionholder, this.registry);
}
}
}
return beandefinitions;
}
而 registerbeandefinition 方法跟进去与我们上一篇探究的代码一样，这里就不再赘述了。
到这里 invokebeanfactorypostprocessors 方法就执行完成了，没执行之前 defaultlistablebeanfactory 中的 beandefinitionmap 中的数据如下
执行完后，我们的@service，@component，@bean，@import等注解类都已经注册到 bean 工厂中
下一篇解析 refresh 中另一个重要的方法 finishbeanfactoryinitialization
在spring的方法名中包含了很多 initialization 和 instantiation 这两个单词，一个是初始化，一个是实例化
beanpostprocessor 的直接实现类能够干预 bean 的初始化过程，比如 applicationcontextawareprocessor
beanpostprocessor 的继承类能够干预 bean 的实例化过程，比如 smartinstantiationawarebeanpostprocessor
这个先提一下，以后再详细说，希望坚持写下去。
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
浅析我对 String、StringBuilder、StringBuffer 的理解
使用IDEA搭建SSM框架的详细教程(spring + springMVC +MyBatis)
Springboot整合freemarker 404问题解决方案
引入mybatis-plus报 Invalid bound statement错误问题的解决方法
网友评论