Spring依赖注入之@Autowired、@Qualifier、@Primary、@Priority注解原理（下）

jjjjjjjjjjjjjjjjjjzq

已于 2022-04-25 23:09:30 修改

阅读量824

点赞数

于 2022-04-10 01:25:37 首次发布

本文链接：https://blog.csdn.net/qq_32868023/article/details/124071669

版权

@Autowired注解可以声明一个bean依赖的其他bean，spring在创建bean时会将这些依赖的bean注入进来。接依赖注入@Autowired原理（上），本节从AutowireCapableBeanFactory#resolveDependency方法开始分析resolveDependency方法的依赖注入过程。

1、resolveDependency定义

resolveDependency方法定义在AutowireCapableBeanFactory接口中，有两个重载方法

public interface AutowireCapableBeanFactory extends BeanFactory {
    
    @Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;

	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;

}

实际上第一个重载方法就是调用的第二个方法，只是autowiredBeanNames、typeConverter都传的null，所以着重从第二个方法分析

	@Override
	@Nullable
	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException {
		return resolveDependency(descriptor, requestingBeanName, null, null);
	}

resolveDependency的第二个重载有四个参数，除descriptor之外其他三个都比较简单

requestingBeanName，需要注入依赖的bean的name
autowiredBeanNames，符合条件的依赖的beanName
typeConverter，将解析出来的依赖进行类型转换
descriptor，描述依赖，由于依赖可能是Field、方法参数、构造器参数上，包装成DependencyDescriptor提供统一的访问方式

2、resolveDependency实现细节

resolveDependency根据依赖注入所需类型，分为四种情况来处理

Optional
ObjectFactory/ObjectProvider
javax.inject.Provider
除以上三种之外的情况，即常用的情况

	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
		if (Optional.class == descriptor.getDependencyType()) {
			return createOptionalDependency(descriptor, requestingBeanName);
		}
		else if (ObjectFactory.class == descriptor.getDependencyType() ||
				ObjectProvider.class == descriptor.getDependencyType()) {
			return new DependencyObjectProvider(descriptor, requestingBeanName);
		}
		else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
			return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
		}
		else {
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
					descriptor, requestingBeanName);
			if (result == null) {
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}

这四种情况都会调用到doResolveDependency方法，先分析是如何调用到doResolveDependency，下节分析doResolveDependency细节。分别来看

a、Optional

createOptionalDependency方法只是替换了DependencyDescriptor，将required设置为false，然后调用doResolveDependency

	private Optional<?> createOptionalDependency(
			DependencyDescriptor descriptor, @Nullable String beanName, final Object... args) {

		DependencyDescriptor descriptorToUse = new NestedDependencyDescriptor(descriptor) {
			@Override
			public boolean isRequired() {
				return false;
			}
			@Override
			public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) {
				return (!ObjectUtils.isEmpty(args) ? beanFactory.getBean(beanName, args) :
						super.resolveCandidate(beanName, requiredType, beanFactory));
			}
		};
		Object result = doResolveDependency(descriptorToUse, beanName, null, null);
		return (result instanceof Optional ? (Optional<?>) result : Optional.ofNullable(result));
	}

b、ObjectFactory/ObjectProvider

这种情况new了一个DependencyObjectProvider返回，DependencyObjectProvider#getObject方法里调用doResolveDependency

	private class DependencyObjectProvider implements BeanObjectProvider<Object> {

		@Override
		public Object getObject() throws BeansException {
			if (this.optional) {
				return createOptionalDependency(this.descriptor, this.beanName);
			}
			else {
				Object result = doResolveDependency(this.descriptor, this.beanName, null, null);
				if (result == null) {
					throw new NoSuchBeanDefinitionException(this.descriptor.getResolvableType());
				}
				return result;
			}
		}
    }

c、javax.inject.Provider

调用了Jsr330Factory#createDependencyProvider方法，这个方法里返回了Jsr330Provider

	private class Jsr330Factory implements Serializable {

		public Object createDependencyProvider(DependencyDescriptor descriptor, @Nullable String beanName) {
			return new Jsr330Provider(descriptor, beanName);
		}
    }

Jsr330Provider继承了DependencyObjectProvider（同上），get方法里调用了getValue

		private class Jsr330Provider extends DependencyObjectProvider implements Provider<Object> {

			public Jsr330Provider(DependencyDescriptor descriptor, @Nullable String beanName) {
				super(descriptor, beanName);
			}

			@Override
			@Nullable
			public Object get() throws BeansException {
				return getValue();
			}
		}

getValue里调用doResolveDependency方法

		protected Object getValue() throws BeansException {
			if (this.optional) {
				return createOptionalDependency(this.descriptor, this.beanName);
			}
			else {
				return doResolveDependency(this.descriptor, this.beanName, null, null);
			}
		}

d、以上三种情况外

主要逻辑就是

如果有Lazy注解，返回一个Lazy代理，不会立即实例化这个依赖
否则doResolveDependency解析以来

			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
					descriptor, requestingBeanName);
			if (result == null) {
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;

getAutowireCandidateResolver()方法返回什么呢？DefaultListableBeanFactory类里autowireCandidateResolver实例初始化为SimpleAutowireCandidateResolver.INSTANCE，但在初始化AnnotatedBeanDefinitionReader时，调用AnnotationConfigUtils#registerAnnotationConfigProcessors将autowireCandidateResolver修改为ContextAnnotationAutowireCandidateResolver

	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}
        ...
    }

ContextAnnotationAutowireCandidateResolver#getLazyResolutionProxyIfNecessary方法会判断是否需要延迟注入，如果需要延迟注入则会返回一个代理对象。

Note：@Lazy+@Bean/@Component和@Lazy+@Autowired是完全不同的含义。
@Lazy+@Bean/@Component表示这个bean会延迟初始化，延迟到这个bean被引用到的时候，影响的是AbstractApplicationContext#finishBeanFactoryInitialization时，是否主动去提前初始化这个bean，但是一个需要提前初始化的bean依赖了一个Lazy bean，Lazy bean仍然会被初始化。
@Lazy+@Autowired影响的是依赖注入时是否初始化依赖的bean（这个被依赖的bean可能已经初始化了、也可能还未初始化、还可能不存在，但都不影响此处逻辑），如果有@Lazy，此处会返回代理对象，只有到访问这个代理对象的方法时才会去获取被代理bean（是获取而不一定是初始化，因为这个被代理的bean可能在finishBeanFactoryInitialization阶段就已经初始化了、或者被其他bean注入依赖时初始化了）

	public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
		return (isLazy(descriptor) ? buildLazyResolutionProxy(descriptor, beanName) : null);
	}

分别看下isLazy和buildLazyResolutionProxy逻辑

isLazy

	protected boolean isLazy(DependencyDescriptor descriptor) {
		for (Annotation ann : descriptor.getAnnotations()) {
			Lazy lazy = AnnotationUtils.getAnnotation(ann, Lazy.class);
			if (lazy != null && lazy.value()) {
				return true;
			}
		}
		MethodParameter methodParam = descriptor.getMethodParameter();
		if (methodParam != null) {
			Method method = methodParam.getMethod();
			if (method == null || void.class == method.getReturnType()) {
				Lazy lazy = AnnotationUtils.getAnnotation(methodParam.getAnnotatedElement(), Lazy.class);
				if (lazy != null && lazy.value()) {
					return true;
				}
			}
		}
		return false;
	}

对于Field来讲，逻辑很简单，for循环查找Field上的Lazy注解，返回lazy.value
对于方法注入和构造器要复杂一些，@Lazy可以标注在构造器/方法上，也能够标注在参数上

如果@Lazy标注在方法和构造器的参数上，那么for循环就能够拿到@Lazy注解，如果为true的话则返回
如果标注在构造器上， method为null，则@Lazy为true则返回
如果标注在方法上
- 如果方法返回值是void，则@Lazy为true则返回
- 如果方法返回值不是void，则忽略@Lazy

对于方法和构造器简单来说就是，不管是方法上还是参数桑@Lazy，true会覆盖false

buildLazyResolutionProxy

protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {
		BeanFactory beanFactory = getBeanFactory();
		Assert.state(beanFactory instanceof DefaultListableBeanFactory,
				"BeanFactory needs to be a DefaultListableBeanFactory");
		final DefaultListableBeanFactory dlbf = (DefaultListableBeanFactory) beanFactory;

		TargetSource ts = new TargetSource() {
			@Override
			public Class<?> getTargetClass() {
				return descriptor.getDependencyType();
			}
			@Override
			public boolean isStatic() {
				return false;
			}
			@Override
			public Object getTarget() {
				Set<String> autowiredBeanNames = (beanName != null ? new LinkedHashSet<>(1) : null);
				Object target = dlbf.doResolveDependency(descriptor, beanName, autowiredBeanNames, null);
				if (target == null) {
					Class<?> type = getTargetClass();
					if (Map.class == type) {
						return Collections.emptyMap();
					}
					else if (List.class == type) {
						return Collections.emptyList();
					}
					else if (Set.class == type || Collection.class == type) {
						return Collections.emptySet();
					}
					throw new NoSuchBeanDefinitionException(descriptor.getResolvableType(),
							"Optional dependency not present for lazy injection point");
				}
				if (autowiredBeanNames != null) {
					for (String autowiredBeanName : autowiredBeanNames) {
						if (dlbf.containsBean(autowiredBeanName)) {
							dlbf.registerDependentBean(autowiredBeanName, beanName);
						}
					}
				}
				return target;
			}
			@Override
			public void releaseTarget(Object target) {
			}
		};

		ProxyFactory pf = new ProxyFactory();
		pf.setTargetSource(ts);
		Class<?> dependencyType = descriptor.getDependencyType();
		if (dependencyType.isInterface()) {
			pf.addInterface(dependencyType);
		}
		return pf.getProxy(dlbf.getBeanClassLoader());
	}

buildLazyResolutionProxy方法通过ProxyFactory生成了一个代理对象，获取被代理对象TargetSource#getTarget方法，其中调用doResolveDependency方法获取依赖实例

3、doResolveDependency

除去@Value注解的处理逻辑，doResolveDependency有两部分逻辑

解析多个bean。resolveMultipleBeans方法处理Map、Collection、数组的依赖注入，如果成功解析出依赖，直接返回；resolveMultipleBeans方法底层通过findAutowireCandidates获取到依赖的bean
解析单个bean。上面步骤如果返回null，则会通过findAutowireCandidates直接获取matchingBeans，按一定规则处理matchingBeans，返回单个bean或抛出异常

尽管这两种情况都调用了findAutowireCandidates，但返回的内容是不同的，针对两种情况有特殊处理

	public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
		try {
			Object shortcut = descriptor.resolveShortcut(this);
			if (shortcut != null) {
				return shortcut;
			}

            // 省略@Value注解的处理逻辑
            ...

			Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
			if (multipleBeans != null) {
				return multipleBeans;
			}

			Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (matchingBeans.isEmpty()) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				return null;
			}

			String autowiredBeanName;
			Object instanceCandidate;

			if (matchingBeans.size() > 1) {
				autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
				if (autowiredBeanName == null) {
					if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
						return descriptor.resolveNotUnique(descriptor.getResolvableType(), 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;
					}
				}
				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();
			}

			if (autowiredBeanNames != null) {
				autowiredBeanNames.add(autowiredBeanName);
			}
			if (instanceCandidate instanceof Class) {
				instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
			}
			Object result = instanceCandidate;
			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);
		}
	}

a、解析多个bean

if-else分成5种情况来处理，分别是

将beanFactory转换为Stream的情况
依赖为数组类型
依赖为Collection子接口
依赖为Map类型
其他，直接返回null

主要介绍上面四种情况

	private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {

		Class<?> type = descriptor.getDependencyType();

		if (descriptor instanceof StreamDependencyDescriptor) {
			Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (autowiredBeanNames != null) {
				autowiredBeanNames.addAll(matchingBeans.keySet());
			}
			Stream<Object> stream = matchingBeans.keySet().stream()
					.map(name -> descriptor.resolveCandidate(name, type, this))
					.filter(bean -> !(bean instanceof NullBean));
			if (((StreamDependencyDescriptor) descriptor).isOrdered()) {
				stream = stream.sorted(adaptOrderComparator(matchingBeans));
			}
			return stream;
		}
		else if (type.isArray()) {
			Class<?> componentType = type.getComponentType();
			ResolvableType resolvableType = descriptor.getResolvableType();
			Class<?> resolvedArrayType = resolvableType.resolve(type);
			if (resolvedArrayType != type) {
				componentType = resolvableType.getComponentType().resolve();
			}
			if (componentType == null) {
				return null;
			}
			Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
					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(), resolvedArrayType);
			if (result instanceof Object[]) {
				Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
				if (comparator != null) {
					Arrays.sort((Object[]) result, comparator);
				}
			}
			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 (result instanceof List) {
				if (((List<?>) result).size() > 1) {
					Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
					if (comparator != null) {
						((List<?>) result).sort(comparator);
					}
				}
			}
			return result;
		}
		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;
		}
	}

StreamDependencyDescriptor

DependencyObjectProvider提供了对bean的流式访问，相关方法如下

		@Override
		public Stream<Object> stream() {
			return resolveStream(false);
		}

		@Override
		public Stream<Object> orderedStream() {
			return resolveStream(true);
		}

		@SuppressWarnings("unchecked")
		private Stream<Object> resolveStream(boolean ordered) {
			DependencyDescriptor descriptorToUse = new StreamDependencyDescriptor(this.descriptor, ordered);
			Object result = doResolveDependency(descriptorToUse, this.beanName, null, null);
			return (result instanceof Stream ? (Stream<Object>) result : Stream.of(result));
		}

resolveStream方法里new了StreamDependencyDescriptor，封装了真正需要解析的DependencyDescriptor，通过doResolveDependency来解析依赖。
resolveMultipleBeans方法对StreamDependencyDescriptor处理如下，调用findAutowireCandidates解析出真正的matchingBeans，返回Value的Stream

		if (descriptor instanceof StreamDependencyDescriptor) {
			Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (autowiredBeanNames != null) {
				autowiredBeanNames.addAll(matchingBeans.keySet());
			}
			Stream<Object> stream = matchingBeans.keySet().stream()
					.map(name -> descriptor.resolveCandidate(name, type, this))
					.filter(bean -> !(bean instanceof NullBean));
			if (((StreamDependencyDescriptor) descriptor).isOrdered()) {
				stream = stream.sorted(adaptOrderComparator(matchingBeans));
			}
			return stream;
		}

descriptor#resolveCandidate方法就是根据name从beanFactory中获取bean

	public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
			throws BeansException {

		return beanFactory.getBean(beanName);
	}

Array

		else if (type.isArray()) {
			Class<?> componentType = type.getComponentType();
			ResolvableType resolvableType = descriptor.getResolvableType();
			Class<?> resolvedArrayType = resolvableType.resolve(type);
			if (resolvedArrayType != type) {
				componentType = resolvableType.getComponentType().resolve();
			}
			if (componentType == null) {
				return null;
			}
			Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
					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(), resolvedArrayType);
			if (result instanceof Object[]) {
				Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
				if (comparator != null) {
					Arrays.sort((Object[]) result, comparator);
				}
			}
			return result;
		}

数组的处理流程如下

获取数组的ComponentType
通过findAutowireCandidates获取到matchingBeans，这里传的MultiElementDescriptor，继承NestedDependencyDescriptor->DependencyDescriptor，本身无特殊作用，只起到标记作用，表示findAutowireCandidates时需要特殊处理

	private static class NestedDependencyDescriptor extends DependencyDescriptor {

		public NestedDependencyDescriptor(DependencyDescriptor original) {
			super(original);
			increaseNestingLevel();
		}
	}

	private static class MultiElementDescriptor extends NestedDependencyDescriptor {

		public MultiElementDescriptor(DependencyDescriptor original) {
			super(original);
		}
	}

将这些bean转换成resolvedArrayType数组类型
然后排序，返回。排序支持注解和接口形式

Collection子接口

		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 (result instanceof List) {
				if (((List<?>) result).size() > 1) {
					Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
					if (comparator != null) {
						((List<?>) result).sort(comparator);
					}
				}
			}
			return result;
		}

获取集合的elementType
通过findAutowireCandidates获取到matchingBeans，传的MultiElementDescriptor跟前面相同
调用converter转换成指定的集合类型
如果转换的结果是List的话，还会进行排序

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;
		}

校验Map的key类型必须是String
解析出valueType
通过findAutowireCandidates解析出matchingBeans
直接返回matchingBeans

b、解析单个bean

解析单个bean的情况，首先通过findAutowireCandidates获取到matchingBeans，根据matchingBeans是否空分情况处理

如果matchingBeans为空，且required=true的话，抛出异常；否则返回null
如果matchingBeans不为空，需要解析出instanceCandidate，处理NullBean的问题。如果matchingBeans恰好是1个，那么instanceCandidate就是这个bean；如果matchingBeans大于1个，则会通过determineAutowireCandidate选择出来合适的instanceCandidate，选不出来再根据required决定是否抛异常。
根据instanceCandidate类型分别处理
- Class，从BeanFactory获取对应类型的bean
- NullBean，表示bean不存在，根据required决定是否抛异常
- instanceCandidate类型正确，则返回，否则抛异常

除整个流程外，再看一下determineAutowireCandidate怎么选择合适bean的？至于instanceCandidate为什么会出现Class和NullBean类型，findAutowireCandidates方法中再分析

	public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
		try {
            ...
                
			Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (matchingBeans.isEmpty()) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				return null;
			}

			String autowiredBeanName;
			Object instanceCandidate;

			if (matchingBeans.size() > 1) {
				autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
				if (autowiredBeanName == null) {
					if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
						return descriptor.resolveNotUnique(descriptor.getResolvableType(), 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;
					}
				}
				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();
			}

			if (autowiredBeanNames != null) {
				autowiredBeanNames.add(autowiredBeanName);
			}
			if (instanceCandidate instanceof Class) {
				instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
			}
			Object result = instanceCandidate;
			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);
		}
	}

determineAutowireCandidate怎么选择合适bean的？

	@Nullable
	protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {
		Class<?> requiredType = descriptor.getDependencyType();
		String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
		if (primaryCandidate != null) {
			return primaryCandidate;
		}
		String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
		if (priorityCandidate != null) {
			return priorityCandidate;
		}
		// Fallback
		for (Map.Entry<String, Object> entry : candidates.entrySet()) {
			String candidateName = entry.getKey();
			Object beanInstance = entry.getValue();
			if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
					matchesBeanName(candidateName, descriptor.getDependencyName())) {
				return candidateName;
			}
		}
		return null;
	}

这里逻辑分为三部分

determinePrimaryCandidate查找有@Primary的bean
determineHighestPriorityCandidate查找优先级最高的bean
for循环遍历所有的candidates，满足两个条件之一即可
- 这个bean在resolvableDependencies里面
- matchesBeanName名字完全符合

resolvableDependencies是spring基础设施之类的bean，registerResolvableDependency注册了了BeanFactory、ApplicationContext之类的bean

	public void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue) {
		Assert.notNull(dependencyType, "Dependency type must not be null");
		if (autowiredValue != null) {
			if (!(autowiredValue instanceof ObjectFactory || dependencyType.isInstance(autowiredValue))) {
				throw new IllegalArgumentException("Value [" + autowiredValue +
						"] does not implement specified dependency type [" + dependencyType.getName() + "]");
			}
			this.resolvableDependencies.put(dependencyType, autowiredValue);
		}
	}

4、findAutowireCandidates

findAutowireCandidates把符合Autowired条件的cadidates都找出来，逻辑主要有三部分：

第一个for循环从resolvableDependencies里查找符合requiredType类型的bean，加入result，这部分逻辑简单不再分析，resolvableDependencies前面分析过。
第二个for循环从BeanFactoryUtils#beanNamesForTypeIncludingAncestors拿到的candidateNames，将符合isAutowireCandidate条件的加入result。
此时如果result还是空的，将走fallback逻辑。

findAutowireCandidates方法逻辑很清晰，其中有几个方法还需继续看一下
1、beanNamesForTypeIncludingAncestors获取到了哪些candidateNames
2、isAutowireCandidate如何判断一个bean能够作为autowireCandidate
3、addCandidateEntry如何加入result
4、fallback逻辑细节

	protected Map<String, Object> findAutowireCandidates(
			@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {

		String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
				this, requiredType, true, descriptor.isEager());
		Map<String, Object> result = CollectionUtils.newLinkedHashMap(candidateNames.length);
		for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
			Class<?> autowiringType = classObjectEntry.getKey();
			if (autowiringType.isAssignableFrom(requiredType)) {
				Object autowiringValue = classObjectEntry.getValue();
				autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
				if (requiredType.isInstance(autowiringValue)) {
					result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
					break;
				}
			}
		}
		for (String candidate : candidateNames) {
			if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
				addCandidateEntry(result, candidate, descriptor, requiredType);
			}
		}
		if (result.isEmpty()) {
			boolean multiple = indicatesMultipleBeans(requiredType);
			// Consider fallback matches if the first pass failed to find anything...
			DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
			for (String candidate : candidateNames) {
				if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
						(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
					addCandidateEntry(result, candidate, descriptor, 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.
				for (String candidate : candidateNames) {
					if (isSelfReference(beanName, candidate) &&
							(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
							isAutowireCandidate(candidate, fallbackDescriptor)) {
						addCandidateEntry(result, candidate, descriptor, requiredType);
					}
				}
			}
		}
		return result;
	}

a、beanNamesForTypeIncludingAncestors

beanNamesForTypeIncludingAncestors这个方法就是从beanFactory以及parent beanFactory找到符合type类型的bean，bean的类型包括type和type的子类

	public static String[] beanNamesForTypeIncludingAncestors(
			ListableBeanFactory lbf, Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {

		Assert.notNull(lbf, "ListableBeanFactory must not be null");
		String[] result = lbf.getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
		if (lbf instanceof HierarchicalBeanFactory) {
			HierarchicalBeanFactory hbf = (HierarchicalBeanFactory) lbf;
			if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
				String[] parentResult = beanNamesForTypeIncludingAncestors(
						(ListableBeanFactory) hbf.getParentBeanFactory(), type, includeNonSingletons, allowEagerInit);
				result = mergeNamesWithParent(result, parentResult, hbf);
			}
		}
		return result;
	}

b、isAutowireCandidate

isAutowireCandidate处理了这个bean能否作为candidate的逻辑，总的来说检查了以下条件：

@Bean注解的candidate字段
泛型是否匹配
@Qualifier注解

	public boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
			throws NoSuchBeanDefinitionException {

		return isAutowireCandidate(beanName, descriptor, getAutowireCandidateResolver());
	}

isAutowireCandidate通过getAutowireCandidateResolver方法获取了一个AutowireCandidateResolver，调用isAutowireCandidate重载

	protected boolean isAutowireCandidate(
			String beanName, DependencyDescriptor descriptor, AutowireCandidateResolver resolver)
			throws NoSuchBeanDefinitionException {

		String bdName = BeanFactoryUtils.transformedBeanName(beanName);
		if (containsBeanDefinition(bdName)) {
			return isAutowireCandidate(beanName, getMergedLocalBeanDefinition(bdName), descriptor, resolver);
		}
		else if (containsSingleton(beanName)) {
			return isAutowireCandidate(beanName, new RootBeanDefinition(getType(beanName)), descriptor, resolver);
		}

		BeanFactory parent = getParentBeanFactory();
		if (parent instanceof DefaultListableBeanFactory) {
			// No bean definition found in this factory -> delegate to parent.
			return ((DefaultListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor, resolver);
		}
		else if (parent instanceof ConfigurableListableBeanFactory) {
			// If no DefaultListableBeanFactory, can't pass the resolver along.
			return ((ConfigurableListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor);
		}
		else {
			return true;
		}
	}

isAutowireCandidate重载从beanFactory和parent beanFactory中构造出BeanDefinition，再次调用重载

	protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
			DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {

		String bdName = BeanFactoryUtils.transformedBeanName(beanName);
		resolveBeanClass(mbd, bdName);
		if (mbd.isFactoryMethodUnique && mbd.factoryMethodToIntrospect == null) {
			new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
		}
		BeanDefinitionHolder holder = (beanName.equals(bdName) ?
				this.mergedBeanDefinitionHolders.computeIfAbsent(beanName,
						key -> new BeanDefinitionHolder(mbd, beanName, getAliases(bdName))) :
				new BeanDefinitionHolder(mbd, beanName, getAliases(bdName)));
		return resolver.isAutowireCandidate(holder, descriptor);
	}

isAutowireCandidate这个重载构造出BeanDefinitionHolder，通过AutowireCandidateResolver判断是否是autowireCandidate。
回头看getAutowireCandidateResolver逻辑，getAutowireCandidateResolver获取autowireCandidateResolver，这个autowireCandidateResolver在AnnotatedBeanDefinitionReader实例化时，通过AnnotationConfigUtils#registerAnnotationConfigProcessors方法set一个ContextAnnotationAutowireCandidateResolver进来。

	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}
        ...
    }

ContextAnnotationAutowireCandidateResolver的继承层次是ContextAnnotationAutowireCandidateResolver=>QualifierAnnotationAutowireCandidateResolver=>GenericTypeAwareAutowireCandidateResolver=>SimpleAutowireCandidateResolver。跟isAutowireCandidate相关的逻辑从QualifierAnnotationAutowireCandidateResolver开始，由于每个类都会调用super#isAutowireCandidate，从SimpleAutowireCandidateResolver开始分析

SimpleAutowireCandidateResolver

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {

	@Override
	public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		return bdHolder.getBeanDefinition().isAutowireCandidate();
	}
}

SimpleAutowireCandidateResolver调用了BeanDefinition#isAutowireCandidate方法，其实就是读取了autowireCandidate字段，而这个字段就是@Bean设置的。

GenericTypeAwareAutowireCandidateResolver

    public class GenericTypeAwareAutowireCandidateResolver extends SimpleAutowireCandidateResolver
		implements BeanFactoryAware, Cloneable {


	@Override
	public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		if (!super.isAutowireCandidate(bdHolder, descriptor)) {
			// If explicitly false, do not proceed with any other checks...
			return false;
		}
		return checkGenericTypeMatch(bdHolder, descriptor);
	}

GenericTypeAwareAutowireCandidateResolver首先调用SimpleAutowireCandidateResolver#isAutowireCandidate方法，满足则继续checkGenericTypeMatch。checkGenericTypeMatch检查了泛型类型是否匹配。

QualifierAnnotationAutowireCandidateResolver

public class QualifierAnnotationAutowireCandidateResolver extends GenericTypeAwareAutowireCandidateResolver {

	@Override
	public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		boolean match = super.isAutowireCandidate(bdHolder, descriptor);
		if (match) {
			match = checkQualifiers(bdHolder, descriptor.getAnnotations());
			if (match) {
				MethodParameter methodParam = descriptor.getMethodParameter();
				if (methodParam != null) {
					Method method = methodParam.getMethod();
					if (method == null || void.class == method.getReturnType()) {
						match = checkQualifiers(bdHolder, methodParam.getMethodAnnotations());
					}
				}
			}
		}
		return match;
	}
}

QualifierAnnotationAutowireCandidateResolver首先调用GenericTypeAwareAutowireCandidateResolver#isAutowireCandidate，满足的话再继续检查Qualifier注解。两个checkQualifiers首先检查Method、Field上的Qualifier注解、然后检查Constructor、Method参数上的Qualifier注解，全都满足Qualifier条件则可以作为candidate。

这里面还存在细节逻辑不深究：
1、方法注入时，Qualifier能够标注在方法上、也能够标注在参数上，以谁为准？
2、方法注入时，如果存在多个参数，能不能在方法上指定这些参数？

checkQualifiers方法为了支持javax，实际检查了两种注解：org.springframework.beans.factory.annotation.Qualifier和javax.inject.Qualifier。

c、addCandidateEntry

addCandidateEntry将candidateName加入到candidates里，分析这个方法可以知道每个调用findAutowireCandidates的地方拿到的map是什么。

	private void addCandidateEntry(Map<String, Object> candidates, String candidateName,
			DependencyDescriptor descriptor, Class<?> requiredType) {

		if (descriptor instanceof MultiElementDescriptor) {
			Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
			if (!(beanInstance instanceof NullBean)) {
				candidates.put(candidateName, beanInstance);
			}
		}
		else if (containsSingleton(candidateName) || (descriptor instanceof StreamDependencyDescriptor &&
				((StreamDependencyDescriptor) descriptor).isOrdered())) {
			Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
			candidates.put(candidateName, (beanInstance instanceof NullBean ? null : beanInstance));
		}
		else {
			candidates.put(candidateName, getType(candidateName));
		}
	}

value分为第三种情况

第一种情况是descriptor是MultiElementDescriptor的时候。MultiElementDescriptor是解析Array、Collection、Map是传入的tDescriptor，此时通过descriptor#resolveCandidate解析出bean实例，作为value存入map
第二种情况有两种，1是beanFactory以及存在该单例bean，2是descriptor是StreamDependencyDescriptor且需要排序。此时也会通过descriptor#resolveCandidate解析出bean实例，作为value存入map
第三种即其他情况，包括解析单个bean的情况，和descriptor是StreamDependencyDescriptor但不需要排序。这时value是candidate的类型。

jjjjjjjjjjjjjjjjjjzq

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Spring依赖注入之@Autowired、@Qualifier、@Primary、@Priority注解原理（下）

@Autowired注解可以声明一个bean依赖的其他bean，spring在创建bean时会将这些依赖的bean注入进来。接依赖注入@Autowired原理（上），本节从AutowireCapableBeanFactory#resolveDependency方法开始分析resolveDependency方法的依赖注入过程。
复制链接

扫一扫