【Spring源代码阅读之十】populateBean()方法对已经创建好的实例进行属性填充之ByName或ByType自动注入模型相关代码阅读
populateBean方法对已经创建好的实例进行属性填充之ByName或ByType自动注入模型相关代码阅读
- 导图(关注黄色populateBean方法2、3步)
- AbstractAutowireCapableBeanFactory#populateBean
- autowireByName
- unsatisfiedNonSimpleProperties
- isExcludedFromDependencyCheck
- AutowireUtils#isExcludedFromDependencyCheck
- autowireByType
- DefaultListableBeanFactory#resolveDependency
- doResolveDependency
- resolveMultipleBeans
导图(关注黄色populateBean方法2、3步)
AbstractAutowireCapableBeanFactory#populateBean
/**
* 使用bean定义中的属性值填充给定BeanWrapper中的bean实例。
*/
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
/**
* BeanWrapper为空，则没有填充的意义，可以直接返回
* 如果BeanDefinition中依然存在需要填充的属性值，则报错
*/
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
/**
* 设置一个标识，在设置属性之前，给任何InstantiationAwareBeanPostProcessors实现修改bean状态的机会
*/
boolean continueWithPropertyPopulation = true;
/**
* BeanDefinition不是合成的，则遍历所有实现了InstantiationAwareBeanPostProcessor的BeanPostProcessor
* 在属性注入前修改Bean的属性值，并返回一个状态，是否继续进行依赖注入，默认实现返回true，继续依赖注入
*/
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
/**
* 如果上方在循环中有一个BeanPostProcessor表示不继续依赖注入，标识会被修改，这里返回
* 之后的依赖注入逻辑不再执行
*/
if (!continueWithPropertyPopulation) {
return;
}
/**
* 封装属性值的对象，里面封装了显示设置的属性名称和值
* XML:
*
*
*/
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
/**
* Spring中默认认为BeanDefinition的自动注入模型是NO，可以配置为ByName或者ByType或者constructor
* 如果配置了ByName或者ByType，则遍历Bean中的属性，获取容器中的Bean
*/
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
/**
* 复制BeanDefinition中的属性值
*/
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
/**
* 根据属性的setter方法名称装配属性
*/
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
/**
* 根据属性类型装配属性
*/
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
/**
* 更新配置，新的配置含有依赖注入的对象实例
*/
pvs = newPvs;
}
/**
* 容器中是否有InstantiationAwareBeanPostProcessors类型的BeanPostProcessor
*/
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
/**
* 是否进行依赖检查，默认不检查
*/
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
/**
* 含有InstantiationAwareBeanPostProcessors类型的BeanPostProcessor
* 或者需要进行检查则进入
*/
if (hasInstAwareBpps || needsDepCheck) {
/**
* 还没有属性封装对象，则获取显示设置的属性封装对象，没设置的话对象存在，只不过其中的属性集合为空
* 防止pvs为空的情况
*/
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
/**
* 从BeanWrapper中提取经过筛选的属性封装对象，不包括忽略的依赖项类型或在忽略的依赖项接口上定义的属性。
*/
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
/**
* 遍历InstantiationAwareBeanPostProcessor，可对属性做修改
* 主要起作用的是CommonAnnotationBeanPostProcessor和AutowiredAnnotationBeanPostProcessor这两个类
* 解析了{@link Resource} 和 {@link org.springframework.beans.factory.annotation.Autowired}注解
*/
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
/**
* 需要则进行属性检查，确保所有依赖的Bean已经完成实例创建
* 比对的就是pvs中属性的值是否已经设置
*/
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
/**
* 不理解
*/
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
autowireByName
/**
* 按setter属性方法名称装配属性
*/
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
/**
* 获取符合参与条件的属性
*/
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
/**
* 遍历这些属性名称
*/
for (String propertyName : propertyNames) {
/**
* 容器中存在这个名称的BeanDefinition或者单例Bean
*/
if (containsBean(propertyName)) {
/**
* 初始化Bean
*/
Object bean = getBean(propertyName);
/**
* 存放到属性封装对象中
*/
pvs.add(propertyName, bean);
/**
* 注册一个依赖关系，主要用于销毁操作
*/
registerDependentBean(propertyName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("Added autowiring by name from bean name '" + beanName +
"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
"' by name: no matching bean found");
}
}
}
}
unsatisfiedNonSimpleProperties
/**
* 返回一个未满足的非简单bean属性数组。这些可能是对工厂中其他Bean的不满意的引用。
* 不包括简单的属性，如原语或字符串。
*/
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
Set<String> result = new TreeSet<>();
/**
* 获取BeanDefinition中显示设置的属性
*/
PropertyValues pvs = mbd.getPropertyValues();
/**
* 获取Class中所有的setter或getter对应的属性
* 属性名称就是根据setter或getter方法的方法名去掉set或get前缀
*/
PropertyDescriptor[] pds = bw.getPropertyDescriptors();
/**
* 遍历属性，符合条件的才能添加到集合中进行返回
*/
for (PropertyDescriptor pd : pds) {
/**
* 以下条件必须全部符合才可以
* 1、属性存在setter方法
* 2、不在一些排除的规则中
* 3、不在BeanDefinition中显示设置的属性列表中
* 4、不是规定的简单类型的属性
*/
if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
!BeanUtils.isSimpleProperty(pd.getPropertyType())) {
result.add(pd.getName());
}
}
return StringUtils.toStringArray(result);
}
isExcludedFromDependencyCheck
/**
* 确定给定的bean属性是否从依赖项检查中排除。返回false表示不排除
* 此实现排除由CGLIB定义的属性和其类型与忽略的依赖项类型匹配或由忽略的依赖项接口定义的属性。
*/
protected boolean isExcludedFromDependencyCheck(PropertyDescriptor pd) {
/**
* 1、排除由CGLIB定义的属性
* 2、排除忽略的依赖项类型
* 3、排除依赖项接口定义的属性
*/
return (AutowireUtils.isExcludedFromDependencyCheck(pd) ||
this.ignoredDependencyTypes.contains(pd.getPropertyType()) ||
AutowireUtils.isSetterDefinedInInterface(pd, this.ignoredDependencyInterfaces));
}
AutowireUtils#isExcludedFromDependencyCheck
/**
* 确定给定的bean属性是否从依赖项检查中排除
* 此实现不包括CGLIB定义的属性
*/
public static boolean isExcludedFromDependencyCheck(PropertyDescriptor pd) {
/**
* 获取setter方法
*/
Method wm = pd.getWriteMethod();
/**
* 不存在setter方法不需要排除
*/
if (wm == null) {
return false;
}
/**
* 不是CGLIB方法不需要排除
*/
if (!wm.getDeclaringClass().getName().contains("$$")) {
// Not a CGLIB method so it's OK.
return false;
}
// It was declared by CGLIB, but we might still want to autowire it
// if it was actually declared by the superclass.
/**
* 它是由CGLIB声明的，但是如果它实际上是由超类声明的，我们可能仍然希望自动连接它。
*/
Class<?> superclass = wm.getDeclaringClass().getSuperclass();
/**
* 判断超类中的属性
*/
return !ClassUtils.hasMethod(superclass, wm.getName(), wm.getParameterTypes());
}
autowireByType
/**
* 按类型自动装配属性
*/
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
/**
* 获取类型转换器
*/
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
/**
* 存放依赖项的集合
*/
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
/**
* 获取符合参与条件的属性(ByName中也用到了，上翻就可以看到)
*/
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
/**
* 遍历这些属性
*/
for (String propertyName : propertyNames) {
try {
/**
* 根据属性名获取属性封装
*/
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// Don't try autowiring by type for type Object: never makes sense,
// even if it technically is a unsatisfied, non-simple property.
/**
* Object类型的话就忽略
*/
if (Object.class != pd.getPropertyType()) {
/**
* 获得属性的setter方法的描述(就是setter方法的一些信息)
*/
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
/**
* 如果Bean实现了PriorityOrdered接口，则不进行类型匹配，这针对后置处理器
*/
boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
/**
* 构建依赖关系描述符
*/
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
/**
* 根据setter方法的入参类型确定依赖项，根据类型在容器中查找类并创建实例并返回
* 同时放到了autowiredBeanNames集合中
* @see DefaultListableBeanFactory#resolveDependency(org.springframework.beans.factory.config.DependencyDescriptor, java.lang.String, java.util.Set, org.springframework.beans.TypeConverter)
*/
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
/**
* 返回的依赖对象不为空，则添加到属性封装类中
*/
if (autowiredArgument != null) {
pvs.add(propertyName, autowiredArgument);
}
/**
* 遍历依赖集合，注册依赖，用于销毁操作
*/
for (String autowiredBeanName : autowiredBeanNames) {
registerDependentBean(autowiredBeanName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
propertyName + "' to bean named '" + autowiredBeanName + "'");
}
}
/**
* 清空依赖集合
*/
autowiredBeanNames.clear();
}
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
}
}
}
DefaultListableBeanFactory#resolveDependency
/**
* 根据此工厂中定义的bean解析指定的依赖关系
*/
@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
/**
* 设置方法参数名的解析器策略
*/
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
/**
* 获取方法参数的包装类型或字段的声明类型是否是Optional类型
* 此类型是包装类，可优雅判断空情况
* 则返回包装有实际Bean的Optional对象
*/
if (Optional.class == descriptor.getDependencyType()) {
return createOptionalDependency(descriptor, requestingBeanName);
}
/**
* ObjectProvider和javax.inject.Provider与ObjectFactory意义差不多，只不过是不同的机构定义的标准
* ObjectProvider是ObjectFactory的一种变体，没用过
*/
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
return new Jsr330ProviderFactory().createDependencyProvider(descriptor, requestingBeanName);
}
else {
/**
* 解析需要注入的setter方法或属性上是否有Lazy注解
* 1、存在的话就返回一个代理对象使其依赖上，并不是真正的Bean，当调用的时候再从容器中获取真正的Bean
* 这样可以在解析依赖的时候不触发依赖Bean的创建，但是本Bean中的属性就一直为代理Bean了，
* 无论是第一次还是多次调用时，真正的Bean不会替换这个代理Bean
* 2、不存在的话就返回空，从容器中获取真正的Bean使其依赖上
* @see org.springframework.context.annotation.ContextAnnotationAutowireCandidateResolver#getLazyResolutionProxyIfNecessary(org.springframework.beans.factory.config.DependencyDescriptor, java.lang.String)
*/
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
/**
* 直接进行依赖，利用依赖项描述符从容器中获取
*/
if (result == null) {
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
}
doResolveDependency
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
/**
* 将依赖项描述符设置进本地线程中
*/
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
/**
* 利用快捷缓存解析获取此依赖项，Spring默认返回空
* 意义在于程序员可以在子类工厂中重写此方法进行快捷获取
*/
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
/**
* 获取setter方法的参数类型或属性的类型
*/
Class<?> type = descriptor.getDependencyType();
/**
* 获取Setter方法或属性上{@link org.springframework.beans.factory.annotation.Value}注解中的参数
* 里面代码自行断点查看，不解释
* @see QualifierAnnotationAutowireCandidateResolver#getSuggestedValue(org.springframework.beans.factory.config.DependencyDescriptor)
*/
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
/**
* 存在@Value注解则需要对其进行解析
*/
if (value != null) {
/**
* 注解中的value属性值是String类型的(只能是String类型的)
*/
if (value instanceof String) {
/**
* 使用属性值字符串解析器解析，解析@Value("${xxxx}")用法，获取配置文件中的配置
*/
String strVal = resolveEmbeddedValue((String) value);
/**
* 获取依赖项所在Bean的BeanDefinition
*/
BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
/**
* 解析字符串，可能将其解析为表达式(Spel表达式)
* 例如：@Value("#{service.getDict()}"),获取容器中一个实例的方法或属性，
* 这种方式有限制，具体自行百度测试
*/
value = evaluateBeanDefinitionString(strVal, bd);
}
/**
* 获取类型转换器
*/
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
/**
* 查看依赖描述符中是否是属性依赖还是Setter方法依赖，并进入不同的方法中
* 以下两个方法最后进入的是同一个方法，只不过通过参数来对那一个方法进行处理
* Setter方法依赖
* @see TypeConverterSupport#convertIfNecessary(java.lang.Object, java.lang.Class, org.springframework.core.MethodParameter)
* 属性依赖
* @see TypeConverterSupport#convertIfNecessary(java.lang.Object, java.lang.Class, java.lang.reflect.Field)
* 最终都会进入的方法
* @see TypeConverterSupport#doConvert(java.lang.Object, java.lang.Class, org.springframework.core.MethodParameter, java.lang.reflect.Field)
*/
return (descriptor.getField() != null ?
converter.convertIfNecessary(value, type, descriptor.getField()) :
converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}
/**
* 解析依赖的类型是数组、集合情况
*/
Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
return multipleBeans;
}
/**
* 获得容器中所有与依赖类型相符的BeanName和Class对象
*/
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
/**
* 如果找不到，判断是否有{@link org.springframework.beans.factory.annotation.Required}注解
* 有的话就抛异常，没有则返回空
*/
if (matchingBeans.isEmpty()) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
/**
* 确定注入的BeanName和Class对象
*/
String autowiredBeanName;
Object instanceCandidate;
/**
* 找到依赖的类型在容器中存在多个，则进行处理
*/
if (matchingBeans.size() > 1) {
/**
* 获取有没有优先使用的Bean，即查找@Primary和@Priority注解，确定主要使用哪一个
*/
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
/**
* 找不到确定使用的Bean，符合下列条件之一就会抛异常，否则返回空
* 1、依赖项是必须注入的，存在@Required注解
* 2、依赖项不是数组或集合
*/
if (autowiredBeanName == null) {
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
return descriptor.resolveNotUnique(type, matchingBeans);
}
else {
// In case of an optional Collection/Map, silently ignore a non-unique case:
// possibly it was meant to be an empty collection of multiple regular beans
// (before 4.3 in particular when we didn't even look for collection beans).
return null;
}
}
/**
* 找到确定使用的Bean，则给到变量中
*/
instanceCandidate = matchingBeans.get(autowiredBeanName);
}
/**
* 容器中找到依赖的类型只有一个，则进行赋值
*/
else {
// We have exactly one match.
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
/**
* 将依赖的BeanName放入到集合中，通过代码追踪可知为了销毁使用
*/
if (autowiredBeanNames != null) {
autowiredBeanNames.add(autowiredBeanName);
}
/**
* 解析依赖项，从容器中获取实例,实际上就是调用getBean方法
*/
if (instanceCandidate instanceof Class) {
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
Object result = instanceCandidate;
/**
* 实例为空(NullBean为Spring内部中对空对象的表示)，判断存不存在@Required注解必须注入
* 来进行抛异常或返回空
*/
if (result instanceof NullBean) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
result = null;
}
/**
* 判断从容器中找出的实例和依赖的类型是否一致，不一致抛异常
*/
if (!ClassUtils.isAssignableValue(type, result)) {
throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
}
return result;
}
/**
* 将依赖项描述符从本地线程中删除
*/
finally {
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}
resolveMultipleBeans
private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {
/**
* 获取依赖的类型
*/
Class<?> type = descriptor.getDependencyType();
/**
* 依赖的类型是数组
*/
if (type.isArray()) {
/**
* 获取数组的泛型类型
*/
Class<?> componentType = type.getComponentType();
/**
* 获取解析器中能解析的类型
*/
ResolvableType resolvableType = descriptor.getResolvableType();
Class<?> resolvedArrayType = resolvableType.resolve();
/**
* 依赖的类型和解析器中解析的类型不一致时，以解析器中解析类型为主
*/
if (resolvedArrayType != null && resolvedArrayType != type) {
type = resolvedArrayType;
componentType = resolvableType.getComponentType().resolve();
}
/**
* 依赖的类型为空，则不解析
*/
if (componentType == null) {
return null;
}
/**
* 获得容器中所有与依赖类型相符的BeanName为Key,Value为实例(属性未填充)
*/
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
new MultiElementDescriptor(descriptor));
/**
* 容器中不存在则返回空
*/
if (matchingBeans.isEmpty()) {
return null;
}
/**
* 将依赖的BeanName放入到集合中，通过代码追踪可知为了销毁使用
*/
if (autowiredBeanNames != null) {
autowiredBeanNames.addAll(matchingBeans.keySet());
}
/**
* 获取类型解析器
*/
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
/**
* 将这些依赖转换成实际的Bean实例返回
*/
Object result = converter.convertIfNecessary(matchingBeans.values(), type);
if (getDependencyComparator() != null && result instanceof Object[]) {
Arrays.sort((Object[]) result, adaptDependencyComparator(matchingBeans));
}
return result;
}
/**
* 依赖的类型属于单列集合并且是接口，则解析成集合返回，处理思路和数组一样
*/
else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
Class<?> elementType = descriptor.getResolvableType().asCollection().resolveGeneric();
if (elementType == null) {
return null;
}
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType,
new MultiElementDescriptor(descriptor));
if (matchingBeans.isEmpty()) {
return null;
}
if (autowiredBeanNames != null) {
autowiredBeanNames.addAll(matchingBeans.keySet());
}
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
Object result = converter.convertIfNecessary(matchingBeans.values(), type);
if (getDependencyComparator() != null && result instanceof List) {
((List<?>) result).sort(adaptDependencyComparator(matchingBeans));
}
return result;
}
/**
* 如果依赖是Map集合，则处理思路比数组少一步
*/
else if (Map.class == type) {
ResolvableType mapType = descriptor.getResolvableType().asMap();
Class<?> keyType = mapType.resolveGeneric(0);
if (String.class != keyType) {
return null;
}
Class<?> valueType = mapType.resolveGeneric(1);
if (valueType == null) {
return null;
}
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType,
new MultiElementDescriptor(descriptor));
if (matchingBeans.isEmpty()) {
return null;
}
if (autowiredBeanNames != null) {
autowiredBeanNames.addAll(matchingBeans.keySet());
}
return matchingBeans;
}
else {
return null;
}
}