Spring源码阅读（八）标注Autowired的构造器是如何实例化的

挑选候选构造器

// Class: AutowiredAnnotationBeanPostProcessor
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName) throws BeansException {
   if (!this.lookupMethodsChecked.contains(beanName)) {
      ReflectionUtils.doWithMethods(beanClass, new ReflectionUtils.MethodCallback() {
         @Override
         public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
            Lookup lookup = method.getAnnotation(Lookup.class);
            if (lookup != null) {
               LookupOverride override = new LookupOverride(method, lookup.value());
               try {
                  RootBeanDefinition mbd = (RootBeanDefinition) beanFactory.getMergedBeanDefinition(beanName);
                  mbd.getMethodOverrides().addOverride(override);
               }
               catch (NoSuchBeanDefinitionException ex) {
                  throw new BeanCreationException(beanName,
                        "Cannot apply @Lookup to beans without corresponding bean definition");
               }
            }
         }
      });
      this.lookupMethodsChecked.add(beanName);
   }

   // Quick check on the concurrent map first, with minimal locking.
   Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
   if (candidateConstructors == null) {
      synchronized (this.candidateConstructorsCache) {
         // 从缓存中获取构造器
         candidateConstructors = this.candidateConstructorsCache.get(beanClass);
         // 如果缓存中不存在
         if (candidateConstructors == null) {
            // 获取所有的构造器
            Constructor<?>[] rawCandidates = beanClass.getDeclaredConstructors();
            List<Constructor<?>> candidates = new ArrayList<Constructor<?>>(rawCandidates.length);
            Constructor<?> requiredConstructor = null;
            Constructor<?> defaultConstructor = null;
            // 遍历所有的构造器
            for (Constructor<?> candidate : rawCandidates) {
               // 寻找标注了Autowired的构造器
               AnnotationAttributes ann = findAutowiredAnnotation(candidate);
               // 如果没有标注Autowired的构造器
               if (ann == null) {
                  Class<?> userClass = ClassUtils.getUserClass(beanClass);
                  if (userClass != beanClass) {
                     try {
                        Constructor<?> superCtor =
                              userClass.getDeclaredConstructor(candidate.getParameterTypes());
                        ann = findAutowiredAnnotation(superCtor);
                     }
                     catch (NoSuchMethodException ex) {
                        // Simply proceed, no equivalent superclass constructor found...
                     }
                  }
               }
               // 如果有标注Autowired的构造器
               if (ann != null) {
                  // 已经存在标注Autowried的构造器，报错
                  if (requiredConstructor != null) {
                     throw new BeanCreationException(beanName,
                           "Invalid autowire-marked constructor: " + candidate +
                           ". Found constructor with 'required' Autowired annotation already: " +
                           requiredConstructor);
                  }
                  // 标注Autowired的构造器没有参数，报错
                  if (candidate.getParameterTypes().length == 0) {
                     throw new IllegalStateException(
                           "Autowired annotation requires at least one argument: " + candidate);
                  }
                  // 获取required属性的值
                  boolean required = determineRequiredStatus(ann);
                  // 如果required的值为true，不指定默认为true
                  if (required) {
                     // 存在其他Autowired(required=false)的构造器，报错
                     if (!candidates.isEmpty()) {
                        throw new BeanCreationException(beanName,
                              "Invalid autowire-marked constructors: " + candidates +
                              ". Found constructor with 'required' Autowired annotation: " +
                              candidate);
                     }
                     // 标注为必须注入的构造器
                     requiredConstructor = candidate;
                  }
                  // 加入到候选构造器中
                  candidates.add(candidate);
               }
               // 如果构造器没有参数
               else if (candidate.getParameterTypes().length == 0) {
                  // 标注为默认构造器
                  defaultConstructor = candidate;
               }
            }
            // 如果候选构造器不为空
            if (!candidates.isEmpty()) {
               // 没有标注为Autowired的构造器
               if (requiredConstructor == null) {
                  // 存在默认构造器
                  if (defaultConstructor != null) {
                     // 将默认构造器添加到候选构造器中
                     candidates.add(defaultConstructor);
                  }
                  else if (candidates.size() == 1 && logger.isWarnEnabled()) {
                     logger.warn("Inconsistent constructor declaration on bean with name '" + beanName +
                           "': single autowire-marked constructor flagged as optional - this constructor " +
                           "is effectively required since there is no default constructor to fall back to: " +
                           candidates.get(0));
                  }
               }
               candidateConstructors = candidates.toArray(new Constructor<?>[candidates.size()]);
            }
            // 如果只有一个构造器且构造器的参数不等于空
            else if (rawCandidates.length == 1 && rawCandidates[0].getParameterTypes().length > 0) {
               // 则将该构造器作为唯一的候选构造器
               candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
            }
            else {
               // 其他情况没有候选构造器
               candidateConstructors = new Constructor<?>[0];
            }
            // 将候选构造器放到缓存中
            this.candidateConstructorsCache.put(beanClass, candidateConstructors);
         }
      }
   }
   // 存在候选构造器则返回，不存在则返回null
   return (candidateConstructors.length > 0 ? candidateConstructors : null);
}

总结

1. Autowired(required=true)只允许出现一次，不能于Autowired(required=false)同时存在。
2. 如果只存在一个构造器且参数不为空，则可以不标注Autowiried。
3. 标注Autowired的构造器不允许参数为空。

为构造器参数注入值

// ConstructorResolver
private ArgumentsHolder createArgumentArray(
      String beanName, RootBeanDefinition mbd, ConstructorArgumentValues resolvedValues,
      BeanWrapper bw, Class<?>[] paramTypes, String[] paramNames, Object methodOrCtor,
      boolean autowiring) throws UnsatisfiedDependencyException {

   TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
   TypeConverter converter = (customConverter != null ? customConverter : bw);

   ArgumentsHolder args = new ArgumentsHolder(paramTypes.length);
   Set<ConstructorArgumentValues.ValueHolder> usedValueHolders =
         new HashSet<ConstructorArgumentValues.ValueHolder>(paramTypes.length);
   Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
   // 循环构造器参数开始处理
   for (int paramIndex = 0; paramIndex < paramTypes.length; paramIndex++) {
      Class<?> paramType = paramTypes[paramIndex];
      String paramName = (paramNames != null ? paramNames[paramIndex] : "");
      // Try to find matching constructor argument value, either indexed or generic.
      ConstructorArgumentValues.ValueHolder valueHolder =
            resolvedValues.getArgumentValue(paramIndex, paramType, paramName, usedValueHolders);
      // If we couldn't find a direct match and are not supposed to autowire,
      // let's try the next generic, untyped argument value as fallback:
      // it could match after type conversion (for example, String -> int).
      if (valueHolder == null && (!autowiring || paramTypes.length == resolvedValues.getArgumentCount())) {
         valueHolder = resolvedValues.getGenericArgumentValue(null, null, usedValueHolders);
      }
      if (valueHolder != null) {
         // We found a potential match - let's give it a try.
         // Do not consider the same value definition multiple times!
         usedValueHolders.add(valueHolder);
         Object originalValue = valueHolder.getValue();
         Object convertedValue;
         if (valueHolder.isConverted()) {
            convertedValue = valueHolder.getConvertedValue();
            args.preparedArguments[paramIndex] = convertedValue;
         }
         else {
            ConstructorArgumentValues.ValueHolder sourceHolder =
                  (ConstructorArgumentValues.ValueHolder) valueHolder.getSource();
            Object sourceValue = sourceHolder.getValue();
            MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, paramIndex);
            try {
               convertedValue = converter.convertIfNecessary(originalValue, paramType, methodParam);
               // TODO re-enable once race condition has been found (SPR-7423)
               /*
               if (originalValue == sourceValue || sourceValue instanceof TypedStringValue) {
                  // Either a converted value or still the original one: store converted value.
                  sourceHolder.setConvertedValue(convertedValue);
                  args.preparedArguments[paramIndex] = convertedValue;
               }
               else {
               */
                  args.resolveNecessary = true;
                  args.preparedArguments[paramIndex] = sourceValue;
               // }
            }
            catch (TypeMismatchException ex) {
               throw new UnsatisfiedDependencyException(
                     mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam),
                     "Could not convert argument value of type [" +
                     ObjectUtils.nullSafeClassName(valueHolder.getValue()) +
                     "] to required type [" + paramType.getName() + "]: " + ex.getMessage());
            }
         }
         args.arguments[paramIndex] = convertedValue;
         args.rawArguments[paramIndex] = originalValue;
      }
      else {
         MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, paramIndex);
         // No explicit match found: we're either supposed to autowire or
         // have to fail creating an argument array for the given constructor.
         if (!autowiring) {
            throw new UnsatisfiedDependencyException(
                  mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam),
                  "Ambiguous argument values for parameter of type [" + paramType.getName() +
                  "] - did you specify the correct bean references as arguments?");
         }
         try {
            // 开始解析注入参数
            Object autowiredArgument =
                  resolveAutowiredArgument(methodParam, beanName, autowiredBeanNames, converter);
            args.rawArguments[paramIndex] = autowiredArgument;
            args.arguments[paramIndex] = autowiredArgument;
            args.preparedArguments[paramIndex] = new AutowiredArgumentMarker();
            args.resolveNecessary = true;
         }
         catch (BeansException ex) {
            throw new UnsatisfiedDependencyException(
                  mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam), ex);
         }
      }
   }

   for (String autowiredBeanName : autowiredBeanNames) {
      this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
      if (this.beanFactory.logger.isDebugEnabled()) {
         this.beanFactory.logger.debug("Autowiring by type from bean name '" + beanName +
               "' via " + (methodOrCtor instanceof Constructor ? "constructor" : "factory method") +
               " to bean named '" + autowiredBeanName + "'");
      }
   }

   return args;
}

进入 resolveAutowiredArgument

// DefaultListableBeanFactory
public Object resolveDependency(DependencyDescriptor descriptor, String beanName,
      Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

   descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
   if (javaUtilOptionalClass == descriptor.getDependencyType()) {
      return new OptionalDependencyFactory().createOptionalDependency(descriptor, beanName);
   }
   else if (ObjectFactory.class == descriptor.getDependencyType() ||
         ObjectProvider.class == descriptor.getDependencyType()) {
      return new DependencyObjectProvider(descriptor, beanName);
   }
   else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
      return new Jsr330ProviderFactory().createDependencyProvider(descriptor, beanName);
   }
   else {
      Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, beanName);
      if (result == null) {
         // 一般代码逻辑都是走这里
         result = doResolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter);
      }
      return result;
   }
}

进入doResolveDependency

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

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

      Class<?> type = descriptor.getDependencyType();
      Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
      if (value != null) {
         if (value instanceof String) {
            String strVal = resolveEmbeddedValue((String) value);
            BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
            value = evaluateBeanDefinitionString(strVal, bd);
         }
         TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
         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;
      }
	  // 这里是注入单个对象的处理方法
      Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
      if (matchingBeans.isEmpty()) {
         if (descriptor.isRequired()) {
            raiseNoMatchingBeanFound(type, descriptor.getResolvableType().toString(), descriptor);
         }
         return null;
      }
      if (matchingBeans.size() > 1) {
         String primaryBeanName = determineAutowireCandidate(matchingBeans, descriptor);
         if (primaryBeanName == null) {
            if (descriptor.isRequired() || !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;
            }
         }
         if (autowiredBeanNames != null) {
            autowiredBeanNames.add(primaryBeanName);
         }
         return matchingBeans.get(primaryBeanName);
      }
      // We have exactly one match.
      Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
      if (autowiredBeanNames != null) {
         autowiredBeanNames.add(entry.getKey());
      }
      return entry.getValue();
   }
   finally {
      ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
   }
}

进入findAutowireCandidates

// DefaultListableBeanFactory
protected Map<String, Object> findAutowireCandidates(
      String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
   // 根据参数类型获取候选者名称
   String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
         this, requiredType, true, descriptor.isEager());
   Map<String, Object> result = new LinkedHashMap<String, Object>(candidateNames.length);
   // 处理ApplicationContext,BeanFactory,ResourceLoader,ApplicationEventPublisher
   for (Class<?> autowiringType : this.resolvableDependencies.keySet()) {
      if (autowiringType.isAssignableFrom(requiredType)) {
         Object autowiringValue = this.resolvableDependencies.get(autowiringType);
         autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
         if (requiredType.isInstance(autowiringValue)) {
            result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
            break;
         }
      }
   }
   // 遍历候选者
   for (String candidateName : candidateNames) {
      // 非自引用并且是注入候选（默认结果是true）
      if (!isSelfReference(beanName, candidateName) && isAutowireCandidate(candidateName, descriptor)) {
         result.put(candidateName, descriptor.resolveCandidate(candidateName, requiredType, this));
      }
   }
   if (result.isEmpty() && !indicatesMultipleBeans(requiredType)) {
      // Consider fallback matches if the first pass failed to find anything...
      DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
      for (String candidateName : candidateNames) {
         if (!isSelfReference(beanName, candidateName) && isAutowireCandidate(candidateName, fallbackDescriptor)) {
            result.put(candidateName, descriptor.resolveCandidate(candidateName, requiredType, this));
         }
      }
      if (result.isEmpty()) {
         // Consider self references before as a final pass
         for (String candidateName : candidateNames) {
            if (isSelfReference(beanName, candidateName) && isAutowireCandidate(candidateName, fallbackDescriptor)) {
               result.put(candidateName, descriptor.resolveCandidate(candidateName, requiredType, this));
            }
         }
      }
   }
   return result;
}

进入resolveCandidate

// Class: DependencyDescriptor
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
      throws BeansException {
   // 获取bean对象,获取不到则进行创建
   return beanFactory.getBean(beanName, requiredType);
}

在多个注入候选者之间挑选注入对象

进入doResolveDependency方法中的determineAutowireCandidate方法

protected String determineAutowireCandidate(Map<String, Object> candidateBeans, DependencyDescriptor descriptor) {
   // 获取注入对象的类型
   Class<?> requiredType = descriptor.getDependencyType();
   // 寻找标注Primary的bean对象
   String primaryCandidate = determinePrimaryCandidate(candidateBeans, requiredType);
   if (primaryCandidate != null) {
      return primaryCandidate;
   }
   // 寻找标注Priority的bean对象
   String priorityCandidate = determineHighestPriorityCandidate(candidateBeans, requiredType);
   if (priorityCandidate != null) { 
      return priorityCandidate;
   }
   // 如果候选bean对象的名称于依赖的bean对象名称相同，则返回
   for (Map.Entry<String, Object> entry : candidateBeans.entrySet()) {
      String candidateBeanName = entry.getKey();
      Object beanInstance = entry.getValue();
      if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
            matchesBeanName(candidateBeanName, descriptor.getDependencyName())) {
         return candidateBeanName;
      }
   }
   return null;
}

总结

1. 由源码可知，Autowired是先根据类型来匹配依赖对象。
2. 如果存在多个候选的依赖对象，则看是否有标注Primary的，如果没有，则看是否有标注Priority的，取最高优先级。
3. 如果都没有，则看是否候选的bean对象与依赖的bean对象名称是否相同，相同则直接采纳。即所谓的根据名称来匹配。