Spring 5 AutowireCapableBeanFactory -- resolveDependency源码分析(二)

其他 2021-01-31 13:45:30 阅读次数: 0

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对象，并将其封装成相应的依赖类型对象:

  1. 获取包装的参数/字段的声明的(非通用)类型【变量 type】
  2. 【当decriptor所包装的对象是Stream类型】:
    1. 如果描述符是Stream依赖项描述符:
      1. 查找与valueType匹配的候选bean对象;构建成Map，key=bean名,val=Bean对象【变量 matchingBeans】
      2. 自动注入匹配成功的候选Bean名集合不为null,将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
      3. 取出除Bean对象为NullBean以外的所有候选Bean名称的Bean对象【变量 stream】
      4. 如果decriptor需要排序,根据matchingBean构建排序比较器，交由steam进行排序
      5. 返回已排好序且已存放除Bean对象为NullBean以外的所有候选Bean名称的Bean对象的stream对象【变量 stream】
  3. 【当decriptor所包装的对象是数组类型】：
    1. 如果依赖类型是数组类型:
      1. 获取type的元素Class对象【变量 componentType】
      2. 获取decriptor包装的参数/字段所构建出来的ResolvableType对象【变量 resolvableType】
      3. 让resolvableType解析出的对应的数组Class对象，如果解析失败，就引用type【变量 resolvedArrayType】
      4. 如果resolvedArrayType与type不是同一个Class对象,componentType就引用resolvableType解析处理的元素Class对象
      5. 如果没有元素Class对象，就返回null，表示获取不到候选bean对象
      6. 查找与valueType匹配的候选bean对象;构建成Map，key=bean名,val=Bean对象【变量 matchingBeans】
      7. 如果没有候选Bean对象,返回null，表示获取不到候选bean对象
      8. 自动注入匹配成功的候选Bean名集合不为null,将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
      9. 如果有传入类型转换器就引用传入的类型转换器，否则获取此BeanFactory使用的类型转换器
      10. 将所有候选Bean对象转换为resolvedArrayType类型【变量 result】
      11. 如果result是数组实例:
        1. 构建依赖比较器,用于对matchingBean的所有bean对象进行优先级排序【变量 comparator】
        2. 如果比较器不为null,使用comparator对result数组进行排序
      12. 返回该候选对象数组【result】
  4. 【如果依赖类型属于Collection类型 且 依赖类型是否接口】:
    1. 将descoptor所包装的参数/字段构建出来的ResolvableType对象解析成Collectionl类型，然后解析出其 泛型参数的Class对象【变量 elementType】
    2. 如果元素类型为null,返回null，表示获取不到候选bean对象
    3. 查找与valueType匹配的候选bean对象;构建成Map，key=bean名,val=Bean对象【变量 matchingBeans】
    4. 如果没有候选bean对象，返回null，表示获取不到候选bean对象
    5. 自动注入匹配成功的候选Bean名集合不为null,将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
    6. 如果有传入类型转换器就引用传入的类型转换器，否则获取此BeanFactory使用的类型转换器
    7. 将所有候选Bean对象转换为resolvedArrayType类型【变量 result】
    8. 如果result是List实例:
      1. 构建依赖比较器,用于对matchingBean的所有bean对象进行优先级排序【变量 comparator】
      2. 如果比较器不为null,使用comparator对result数组进行排序
    9. 返回该候选对象数组【result】
  5. 【如果依赖类型是Map类型】：
    1. 将descoptor所包装的参数/字段构建出来的ResolvableType对象解析成Map类型【变量 mapType】
    2. 解析出第1个泛型参数的Class对象,即key的Class对象【变量 keyType】
    3. 如果keyType不是String类型,返回null，表示获取不到候选bean对象
    4. 解析出第2个泛型参数的Class对象,即value的Class对象【变量 valueType】
    5. 如果keyType为null，即解析不出value的Class对象或者是根本没有value的Class对象, 返回null，表示获取不到候选bean对象
    6. 查找与valueType匹配的候选bean对象;构建成Map，key=bean名,val=Bean对象【变量 matchingBeans】
    7. 如果没有候选bean对象,返回null，表示获取不到候选bean对象
    8. 自动注入匹配成功的候选Bean名集合不为null,将所有的自动注入匹配成功的候选Bean名添加到autowiredBeanNames
    9. 返回候选的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期间调用】:

  1. 获取requiredType的所有bean名,包括父级工厂中定义的名称【变量 candidateNames】
  2. 定义用于保存匹配requiredType的bean名和其实例对象的Map，即匹配成功的候选Map【变量 result】
  3. 【从 存放着手动显示注册的依赖项类型-相应的自动装配值的缓存【resolvableDependencies】中匹配候选】:
    1. 遍历resolvableDependencies,元素classObjectEntry:
      1. 取出依赖项类型【变量 autowiringType】
      2. 如果autowiringType是属于requiredType的实例:
        1. 取出autowiringType对应的实例对象【变量 autowiringValue】
        2. 根据requiredType解析autowiringValue,并针对autowiringValue是ObjectFactory的情况进行解析,将解析出来的值 重新赋值给autowiringValue
        3. 如果autowiringValue是requiredType类型,就根据autowiringValue构建出唯一 ID与autowiringValue绑定到result中,然后跳槽循环
  4. 【常规匹配候选(beanDefinition是否允许依赖注入,泛型类型是否匹配,限定符注解 /限定符信息是否匹配)】:
    1. 遍历candidateNames,元素candidate:
      1. 如果beanName与candidateName所对应的Bean对象不是同一个且candidate可以自动注入, 添加一个条目在result中:一个bean实例(如果可用)或仅一个已解析的类型
  5. 【找不到候选时，就采用将回退模式(在回退模式下，候选Bean具有无法解析的泛型 || 候选Bean的Class 对象是Properties类对象时，都允许成为该描述符的可自动注入对象)尽可能的匹配到候选，一般情况 下不会出现回退情况,除非代码非常糟糕】:
    1. 如果result为空:
      1. requiredType是否是数组/集合类型的标记【变量multiple】
      2. 获取desciptord的一个旨在用于回退匹配变体【遍历 fallbackDescriptor】
      3. 【先尝试匹配候选bean名符合允许回退匹配的依赖描述符的自动依赖条件且(依赖类型不是集合/数组 或者描述符指定限定符)的候选Bean对象】:
        1. 遍历candidateNames,元素candidate:
          1. 如果beanName与candidateName所对应的Bean对象不是同一个 且 candidate可以自动注入 且 (type不是数组/集合类型或者 desciptor有@Qualifier注解或qualifier标准修饰), 就添加一个条目在result中:一个bean实例(如果可用)或仅一个已解析的类型
      4. 【降低匹配精度:满足下面条件即可】【除beanName符合描述符依赖类型不是数组/集合，beanName与candidateName所对应的Bean对象不是同一个，descriptor不是集合依赖或者beanName与candidate不相同，候选bean名符合允许回退匹配的依赖描述符的自动依赖条件】
        1. 如果result为空且requiredType不是数组/集合类型或者
        2. 遍历candidateNames,元素candidate:
          1. 如果beanName与candidateName所对应的Bean对象不是同一个 且 (descriptor不是 MultiElementDescriptor实例(即集合依赖)或者beanName不等于candidate) 且 candidate可以自动注入,添加一个条目在result中:一个bean实例(如果可用) 或仅一个已解析的类型
  6. 返回匹配成功的后续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名,包括父级工厂中定义的名称:

  1. 如果lbf为null，抛出异常
  2. 获取与type（包括子类）匹配的bean名称【变量 result】,根据includeNonSingletons来决定是否包含原型+单例 还是 只包含单例,根据allowEargerInit决定是否初始化lazy-init单例和由FactoryBeans创建的对象 以进行类型检查
  3. 如果lbf是HierarchicalBeanFactory:
    1. 将lbf强转HierarchicalBeanFactory对象【变量 hbf】
    2. 如果hbf的父工厂是LisableBeanFactory对象:
      1. 递归该方法获取父工厂里type的所有bean名,包括父级工厂中定义的名称
      2. 将result结果与parentResult合并重新赋值给result
  4. 返回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

Spring 5 AutowireCandidateResolver源码注释

addCandidateEntry(result, candidate, descriptor, requiredType);

在候选映射中添加一个条目:一个bean实例(如果可用)或仅一个已解析的类型，以防止在选择主要候选对象之前太早初始化bean:

  1. 如果desciprtor是MultiElementDescriptor的实例【集合类型依赖】:
    1. 获取candidateName的该工厂的Bean实例【变量 beanInstance】
    2. 如果beanInstance不是NullBean实例,将candidateName和其对应的实例绑定到candidates中
  2. 如果beanName是在该BeanFactory的单例对象的高速缓存Map集合中 或者 (descriptor是SteamDependencyDesciptor实例【Stream类型依赖】且 该实例有排序标记):
    1. 获取candidateName的该工厂的Bean实例【变量 beanInstance】
    2. 如果beanInstance是NullBean实例,会将candidateName和null绑定到candidates中；否则将candidateName和其对应的实例绑定到candidates中
  3. 否则(一般就是指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的元信息类

Spring 5 ResolvableType 源码注释

TypeConverter

定义类型转换方法的接口。通常(但不一定)与PropertyEditorRegistry接口一起实现。

Spring 5 SimpleTypeConverter 源码注释

构建依赖比较器,用于对matchingBean的所有bean对象进行优先级排序

  1. 获取此BeanFactory的依赖关系比较器【变量 comparator】
  2. 如果comparator是OrderComparator实例,创建工厂感知排序源提供者实例 【FactoryAwareOrderSourceProvider】并让comparator引用它,然后返回出去
  3. 返回此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源码分析

猜你喜欢

转载自blog.csdn.net/qq_30321211/article/details/108361995
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
curl的POST请求，封装方法
8.1.1. Integer Types
Java基础 Day05(个人复习整理)
Python - Django - 中间件 process_exception
小L的试卷
【Shell编程】 （函数）判断用户是否存在
python(css样式)
spring ant path 匹配原则 - 【笔记】
《JavaScript与JScript从入门到精通》(美)James.Jaworski.中译本.扫描版.pdf
Eclipse运行带参数的java程序
每日归档
更多
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022