Spring 5 AutowireCapableBeanFactory – resolveDependency源码分析(一)
Spring 5 AutowireCapableBeanFactory – resolveDependency源码分析(二)
相关源码注释
ApplicationContext
Spring 5 DefaultResourceLoader 源码注释
Spring 5 AbstractApplicationContext 源码注释
BeanFactory
Spring 5 SimpleAliasRegistry 源码注释
Spring 5 DefaultSingletonBeanRegistry 源码注释
Spring 5 FactoryBeanRegistrySupport 源码注释
Spring 5 AbstractBeanFactory 源码注释
Spring 5 AbstractAutowireCapableBeanFactory 源码注释
Spring 5 DefaultLisbaleBeanFactory 源码注释
resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
针对desciptor所包装的对象类型是[stream,数组,Collection类型且对象类型是接口,Map]的情况,进行解析与依赖类型匹配的 候选Bean对象,并将其封装成相应的依赖类型对象:
- 获取包装的参数/字段的声明的(非通用)类型【变量 type】
- 【当decriptor所包装的对象是Stream类型】:
- 如果描述符是Stream依赖项描述符:
- 查找与valueType匹配的候选bean对象;构建成Map,key=bean名,val=Bean对象【变量 matchingBeans】
- 自动注入匹配成功的候选Bean名集合不为null,将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
- 取出除Bean对象为NullBean以外的所有候选Bean名称的Bean对象【变量 stream】
- 如果decriptor需要排序,根据matchingBean构建排序比较器,交由steam进行排序
- 返回已排好序且已存放除Bean对象为NullBean以外的所有候选Bean名称的Bean对象的stream对象【变量 stream】
- 如果描述符是Stream依赖项描述符:
- 【当decriptor所包装的对象是数组类型】:
- 如果依赖类型是数组类型:
- 获取type的元素Class对象【变量 componentType】
- 获取decriptor包装的参数/字段所构建出来的ResolvableType对象【变量 resolvableType】
- 让resolvableType解析出的对应的数组Class对象,如果解析失败,就引用type【变量 resolvedArrayType】
- 如果resolvedArrayType与type不是同一个Class对象,componentType就引用resolvableType解析处理的元素Class对象
- 如果没有元素Class对象,就返回null,表示获取不到候选bean对象
- 查找与valueType匹配的候选bean对象;构建成Map,key=bean名,val=Bean对象【变量 matchingBeans】
- 如果没有候选Bean对象,返回null,表示获取不到候选bean对象
- 自动注入匹配成功的候选Bean名集合不为null,将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
- 如果有传入类型转换器就引用传入的类型转换器,否则获取此BeanFactory使用的类型转换器
- 将所有候选Bean对象转换为resolvedArrayType类型【变量 result】
- 如果result是数组实例:
- 构建依赖比较器,用于对matchingBean的所有bean对象进行优先级排序【变量 comparator】
- 如果比较器不为null,使用comparator对result数组进行排序
- 返回该候选对象数组【result】
- 如果依赖类型是数组类型:
- 【如果依赖类型属于Collection类型 且 依赖类型是否接口】:
- 将descoptor所包装的参数/字段构建出来的ResolvableType对象解析成Collectionl类型,然后解析出其 泛型参数的Class对象【变量 elementType】
- 如果元素类型为null,返回null,表示获取不到候选bean对象
- 查找与valueType匹配的候选bean对象;构建成Map,key=bean名,val=Bean对象【变量 matchingBeans】
- 如果没有候选bean对象,返回null,表示获取不到候选bean对象
- 自动注入匹配成功的候选Bean名集合不为null,将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
- 如果有传入类型转换器就引用传入的类型转换器,否则获取此BeanFactory使用的类型转换器
- 将所有候选Bean对象转换为resolvedArrayType类型【变量 result】
- 如果result是List实例:
- 构建依赖比较器,用于对matchingBean的所有bean对象进行优先级排序【变量 comparator】
- 如果比较器不为null,使用comparator对result数组进行排序
- 返回该候选对象数组【result】
- 【如果依赖类型是Map类型】:
- 将descoptor所包装的参数/字段构建出来的ResolvableType对象解析成Map类型【变量 mapType】
- 解析出第1个泛型参数的Class对象,即key的Class对象【变量 keyType】
- 如果keyType不是String类型,返回null,表示获取不到候选bean对象
- 解析出第2个泛型参数的Class对象,即value的Class对象【变量 valueType】
- 如果keyType为null,即解析不出value的Class对象或者是根本没有value的Class对象, 返回null,表示获取不到候选bean对象
- 查找与valueType匹配的候选bean对象;构建成Map,key=bean名,val=Bean对象【变量 matchingBeans】
- 如果没有候选bean对象,返回null,表示获取不到候选bean对象
- 自动注入匹配成功的候选Bean名集合不为null,将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
- 返回候选的Bean对象Map【matchingBeans】
/**
* 针对desciptor所包装的对象类型是[stream,数组,Collection类型且对象类型是接口,Map]的情况,进行解析与依赖类型匹配的
* 候选Bean对象,并将其封装成相应的依赖类型对象
* @param descriptor 依赖项的描述符(字段/方法/构造函数)
* @param beanName 声明给定依赖项的bean名
* @param autowiredBeanNames 一个集合,所有自动装配的bean名(用于解决给定依赖关系)都应添加.即自动注入匹配成功的候选Bean名集合。
* 【当autowiredBeanNames不为null,会将所找到的所有候选Bean对象添加到该集合中,以供调用方使用】
* @param typeConverter 用于填充数组和集合的TypeConverter
* @return 由候选Bean对象组成对象,该对象与descriptor的依赖类型相同;如果descriptor的依赖类型不是
* [stream,数组,Collection类型且对象类型是接口,Map],又或者解析不出相应的依赖类型,又或者拿不到候选Bean对象都会导致返回null
*/
@Nullable
private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {
//获取包装的参数/字段的声明的(非通用)类型
final Class<?> type = descriptor.getDependencyType();
//如果描述符是Stream依赖项描述符
if (descriptor instanceof StreamDependencyDescriptor) {
//查找与valueType匹配的候选bean对象;构建成Map,key=bean名,val=Bean对象
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
//自动注入匹配成功的候选Bean名集合不为null
if (autowiredBeanNames != null) {
//将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
autowiredBeanNames.addAll(matchingBeans.keySet());
}
//取出除Bean对象为NullBean以外的所有候选Bean名称的Bean对象
Stream<Object> stream = matchingBeans.keySet().stream()
.map(name ->
//将name解析为该Bean工厂的Bean实例
descriptor.resolveCandidate(name, type, this))
//只要收集bean对象不为NullBean对象
.filter(bean -> !(bean instanceof NullBean));
//如果decriptor需要排序
if (((StreamDependencyDescriptor) descriptor).isOrdered()) {
//根据matchingBean构建排序比较器,交由steam进行排序
stream = stream.sorted(adaptOrderComparator(matchingBeans));
}
//返回已排好序且已存放除Bean对象为NullBean以外的所有候选Bean名称的Bean对象的stream对象
return stream;
}
//如果依赖类型是数组类型
else if (type.isArray()) {
//获取type的元素Class对象
Class<?> componentType = type.getComponentType();
//获取decriptor包装的参数/字段所构建出来的ResolvableType对象
ResolvableType resolvableType = descriptor.getResolvableType();
//让resolvableType解析出的对应的数组Class对象,如果解析失败,就引用type
Class<?> resolvedArrayType = resolvableType.resolve(type);
//如果resolvedArrayType与type不是同一个Class对象
if (resolvedArrayType != type) {
//componentType就引用resolvableType解析处理的元素Class对象
componentType = resolvableType.getComponentType().resolve();
}
//如果没有元素Class对象,就返回null,表示获取不到候选bean对象
if (componentType == null) {
return null;
}
//MultiElemetDesciptor:具有嵌套元素的多元素声明的依赖描述符,表示集合/数组依赖
//查找与valueType匹配的候选bean对象;构建成Map,key=bean名,val=Bean对象
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
new MultiElementDescriptor(descriptor));
//如果没有候选Bean对象
if (matchingBeans.isEmpty()) {
//返回null,表示获取不到候选bean对象
return null;
}
//自动注入匹配成功的候选Bean名集合不为null
if (autowiredBeanNames != null) {
//将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
autowiredBeanNames.addAll(matchingBeans.keySet());
}
//如果有传入类型转换器就引用传入的类型转换器,否则获取此BeanFactory使用的类型转换器
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
//将所有候选Bean对象转换为resolvedArrayType类型
Object result = converter.convertIfNecessary(matchingBeans.values(), resolvedArrayType);
//如果result是数组实例
if (result instanceof Object[]) {
//构建依赖比较器,用于对matchingBean的所有bean对象进行优先级排序
Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
//如果比较器不为null
if (comparator != null) {
//使用comparator对result数组进行排序
Arrays.sort((Object[]) result, comparator);
}
}
//返回该候选对象数组
return result;
}
//如果依赖类型属于Collection类型 且 依赖类型是否接口
else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
//将descoptor所包装的参数/字段构建出来的ResolvableType对象解析成Collectionl类型,然后
// 解析出其泛型参数的Class对象
Class<?> elementType = descriptor.getResolvableType().asCollection().resolveGeneric();
//如果元素类型为null
if (elementType == null) {
//返回null,表示获取不到候选bean对象
return null;
}
//查找与valueType匹配的候选bean对象;构建成Map,key=bean名,val=Bean对象
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType,
new MultiElementDescriptor(descriptor));
//如果没有候选bean对象,
if (matchingBeans.isEmpty()) {
//返回null,表示获取不到候选bean对象
return null;
}
//自动注入匹配成功的候选Bean名集合不为null
if (autowiredBeanNames != null) {
//将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
autowiredBeanNames.addAll(matchingBeans.keySet());
}
//如果有传入类型转换器就引用传入的类型转换器,否则获取此BeanFactory使用的类型转换器
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
//将所有候选Bean对象转换为resolvedArrayType类型
Object result = converter.convertIfNecessary(matchingBeans.values(), type);
//如果result是List实例
if (result instanceof List) {
//构建依赖比较器,用于对matchingBean的所有bean对象进行优先级排序
Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
//如果比较器不为null
if (comparator != null) {
//使用comparator对result数组进行排序
((List<?>) result).sort(comparator);
}
}
//返回该候选对象数组
return result;
}
//如果依赖类型是Map类型
else if (Map.class == type) {
//将descoptor所包装的参数/字段构建出来的ResolvableType对象解析成Map类型
ResolvableType mapType = descriptor.getResolvableType().asMap();
//解析出第1个泛型参数的Class对象,即key的Class对象
Class<?> keyType = mapType.resolveGeneric(0);
//如果keyType不是String类型
if (String.class != keyType) {
//返回null,表示获取不到候选bean对象
return null;
}
//解析出第2个泛型参数的Class对象,即value的Class对象
Class<?> valueType = mapType.resolveGeneric(1);
//如果keyType为null,即解析不出value的Class对象或者是根本没有value的Class对象
if (valueType == null) {
//返回null,表示获取不到候选bean对象
return null;
}
//查找与valueType匹配的候选bean对象;构建成Map,key=bean名,val=Bean对象
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType,
new MultiElementDescriptor(descriptor));
//如果没有候选bean对象
if (matchingBeans.isEmpty()) {
//返回null,表示获取不到候选bean对象
return null;
}
//自动注入匹配成功的候选Bean名集合不为null
if (autowiredBeanNames != null) {
//将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
autowiredBeanNames.addAll(matchingBeans.keySet());
}
//返回候选的Bean对象Map
return matchingBeans;
}
else {
//返回null,表示获取不到候选bean对象
return null;
}
}
StreamDependencyDescriptor
用于访问多个元素的流依赖项描述符标记,一般表示stream类型依赖
/**
* A dependency descriptor marker for stream access to multiple elements.
* <p>用于访问多个元素的流依赖项描述符标记,一般表示stream类型依赖</p>
*/
private static class StreamDependencyDescriptor extends DependencyDescriptor {
/**
* 是否需要排序标记
*/
private final boolean ordered;
/**
* 新建一个StreamDependencyDescriptor实例
* @param original 从其创建副本的原始描述符
* @param ordered 是否需要排序标记
*/
public StreamDependencyDescriptor(DependencyDescriptor original, boolean ordered) {
//拷贝originald的属性
super(original);
this.ordered = ordered;
}
/**
* 是否需要排序
*/
public boolean isOrdered() {
return this.ordered;
}
}
findAutowireCandidates(beanName, type, descriptor);
查找与type匹配的候选bean对象,构建成Map,key=bean名,val=Bean对象【在自动装配指定bean期间调用】:
- 获取requiredType的所有bean名,包括父级工厂中定义的名称【变量 candidateNames】
- 定义用于保存匹配requiredType的bean名和其实例对象的Map,即匹配成功的候选Map【变量 result】
- 【从 存放着手动显示注册的依赖项类型-相应的自动装配值的缓存【resolvableDependencies】中匹配候选】:
- 遍历resolvableDependencies,元素classObjectEntry:
- 取出依赖项类型【变量 autowiringType】
- 如果autowiringType是属于requiredType的实例:
- 取出autowiringType对应的实例对象【变量 autowiringValue】
- 根据requiredType解析autowiringValue,并针对autowiringValue是ObjectFactory的情况进行解析,将解析出来的值 重新赋值给autowiringValue
- 如果autowiringValue是requiredType类型,就根据autowiringValue构建出唯一 ID与autowiringValue绑定到result中,然后跳槽循环
- 遍历resolvableDependencies,元素classObjectEntry:
- 【常规匹配候选(beanDefinition是否允许依赖注入,泛型类型是否匹配,限定符注解 /限定符信息是否匹配)】:
- 遍历candidateNames,元素candidate:
- 如果beanName与candidateName所对应的Bean对象不是同一个且candidate可以自动注入, 添加一个条目在result中:一个bean实例(如果可用)或仅一个已解析的类型
- 遍历candidateNames,元素candidate:
- 【找不到候选时,就采用将回退模式(在回退模式下,候选Bean具有无法解析的泛型 || 候选Bean的Class 对象是Properties类对象时,都允许成为该描述符的可自动注入对象)尽可能的匹配到候选,一般情况 下不会出现回退情况,除非代码非常糟糕】:
- 如果result为空:
- requiredType是否是数组/集合类型的标记【变量multiple】
- 获取desciptord的一个旨在用于回退匹配变体【遍历 fallbackDescriptor】
- 【先尝试匹配候选bean名符合允许回退匹配的依赖描述符的自动依赖条件且(依赖类型不是集合/数组 或者描述符指定限定符)的候选Bean对象】:
- 遍历candidateNames,元素candidate:
- 如果beanName与candidateName所对应的Bean对象不是同一个 且 candidate可以自动注入 且 (type不是数组/集合类型或者 desciptor有@Qualifier注解或qualifier标准修饰), 就添加一个条目在result中:一个bean实例(如果可用)或仅一个已解析的类型
- 遍历candidateNames,元素candidate:
- 【降低匹配精度:满足下面条件即可】【除beanName符合描述符依赖类型不是数组/集合,beanName与candidateName所对应的Bean对象不是同一个,descriptor不是集合依赖或者beanName与candidate不相同,候选bean名符合允许回退匹配的依赖描述符的自动依赖条件】
- 如果result为空且requiredType不是数组/集合类型或者
- 遍历candidateNames,元素candidate:
- 如果beanName与candidateName所对应的Bean对象不是同一个 且 (descriptor不是 MultiElementDescriptor实例(即集合依赖)或者beanName不等于candidate) 且 candidate可以自动注入,添加一个条目在result中:一个bean实例(如果可用) 或仅一个已解析的类型
- 如果result为空:
- 返回匹配成功的后续Bean对象【result】
/**
* <p>存放着手动显示注册的依赖项类型-相应的自动装配值的缓存</p>
* <p>手动显示注册指直接调用{@link #registerResolvableDependency(Class, Object)}</p>
* Map from dependency type to corresponding autowired value.
* <p>从依赖项类型映射到相应的自动装配值</p>
* */
private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);
/**
* <p>查找与type匹配的候选bean对象,构建成Map,key=bean名,val=Bean对象【在自动装配指定bean期间调用】
* </p>
* Find bean instances that match the required type.
* Called during autowiring for the specified bean.
* <p>查找与所需类型匹配的bean实例。在自动装配指定bean期间调用</p>
* @param beanName the name of the bean that is about to be wired
* -- 即将被连线的bean名,要依赖的bean名(不是指desciptor的所包装的Field/MethodParamater的依赖类型的bean名,
* 而是指需要Field/MethodParamter所对应的bean对象来构建的Bean对象的Bean名)
* @param requiredType the actual type of bean to look for
* (may be an array component type or collection element type)
* -- 要查找的bean的实际类型(可以是数组组件或集合元素类型),descriptor的依赖类型
* @param descriptor the descriptor of the dependency to resolve
* -- 要解析的依赖项的描述符
* @return a Map of candidate names and candidate instances that match
* the required type (never {@code null})
* -- 匹配所需类型的候选名称和候选实例的映射(从不为null)
* @throws BeansException in case of errors -- 如果有错误
* @see #autowireByType
* @see #autowireConstructor
*/
protected Map<String, Object> findAutowireCandidates(
@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
//获取requiredType的所有bean名,包括父级工厂中定义的名称
String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this, requiredType, true, descriptor.isEager());
//定义用于保存匹配requiredType的bean名和其实例对象的Map,即匹配成功的候选Map
Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
//从 存放着手动显示注册的依赖项类型-相应的自动装配值的缓存 中匹配候选
//遍历 从依赖项类型映射到相应的自动装配值缓存
for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
//取出依赖项类型
Class<?> autowiringType = classObjectEntry.getKey();
//如果autowiringType是属于requiredType的实例
if (autowiringType.isAssignableFrom(requiredType)) {
//取出autowiringType对应的实例对象
Object autowiringValue = classObjectEntry.getValue();
//根据requiredType解析autowiringValue,并针对autowiringValue是ObjectFactory的情况进行解析
autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
//如果autowiringValue是requiredType类型
if (requiredType.isInstance(autowiringValue)) {
//objectUtils.identityToString:可得到(obj的全类名+'@'+obj的hashCode的十六进制字符串),如果obj为null,返回空字符串
//根据autowiringValue构建出唯一ID与autowiringValue绑定到result中
result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
//跳槽循环
break;
}
}
}
//常规匹配候选
//遍历candidateNames
for (String candidate : candidateNames) {
//如果beanName与candidateName所对应的Bean对象不是同一个 且 candidate可以自动注入
if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
//添加一个条目在result中:一个bean实例(如果可用)或仅一个已解析的类型
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
//找不到候选时,就采用将回退模式尽可能的匹配到候选,一般情况下不会出现回退情况,除非代码非常糟糕
//result为空
if (result.isEmpty()) {
//requiredType是否是数组/集合类型的标记
boolean multiple = indicatesMultipleBeans(requiredType);
// Consider fallback matches if the first pass failed to find anything...
// 如果第一遍未找到任何内容,请考虑进行回退匹配
// 在允许回退的情况下,候选Bean具有无法解析的泛型 || 候选Bean的Class对象是Properties类对象时,
// 都允许成为 该描述符的可自动注入对象
//获取desciptord的一个旨在用于回退匹配变体
DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
//先尝试匹配候选bean名符合允许回退匹配的依赖描述符的自动依赖条件且(依赖类型不是集合/数组或者描述符指定限定符)的候选Bean对象
//遍历candidateNames
for (String candidate : candidateNames) {
//getAutowireCandidateResolver()得到是QualifierAnnotationAutowireCandidateResolver实例,hasQualifier方法才有真正的限定符语义。
//如果beanName与candidateName所对应的Bean对象不是同一个 且 candidate可以自动注入 且 (type不是数组/集合类型或者
// desciptor有@Qualifier注解或qualifier标准修饰)
if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
//添加一个条目在result中:一个bean实例(如果可用)或仅一个已解析的类型
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
//匹配 除beanName符合描述符依赖类型不是数组/集合
// 且 如果beanName与candidateName所对应的Bean对象不是同一个
// 且 (descriptor不是集合依赖或者beanName与candidate不相同)
// 且 候选bean名符合允许回退匹配的依赖描述符的自动依赖条件
//如果result为空且requiredType不是数组/集合类型或者
if (result.isEmpty() && !multiple) {
// Consider self references as a final pass...
// but in the case of a dependency collection, not the very same bean itself.
// 将自我推荐视为最终通过
// 但是对于依赖项集合,不是相同的bean本身
//遍历candidateNames
for (String candidate : candidateNames) {
//如果beanName与candidateName所对应的Bean对象不是同一个 且 (descriptor不是MultiElementDescriptor实例(即集合依赖)或者
// beanName不等于candidate) 且 candidate可以自动注入
if (isSelfReference(beanName, candidate) &&
(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
isAutowireCandidate(candidate, fallbackDescriptor)) {
///添加一个条目在result中:一个bean实例(如果可用)或仅一个已解析的类型
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
}
}
return result;
}
BeanFactoryUtils.beanNamesForTypeIncludingAncestors
获取给定类型的所有bean名,包括父级工厂中定义的名称:
- 如果lbf为null,抛出异常
- 获取与type(包括子类)匹配的bean名称【变量 result】,根据includeNonSingletons来决定是否包含原型+单例 还是 只包含单例,根据allowEargerInit决定是否初始化lazy-init单例和由FactoryBeans创建的对象 以进行类型检查
- 如果lbf是HierarchicalBeanFactory:
- 将lbf强转HierarchicalBeanFactory对象【变量 hbf】
- 如果hbf的父工厂是LisableBeanFactory对象:
- 递归该方法获取父工厂里type的所有bean名,包括父级工厂中定义的名称
- 将result结果与parentResult合并重新赋值给result
- 返回result
/**
* <p>获取给定类型的所有bean名,包括父级工厂中定义的名称 </p>
* Get all bean names for the given type, including those defined in ancestor
* factories. Will return unique names in case of overridden bean definitions.
* <p>获取给定类型的所有bean名,包括父级工厂中定义的名称。如果覆盖了BeanDefinition,
* 将返回唯一名称</p>
* <p>Does consider objects created by FactoryBeans if the "allowEagerInit"
* flag is set, which means that FactoryBeans will get initialized. If the
* object created by the FactoryBean doesn't match, the raw FactoryBean itself
* will be matched against the type. If "allowEagerInit" is not set,
* only raw FactoryBeans will be checked (which doesn't require initialization
* of each FactoryBean).
* <p>如果设置了'allowEagerInit'标记,是否考虑了由FactoryBeans创建的对象,这意味着将
* 初始化FactoryBeans。如果与FactoryBean创建的对象不匹配,则原始FactoryBean本身将
* 与该类型匹配.如果未设置'allowEagerInit',将仅检查原始FactoryBean(不需要初始化每个
* FactoryBean)</p>
* @param lbf the bean factory -- bean工厂
* @param includeNonSingletons whether to include prototype or scoped beans too
* or just singletons (also applies to FactoryBeans)
* -- 是否也包含原始或范围内的bean还是仅包含单例(也适用于FactoryBeans)
* @param allowEagerInit whether to initialize <i>lazy-init singletons</i> and
* <i>objects created by FactoryBeans</i> (or by factory methods with a
* "factory-bean" reference) for the type check. Note that FactoryBeans need to be
* eagerly initialized to determine their type: So be aware that passing in "true"
* for this flag will initialize FactoryBeans and "factory-bean" references.
* -- 是否初始化lazy-init单例和由FactoryBeans(或带有"factory-bean"引用的工厂方法)创建
* 的对象以进行类型检查。注意,必须急切初始化FactoryBean以确定它们的类型:因此请注意,
* 为此标志传递'true'将初始化FactoryBean和'factory-bean'引用
* @param type the type that beans must match -- bean必须匹配的类型
* @return the array of matching bean names, or an empty array if none
* @see ListableBeanFactory#getBeanNamesForType(Class, boolean, boolean)
*/
public static String[] beanNamesForTypeIncludingAncestors(
ListableBeanFactory lbf, Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
//如果bean工厂为null,抛出异常
Assert.notNull(lbf, "ListableBeanFactory must not be null");
//获取与type(包括子类)匹配的bean名称,根据includeNonSingletons来决定是否包含原型+单例 还是 只包含单例,根据allowEargerInit
// 决定是否初始化lazy-init单例和由FactoryBeans创建的对象以进行类型检查
String[] result = lbf.getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
//HierarchicalBeanFactory 提供父容器的访问功能
//如果lbf是HierarchicalBeanFactory
if (lbf instanceof HierarchicalBeanFactory) {
//将lbf强转HierarchicalBeanFactory对象
HierarchicalBeanFactory hbf = (HierarchicalBeanFactory) lbf;
//ListableBeanFactory:扩展BeanFactory使其支持迭代Ioc容器持有的Bean对象。注意如果
// ListableBeanFactory同时也是HierarchicalBeanFactory,那么大多数情况下,
// 只迭代当前Ioc容器持有的Bean对象,不会在体系结构中想父级递归迭代
//如果hbf的父工厂是LisableBeanFactory对象
if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
//递归该方法获取父工厂里type的所有bean名,包括父级工厂中定义的名称
String[] parentResult = beanNamesForTypeIncludingAncestors(
(ListableBeanFactory) hbf.getParentBeanFactory(), type, includeNonSingletons, allowEagerInit);
//将result结果与parentResult合并
result = mergeNamesWithParent(result, parentResult, hbf);
}
}
return result;
}
/**
* <p>将给定的bean名结果与给定的父结果合并:
* <ol>
* <li>如果parentResult是空数组,直接返回result</li>
* <li>定义一个合并后的bean名结果集,初始化长度为result数组长度+parentResult数组长度【变量 merged】</li>
* <li>将result全部添加到merged中</li>
* <li>遍历parentResult,元素为beanName:
* <ol>
* <li>如果merged没包含beanName 且 hbf没包含给定beanName时,将beanName添加到merged中</li>
* </ol>
* </li>
* <li>将merged装换成数组返回出去</li>
* </ol>
* </p>
* Merge the given bean names result with the given parent result.
* <p>将给定的bean名结果与给定的父结果合并</p>
* @param result the local bean name result -- 本地bean名结果
* @param parentResult the parent bean name result (possibly empty) -- 父bean名称结果(可能为空)
* @param hbf the local bean factory -- 本地bean工厂
* @return the merged result (possibly the local result as-is) -- 合并结果(可能是本地结果)
* @since 4.3.15
*/
private static String[] mergeNamesWithParent(String[] result, String[] parentResult, HierarchicalBeanFactory hbf) {
//如果parentResult是空数组,直接返回result
if (parentResult.length == 0) {
return result;
}
//定义一个合并后的bean名结果集,初始化长度为result数组长度+parentResult数组长度
List<String> merged = new ArrayList<>(result.length + parentResult.length);
//将result全部添加到merged中
merged.addAll(Arrays.asList(result));
//遍历parentResult
for (String beanName : parentResult) {
//如果merged没包含beanName 且 hbf没包含给定beanName
if (!merged.contains(beanName) && !hbf.containsLocalBean(beanName)) {
//将beanName添加到merged中
merged.add(beanName);
}
}
//将merged装换成数组返回出去
return StringUtils.toStringArray(merged);
}
ObjectUtils.identityToString(autowiringValue)
可得到(obj的全类名+’@’+obj的hashCode的十六进制字符串),如果obj为null,返回空字符串
/**
* <p>可得到(obj的全类名+'@'+obj的hashCode的十六进制字符串),如果obj为null,返回空字符串</p>
* Return a String representation of an object's overall identity.
* <p>返回对象整体身份的String表现形式</p>
* @param obj the object (may be {@code null}) -- 对象(可以为{@code null})
* @return the object's identity as String representation,
* or an empty String if the object was {@code null}
* -- 对象的身份,以String表现形式;如果对象为{@code null}则为空字符串
*/
public static String identityToString(@Nullable Object obj) {
//如果对象为null
if (obj == null) {
//返回 空字符串
return EMPTY_STRING;
}
//拼接obj的全类名+'@'+obj的hashCode的十六进制字符串,然后返回出去
return obj.getClass().getName() + "@" + getIdentityHexString(obj);
}
isSelfReference(beanName, candidate)
可以理解为beanName与candidateName所对应的Bean对象是不是同一个
/**
* <p>可以理解为beanName与candidateName所对应的Bean对象是不是同一个</p>
* <p>自引用:beanName和candidateName是否都是指向同一个Bean对象,至少beanName所指bean对象是candidateName的合并后
* RootBeanDefinition对象里的FactoryBean对象</p>
* Determine whether the given beanName/candidateName pair indicates a self reference,
* i.e. whether the candidate points back to the original bean or to a factory method
* on the original bean.
* <p>确定给定beanName/candidateName Pair 是否表示自引用,即候选对象是指向原始bean
* 或者指向原始bean的工厂方法</p>
*/
private boolean isSelfReference(@Nullable String beanName, @Nullable String candidateName) {
//如果beanName和candidateName都不会null
// 且 beanName与candidateName相等 或者 (该工厂有candidateName的BeanDefinition对象 且 candidateName的合并后BeanDefinition对象的FactoryBean名与beanName相等)
return (beanName != null && candidateName != null &&
(beanName.equals(candidateName) || (containsBeanDefinition(candidateName) &&
beanName.equals(getMergedLocalBeanDefinition(candidateName).getFactoryBeanName()))));
}
isAutowireCandidate(candidate, descriptor)
Spring 5 DefaultListableBeanFactory-- isAutowireCandidate源码分析
AutowireCandidateResolver
addCandidateEntry(result, candidate, descriptor, requiredType);
在候选映射中添加一个条目:一个bean实例(如果可用)或仅一个已解析的类型,以防止在选择主要候选对象之前太早初始化bean:
- 如果desciprtor是MultiElementDescriptor的实例【集合类型依赖】:
- 获取candidateName的该工厂的Bean实例【变量 beanInstance】
- 如果beanInstance不是NullBean实例,将candidateName和其对应的实例绑定到candidates中
- 如果beanName是在该BeanFactory的单例对象的高速缓存Map集合中 或者 (descriptor是SteamDependencyDesciptor实例【Stream类型依赖】且 该实例有排序标记):
- 获取candidateName的该工厂的Bean实例【变量 beanInstance】
- 如果beanInstance是NullBean实例,会将candidateName和null绑定到candidates中;否则将candidateName和其对应的实例绑定到candidates中
- 否则(一般就是指candidatName所对应的bean不是单例):将candidateName和其对应的Class对象绑定到candidates中
/**
* <p>
* 在候选映射中添加一个条目:一个bean实例(如果可用)或仅一个已解析的类型,以防止在选择主要
* 候选对象之前太早初始化bean:
* </p>
* Add an entry to the candidate map: a bean instance if available or just the resolved
* type, preventing early bean initialization ahead of primary candidate selection.
* <p>在候选映射中添加一个条目:一个bean实例(如果可用)或仅一个已解析的类型,以防止在选择主要
* 候选对象之前太早初始化bean</p>
*/
private void addCandidateEntry(Map<String, Object> candidates, String candidateName,
DependencyDescriptor descriptor, Class<?> requiredType) {
//MultiElementDesciptor:具有嵌套元素的多元素声明的依赖描述符,表示集合/数组依赖
//如果desciprtor是MultiElementDescriptor的实例
if (descriptor instanceof MultiElementDescriptor) {
//获取candidateName的该工厂的Bean实例
Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
//如果beanInstance不是NullBean实例
if (!(beanInstance instanceof NullBean)) {
//将candidateName和其对应的实例绑定到candidates中
candidates.put(candidateName, beanInstance);
}
}
//StreamDependencyDescriptor:用于访问多个元素的流依赖项描述符标记,即属性依赖是 stream类型且
//如果beanName是在该BeanFactory的单例对象的高速缓存Map集合中 或者 (descriptor是SteamDependencyDesciptor实例 且 该实例有排序标记)
else if (containsSingleton(candidateName) || (descriptor instanceof StreamDependencyDescriptor &&
((StreamDependencyDescriptor) descriptor).isOrdered())) {
//获取candidateName的该工厂的Bean实例
Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
//如果beanInstance是NullBean实例,会将candidateName和null绑定到candidates中;否则将candidateName和其对应的实例绑定到candidates中
candidates.put(candidateName, (beanInstance instanceof NullBean ? null : beanInstance));
}
//candidateName所对应的bean不是单例
else {
//将candidateName和其对应的Class对象绑定到candidates中
candidates.put(candidateName, getType(candidateName));
}
}
MultiElementDescriptor
/**
* A dependency descriptor for a multi-element declaration with nested elements.
* <p>具有嵌套元素的多元素声明的依赖描述符,表示集合/数组依赖</p>
*/
private static class MultiElementDescriptor extends NestedDependencyDescriptor {
/**
* 新建一个StreamDependencyDescriptor实例
* @param original 从其创建副本的原始描述符
*/
public MultiElementDescriptor(DependencyDescriptor original) {
//拷贝originald的属性
super(original);
}
}
descriptor.resolveCandidate(name, type, this))
将指定的Bean名称解析为给定工厂的Bean实例,作为对此依赖项的匹配算法的候选结果
/**
* Resolve the specified bean name, as a candidate result of the matching
* algorithm for this dependency, to a bean instance from the given factory.
* <p>将指定的Bean名称解析为给定工厂的Bean实例,作为对此依赖项的匹配算法的候选结果</p>
* <p>The default implementation calls {@link BeanFactory#getBean(String)}.
* Subclasses may provide additional arguments or other customizations.
* <p>默认实现调用BeanFactory.getBean(String).子类可以提供其他参数或其他自定义</p>
* @param beanName the bean name, as a candidate result for this dependency
* -- bean名,作为此依赖项的候选结果
* @param requiredType the expected type of the bean (as an assertion)
* -- bean的预期类型(作为断言)
* @param beanFactory the associated factory -- 相关工厂
* @return the bean instance (never {@code null}) -- bean实例(永远不为 null)
* @throws BeansException if the bean could not be obtained -- 如果无法获取bean
* @since 4.3.2
* @see BeanFactory#getBean(String)
*/
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
throws BeansException {
return beanFactory.getBean(beanName);
}
adaptOrderComparator(matchingBeans)
构建排序比较器,用于对matchingBean的所有bean对象进行优先级排序
Spring 5 DefaultListableBeanFactory-- adaptOrderComparator源码分析
ResolvableType
可以看作是封装JavaType的元信息类
TypeConverter
定义类型转换方法的接口。通常(但不一定)与PropertyEditorRegistry接口一起实现。
构建依赖比较器,用于对matchingBean的所有bean对象进行优先级排序
- 获取此BeanFactory的依赖关系比较器【变量 comparator】
- 如果comparator是OrderComparator实例,创建工厂感知排序源提供者实例 【FactoryAwareOrderSourceProvider】并让comparator引用它,然后返回出去
- 返回此BeanFactory的依赖关系比较器【comparator】
/**
* 构建依赖比较器,用于对matchingBean的所有bean对象进行优先级排序
* @param matchingBeans 要排序的Bean对象Map,key=Bean名,value=Bean对象
* @return 依赖比较器,可能是 {@link OrderComparator} 实例
*/
@Nullable
private Comparator<Object> adaptDependencyComparator(Map<String, ?> matchingBeans) {
//获取此BeanFactory的依赖关系比较器
Comparator<Object> comparator = getDependencyComparator();
//如果comparator是OrderComparator实例
if (comparator instanceof OrderComparator) {
//创建工厂感知排序源提供者实例【FactoryAwareOrderSourceProvider】并让comparator引用它,然后返回出去
return ((OrderComparator) comparator).withSourceProvider(
createFactoryAwareOrderSourceProvider(matchingBeans));
}
else {
//返回此BeanFactory的依赖关系比较器
return comparator;
}
}
Spring 5 DefaultListableBeanFactory-- adaptOrderComparator源码分析