1 判斷類型

注入的屬性判斷其類型：6m428資訊網——每日最新資訊28at.com

1. Optional
2. ObjectFactory
3. ObjectProvider
4. javax.inject.Provider

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {    private static Class<?> javaxInjectProviderClass;    static {        try {            javaxInjectProviderClass =                    ClassUtils.forName("javax.inject.Provider", DefaultListableBeanFactory.class.getClassLoader());        } catch (ClassNotFoundException ex) {            javaxInjectProviderClass = null;        }    }    public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {        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 {            // 判斷是否有@Lazy注解，如果有該注解那么會創建代理對象，否則返回null            // 總結：如果注入的屬性有@Lazy注解，那么會返回由ProxyFactory對象創建的代理對象            Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);            if (result == null) {                // 解析查找依賴注入的對象                result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);            }            return result;        }    }}

2 查找依賴對象

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {  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;      }      Class<?> type = descriptor.getDependencyType();      // 判斷需要注入的類型是否是一個集合（如何：List<Users> beans）      // 2.1       Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);      if (multipleBeans != null) {          return multipleBeans;      }      // 查找與所需類型匹配的bean實例      // 2.2      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) {          // 在這里會判斷多個Bean中是否有一個@Primary注解的Bean          // 如果沒有@Primary，繼續獲取是否有@Priority（優先級）注解          // 如果沒有則返回null，如果有則返回值越小的優先級越高（如果有多個優先級一樣，則系統報錯）          // 如果上面都返回的null，那么最后會通過beanName進行匹配          autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);          if (autowiredBeanName == null) {              if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {                  // 如果是必須的 或者 不是集合類型的Bean注入；那么這里拋出異常                  return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);              } else {                  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);    }  }}

2.1 判斷集合類型

判斷需要注入的屬性的數據類型是否是如下幾種。6m428資訊網——每日最新資訊28at.com

1. StreamDependencyDescriptor
2. Array
3. Collection
4. Map

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {  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;    }  }}

2.2 查找Bean

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {  protected Map<String, Object> findAutowireCandidates(          @Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {    // 通過類型獲取指定類型的Bean    String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(            this, requiredType, true, descriptor.isEager());    Map<String, Object> result = CollectionUtils.newLinkedHashMap(candidateNames.length);    // resolvableDependencies 集合中保存了，容器內置的和自定義注冊的依賴注入對象    //（如：HttpServletRequest對象的注入為該集合內部指定的對象）    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;  }}

以上就是Spring在注入屬性的時候會判斷是什么數據類型進行相應的操作6m428資訊網——每日最新資訊28at.com

完畢！！！6m428資訊網——每日最新資訊28at.com

本文鏈接：http://www.tebozhan.com/showinfo-26-10486-0.html詳解Spring支持的各種數據類型的注入，你都用過哪些？

聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。郵件：2376512515@qq.com

上一篇： Springboot — 用更優雅的方式發HTTP請求(RestTemplate詳解)

下一篇： 為什么我更喜歡基于主干的開發