详解Spring支持的各种数据类型的注入，你都用过哪些？

1 判断类型

注入的属性判断其类型：

成都创新互联是网站建设专家,致力于互联网品牌建设与网络营销，专业领域包括网站设计制作、成都网站制作、电商网站制作开发、成都微信小程序、微信营销、系统平台开发，与其他网站设计及系统开发公司不同，我们的整合解决方案结合了恒基网络品牌建设经验和互联网整合营销的理念，并将策略和执行紧密结合，且不断评估并优化我们的方案，为客户提供全方位的互联网品牌整合方案！

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注解，如果有该注解那么会创建代理对象，否则返回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 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 beans）
      // 2.1 
      Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
      if (multipleBeans != null) {
          return multipleBeans;
      }
      // 查找与所需类型匹配的bean实例
      // 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;


      // 如果找到多个
      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 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 判断集合类型

判断需要注入的属性的数据类型是否是如下几种。

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