日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時(shí)間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
詳解Spring支持的各種數(shù)據(jù)類型的注入，你都用過哪些？

1 判斷類型

注入的屬性判斷其類型：

成都創(chuàng)新互聯(lián)是網(wǎng)站建設(shè)專家,致力于互聯(lián)網(wǎng)品牌建設(shè)與網(wǎng)絡(luò)營銷，專業(yè)領(lǐng)域包括網(wǎng)站設(shè)計(jì)制作、成都網(wǎng)站制作、電商網(wǎng)站制作開發(fā)、成都微信小程序、微信營銷、系統(tǒng)平臺(tái)開發(fā)，與其他網(wǎng)站設(shè)計(jì)及系統(tǒng)開發(fā)公司不同，我們的整合解決方案結(jié)合了恒基網(wǎng)絡(luò)品牌建設(shè)經(jīng)驗(yàn)和互聯(lián)網(wǎng)整合營銷的理念，并將策略和執(zhí)行緊密結(jié)合，且不斷評(píng)估并優(yōu)化我們的方案，為客戶提供全方位的互聯(lián)網(wǎng)品牌整合方案！

  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 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注解，如果有該注解那么會(huì)創(chuàng)建代理對(duì)象，否則返回null
            // 總結(jié)：如果注入的屬性有@Lazy注解，那么會(huì)返回由ProxyFactory對(duì)象創(chuàng)建的代理對(duì)象
            Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
            if (result == null) {
                // 解析查找依賴注入的對(duì)象
                result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
            }
            return result;
        }
    }
}

2 查找依賴對(duì)象

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


      // 判斷需要注入的類型是否是一個(gè)集合（如何：List beans）
      // 2.1 
      Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
      if (multipleBeans != null) {
          return multipleBeans;
      }
      // 查找與所需類型匹配的bean實(shí)例
      // 2.2
      Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);
      if (matchingBeans.isEmpty()) {
          if (isRequired(descriptor)) {
              raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
          }
          return null;
      }


      String autowiredBeanName;
      Object instanceCandidate;


      // 如果找到多個(gè)
      if (matchingBeans.size() > 1) {
          // 在這里會(huì)判斷多個(gè)Bean中是否有一個(gè)@Primary注解的Bean
          // 如果沒有@Primary，繼續(xù)獲取是否有@Priority（優(yōu)先級(jí)）注解
          // 如果沒有則返回null，如果有則返回值越小的優(yōu)先級(jí)越高（如果有多個(gè)優(yōu)先級(jí)一樣，則系統(tǒng)報(bào)錯(cuò)）
          // 如果上面都返回的null，那么最后會(huì)通過beanName進(jìn)行匹配
          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 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 判斷集合類型

判斷需要注入的屬性的數(shù)據(jù)類型是否是如下幾種。

  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 autowiredBeanNames, @Nullable TypeConverter typeConverter) {


    Class type = descriptor.getDependencyType();


    if (descriptor instanceof StreamDependencyDescriptor) {
      Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);
      if (autowiredBeanNames != null) {
        autowiredBeanNames.addAll(matchingBeans.keySet());
      }
      Stream 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 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 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 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 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 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 findAutowireCandidates(
          @Nullable String beanName, Class requiredType, DependencyDescriptor descriptor) {
    // 通過類型獲取指定類型的Bean
    String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
            this, requiredType, true, descriptor.isEager());
    Map result = CollectionUtils.newLinkedHashMap(candidateNames.length);
    // resolvableDependencies 集合中保存了，容器內(nèi)置的和自定義注冊(cè)的依賴注入對(duì)象
    //（如：HttpServletRequest對(duì)象的注入為該集合內(nèi)部指定的對(duì)象）
    for (Map.Entry, 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在注入屬性的時(shí)候會(huì)判斷是什么數(shù)據(jù)類型進(jìn)行相應(yīng)的操作
完畢?。。?/p>                                                

                                                網(wǎng)頁題目：詳解Spring支持的各種數(shù)據(jù)類型的注入，你都用過哪些？                                                

                                                瀏覽地址：http://www.dlmjj.cn/article/djcojcp.html