@Qualified

在spring中进行依赖注入的方式有两个注解可以使用，分别是 @Resource、@Autowired 两个注解其对应的功能分别是

• Resource：默认按照名称进行装配，可以通过name属性指定名称，如果没有指定name属性，当注解写在字段上时，默认取字段名进行查找注入，如果写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配
• Autowired： 默认按类型装配，默认情况下必须要求依赖对象必须存在。如果 Spring 没有其他提示，将会按照需要注入的变量名称来寻找合适的 bean

现在有个场景就是如果我一个接口下面有多个实现，我主要想注入标记了对应注解的实现类，上面的两个注解就不能单独进行使用了，需要进行搭配使用；例如：@LoadBalanced 注解实现负载均衡；

@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Qualifier
public @interface LoadBalanced {}

注意 @LoadBalanced 注解中包含了一个 @Qualifier 的注解，这个注解的用处就是可以在一个接口多个实现类中进行指定注入例如：spring cloud提供的对 RestTemplate 进行负载，下面我们看一下具体的源码是如何进行导入的

public class LoadBalancerAutoConfiguration {@LoadBalanced@Autowired(required = false)private List restTemplates = Collections.emptyList();
}

spring工厂在实例化后对属性进行赋值时执行 InstantiationAwareBeanPostProcessor 接口的实现类

而进行属性注入的时候是通过 AutowiredAnnotationBeanPostProcessor 处理器在bean实例化之后对 @Autowired 注解进行属性赋值的

public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {/*** 获取到对象内部中 是否有Autowired注解标注的属性* InjectionMetadata：* 包含一个list的 InjectedElement接口元素，会将 @Autowired注解标记的字段或者方法解析成对应的实现类*/InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);try {metadata.inject(bean, beanName, pvs);}catch (BeanCreationException ex) {throw ex;}catch (Throwable ex) {throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);}return pvs;}

下面的代码就是循环调用 InjectedElement 的方法

public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {Collection checkedElements = this.checkedElements;Collection elementsToIterate =(checkedElements != null ? checkedElements : this.injectedElements);if (!elementsToIterate.isEmpty()) {for (InjectedElement element : elementsToIterate) {element.inject(target, beanName, pvs);}}}

下面以 AutowiredFieldElement 为例子进行源码的解读。下面的代码可以看到最终解析是通过 resolveFieldValue() 的方法进行解析

protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {//强转为字段对象Field field = (Field) this.member;Object value;//是否被缓存了，默认falseif (this.cached) {try {//开启了缓存直接解析已经缓存了的value值value = resolvedCachedArgument(beanName, this.cachedFieldValue);}catch (NoSuchBeanDefinitionException ex) {// Unexpected removal of target bean for cached argument -> re-resolvevalue = resolveFieldValue(field, bean, beanName);}}else {//通过字段、bean、bean名称去bean工厂中解析出对应的依赖值value = resolveFieldValue(field, bean, beanName);}if (value != null) {ReflectionUtils.makeAccessible(field);field.set(bean, value);}}

解析字段的依赖

@Nullableprivate Object resolveFieldValue(Field field, Object bean, @Nullable String beanName) {//依赖描述类，里面包括了 Method、Filed 的描述DependencyDescriptor desc = new DependencyDescriptor(field, this.required);//设置字段或者方法所属的bean对象类desc.setContainingClass(bean.getClass());//获取到的依赖bean的名称Set autowiredBeanNames = new LinkedHashSet<>(1);Assert.state(beanFactory != null, "No BeanFactory available");//获取到spring工厂定义的类型转换器TypeConverter typeConverter = beanFactory.getTypeConverter();Object value;try {//bean工厂解析出依赖value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);}}

当前方法对需要注入的依赖类型进行判断，最重要的是 doResolveDependency() 方法

public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());//处理 Optionalif (Optional.class == descriptor.getDependencyType()) {return createOptionalDependency(descriptor, requestingBeanName);}//处理 ObjectFactory 类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 {//获取到是否是懒加载，通过 ContextAnnotationAutowireCandidateResolver 进行判断是否有 @Lazy注解，如果是懒加载会通过 ProxyFactory 创建一个动态代理类Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);if (result == null) {result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);}return result;}}

doResolveDependency() 方法中最主要调用的是下面两个方法

• resolveMultipleBeans：解析list、array、map等依赖
• findAutowireCandidates：解析单个bean的依赖方法

整个方法所做的事情就是，先检查依赖缓存中是否已经缓存了字段的依赖数据，如果有的话直接解析缓存数据，没有的话就先解析所需要的字段依赖是集合相关的还是单个bean，优先解析字段依赖的类型是 list、array、map，然后再解析单个

public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {//设置了一下当前正在解析的注入参数，通过本地线程进行保存InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);try {Object shortcut = descriptor.resolveShortcut(this);if (shortcut != null) {return shortcut;}Class type = descriptor.getDependencyType();/*** 通过当前指定的自动注入的接口器来解析需要解析的bean的名称，目前有两个实现类* QualifierAnnotationAutowireCandidateResolver：用于处理 @Value 、@Qualifier 注解* SimpleAutowireCandidateResolver，默认的解析器，并没有实现什么特殊的功能* ContextAnnotationAutowireCandidateResolver：继承至 QualifierAnnotationAutowireCandidateResolver* 这里回去找 @Value 注解是否存在*/Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);if (value != null) {//如果value不为空的话进行下面的的处理.....代码省略}//解析依赖的是否是map、list、数组等Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);if (multipleBeans != null) {return multipleBeans;}//获取到匹配的beanMap matchingBeans = findAutowireCandidates(beanName, type, descriptor);//如果依赖都没有找找到，先判断是否是 required=trueif (matchingBeans.isEmpty()) {if (isRequired(descriptor)) {//抛出bean依赖没有找到的问题raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);}return null;}String autowiredBeanName;Object instanceCandidate;//匹配的bean的个数如果大于1if (matchingBeans.size() > 1) {//查看是否标注了 @Primary注解、@priority，优先使用注入autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);if (autowiredBeanName == null) {if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);}else {return null;}}instanceCandidate = matchingBeans.get(autowiredBeanName);}else {Map.Entry entry = matchingBeans.entrySet().iterator().next();//如果只有一个直接获取key值autowiredBeanName = entry.getKey();instanceCandidate = entry.getValue();}if (autowiredBeanNames != null) {autowiredBeanNames.add(autowiredBeanName);}if (instanceCandidate instanceof Class) {//如果类型为class，直接去bean工厂中调用 getBean() 查询，如果没有查询到直接实例化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);}}

resolveMultipleBeans() 方法解析多元素，其中会进行判断字段的数据类型是什么，array、map、collection、interface 等组装的方式不一样但是获取数据bean的方式都一样，都是通过 findAutowireCandidates() 方法去通过bean工厂获取数据

private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) {//获取到当前字段需要依赖的类型Class type = descriptor.getDependencyType();//处理 StreamDependencyDescriptor 类型的依赖描述器，这里一般是 DependencyDescriptorif (descriptor instanceof StreamDependencyDescriptor) {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;}//获取到适合的依赖，通过 MultiElementDescriptor 对依赖描述器封装成多元素描述器Map matchingBeans = findAutowireCandidates(beanName, componentType,new MultiElementDescriptor(descriptor));if (matchingBeans.isEmpty()) {return null;}if (autowiredBeanNames != null) {autowiredBeanNames.addAll(matchingBeans.keySet());}//通过 TypeConverter 来进行转换判断类型之间是否可以互相转换TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());Object result = converter.convertIfNecessary(matchingBeans.values(), resolvedArrayType);if (result instanceof Object[]) {Comparator