Spring依赖注入@AutoWired

Spring依赖注入@AutoWired

• Spring依赖注入的形式
• • XML的方式
  • 以@AutoWired的方式
• spring的注解依赖注入
• • doCreateBean之注入点
  • @AutoWired依赖注入

Spring依赖注入的形式

Spring中的依赖注入要分好几种，我这边大概说明下这几种方式，spring中现在用的最多的是两种方式，第一种是xml模式，但是现在大多数都是注解的方式，现在不是叫做spring boot零配置吗,说白了就是没有使用xml的模式，使用的是注解的方式；spring中依赖注入要分好几种。

XML的方式

手动方式：
1.构造方法注入
2.set方法注入
自动模式：
1.构造方法注入
2.set方法注入
xml的注入方式在最早的时候用的最多的，xml的注入分为手动模式和自动模式，我们先来看下手动的模式，手动模式要在xml文件中写标签来手动注入

<bean name="orderService" class="com.bml10.service.OrderService">

</bean>
<bean name="userService" class="com.bml10.service.UserService">
   <property name="orderService" ref="orderService"/>
</bean>

对应的要在UserService提供set方法

public class UserService {


   private OrderService orderService;
   public void setOrderService(OrderService orderService) {
      this.orderService = orderService;
   }

   public void test(){
      System.out.println("orderService="+ orderService);
   }
}

这样就可以注入了，我们看下这种手动模式在spring的源码中是如何处理的，在spring填充属性的方法，上一篇笔记中已经记录了，方法就是populateBean

就是这段代码和这个方法的后面的applyPropertyValues(beanName, mbd, bw, pvs);来填充的属性，这种模式就是说在spring扫描的阶段会将你配置的标签扫描成一个PropertyValue，然后最后在初始化实例化bean过后就是填充属性的这个方法applyPropertyValues会将找到的bean填充到bean的属性中，也就是注入到bean的属性中；
如果说xml的方式要通过自动注入怎么做呢？因为一个bean中如果要注入的属性太多，而且你写xml还容易出错，所以xml也提供了一个自动注入的，自动注入分为byType和byName的方式；byName就很简单了，buName就是根据你的属性的set方法，比如setUserSerivce，那么会截取set，得到userService，去spring容器中找，如果找到了就添加到PropertyValues中，后面会调用applyPropertyValues注入，如果没有找到就不注入；如果是byType的方式，就负责点了，首先byType如果找到多个，要报错的，因为xml的自动注入的byType方式找到多个是要报错的，比如这种：

<bean name="orderService" class="com.bml10.service.OrderService">


</bean>
<bean name="orderService1" class="com.bml10.service.OrderService" />

<bean name="userService" class="com.bml10.service.UserService" autowire="byType">
</bean>

所以xml的自动注入通过byType的方式还是有缺陷的，万一你不小心注入了两个相同类型的bean，byType方式将会不成功；这里再说下，spring的xml的自动注入还有中全局的方式，就是在beans标签中设置一个全局的属性default-autowire

但是请注意的是设置了全局，那么每个bean里面就不需要设置了，但是如果你的某个bean设置了autowire，那么是局部生效的，不会用全局的，这个特性记住就行。

xml自动注入源码

刚刚上面演示的是spring的xml自动注入的例子，演示过后，我们来看下源码，源码在populateBean中，populateBean方法中的xml自动注入源码片段如下：

/**
 * 下面的这段逻辑处理的是依赖注入，其实下面的代码主要处理xml中的配置的依赖注入
 * 在xml中可以配置byType or byName的依赖注入
 * spring中的依赖注入分为几种模式：
 * 1.手动模式:在xml中配置Property属性，通过set方法进行注入，构造方法注入
 * 2.自动模式：xml中配置autoWier属性（byType or byName),在注解中配置@AutoWired
 * @Autowired可以注入属性，构造方法以及普通的方法
 *下面的代码主要处理在xml中配置了autowire属性的依赖注入
 * 也就是<bean id="xx" class="com.xx" autowire="byType" />
 * 这样配置了话，那么就会根据autowire来进行依赖注入，就不需要写
 * <Property name="" ref=""/>,还有种方式就是在beans中设置全局的default-autowire
 */

//下面的pvs就是找到在扫描过程中，如果xml配置了Property属性的标签会解析成PropertyValue
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

//得到在xml中配置的autowire属性值，比如配置了autowire="byType"，那么resolvedAutowireMode就会有值2
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
//在xml配置了byType or byName才会进入下面的依赖注入
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
   /**
    * 下面的是xml的依赖注入，现在使用注解的模式基本上是用不到，但是为了解释清楚，这里还是进行解析一下
    * 其中分了两种默认，byType 和byName,byName的比较好理解
    * byName：根据bean找到bean下面的所有set方法，比如setUserService,那么会截取set得到userService，然后去
    * bd中找，如果找到了，然后进注入到pvs中，在本方法的最后applyPropertyValues进入设置属性进去
    * byType：byType就比较复杂一点
    */
   //先声明一个MutablePropertyValues，把原来的PropertyValues传进去，如果pvs为空，则构建一个list集合
   MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
   // Add property values based on autowire by name if applicable.
   if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
      //这个是以byName进行注入，bw是包装的bean对象，mbd是BeanDefinition，newpvs是属性注入的对象
      autowireByName(beanName, mbd, bw, newPvs);
   }
   // Add property values based on autowire by type if applicable.
   if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
      //byType里面处理的逻辑有点复杂，我看了下，实现原理大概如下：
      //1.先根据bean所在的类找到所有的set方法，然后得到set方法对应的名字，也就是beanName集合
      //然后循环这个集合，将beanName装载成一个属性描述器，然后根据属性描述器得到方法参数对象MethodParameter
      //2.然后在根据MethodParameter封装成一个byType的依赖描述器，请注意，只有byType才实行了依赖描述器的实现类
      //byName是没有的，封装成一个byType的依赖描述器过后，根据这个依赖描述器获取bean，简单来说，就是你ref=“bean”中的
      //bean在容器中的bean对象信息，那出来然后注入到newpvs中，在下面的applyPropertyValues方法填充进去
      autowireByType(beanName, mbd, bw, newPvs);
   }
   pvs = newPvs;
}

autowireByName

protected void autowireByName(
      String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
        //找到这个bean中所有的set方法，并且根据set方法截取beanname,并且返回一个beanName所对应的名字集合
   String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
   //根据方法返回的属性名字，循环这个beannames集合
   for (String propertyName : propertyNames) {
      if (containsBean(propertyName)) {
         //创建bean或者获取bean然后注入到pvs中
         Object bean = getBean(propertyName);
         pvs.add(propertyName, bean);
         //下面是注入依赖的信息，表示我的这个bean依赖了那些bean
         registerDependentBean(propertyName, beanName);
         if (logger.isTraceEnabled()) {
            logger.trace("Added autowiring by name from bean name '" + beanName +
                  "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
         }
      }
      else {
         if (logger.isTraceEnabled()) {
            logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
                  "' by name: no matching bean found");
         }
      }
   }
}

autowireByType

protected void autowireByType(
      String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

   TypeConverter converter = getCustomTypeConverter();
   if (converter == null) {
      converter = bw;
   }

   Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
   String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
   for (String propertyName : propertyNames) {
      try {
         //属性名字也就是通过set方法得到的beanName获取一个属性描述器
         PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
         // Don't try autowiring by type for type Object: never makes sense,
         // even if it technically is a unsatisfied, non-simple property.
         //这里是判断是你的属性描述器，也就是说你的set方法的参数的类型不能是Object
         //因为如果setUserService(Object userService),那么像这个方法，如果是Object，spring根本不知道你要注入那个bean
         //所以不能是Object
         if (Object.class != pd.getPropertyType()) {
            //根据属性描述器获取这个set方法的参数信息
            MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
            // Do not allow eager init for type matching in case of a prioritized post-processor.
            boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
            /**
             *
             * 根据方法的参数MethodParameter获取一个bean
             * 到这里知道这个方法是byType，byType的原理是根据你的set方法的参数类型得到一个bean，所以这里是通过
             * set方法的参数比如setUserService(UserService uservice)中的UserService来构建一个依赖描述器
             * 这个依赖描述器得到过后，根据这个依赖描述器和其他一些参数得到一个bean
             */
            DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
            //这个里面的方法有点复杂，大概是知道它做了什么事儿，后面有空再去看下它是如何处理的
            //简单来说就是根据依赖描述器通过下面这个方法得到一个Bean，然后注入到pvs中
            Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
            if (autowiredArgument != null) {
               pvs.add(propertyName, autowiredArgument);
            }
            //循环注入到当前bean所依赖的bean，autowiredBeanNames是当前bean锁依赖的bean集合
            for (String autowiredBeanName : autowiredBeanNames) {
               registerDependentBean(autowiredBeanName, beanName);
               if (logger.isTraceEnabled()) {
                  logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
                        propertyName + "' to bean named '" + autowiredBeanName + "'");
               }
            }
            autowiredBeanNames.clear();
         }
      }
      catch (BeansException ex) {
         throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
      }
   }
}

xml的自动注入看上面的源码分析都是不会马上注入，而是添加到pvs中，最后调用applyPropertyValues方法进行属性填充的，所以我们这里总结出一个结论就是
spring 的xml方式注入依赖，分为手动和自动，手动的时候spring会将属性扫描到pvs中，然后如果是自动的话，自动获取的属性对应关系也会放入pvs中，最后调用applyPropertyValues进行属性填充。

以@AutoWired的方式

1.属性方式注入
2.普通非静态方法的注入
3.构造方法的注入

这篇笔记中，我们主要记录下上面几种注入方式中的非构造方法的注入，构造方法的注入在后面会有记录

spring的注解依赖注入

sprng的注解方式@AutoWired注入模式和上面的不太一样，@AutoWired有三种注入模式：
1.属性注入
2.非静态方法注入
3.构造方法注入
这里只讲前两种，第三中在后面讲，@AutoWired注入分为两步，第一步是找到注入点，然后放入缓存，第二步是从缓存获取注入点进行注入,spring中的依赖注入@AutoWired也是通过AutowiredAnnotationBeanPostProcessor这个bean后置处理器实现的，这个后置处理器中提供了两个方法，spring分别是在实例化后初始化前调用，这两个方法是postProcessMergedBeanDefinition和postProcessProperties，其中postProcessMergedBeanDefinition是找到bena的注入点，而postProcessProperties是进行注入，先来看下如何找到注入点的源码，注入点的源码是在doCreateBean中实现的

doCreateBean之注入点

synchronized (mbd.postProcessingLock) {
   if (!mbd.postProcessed) {
      try {
         //spring提供的又一个bean后置处理器，就是在bean实例化完成过后，可以进行调用
         //这个后置处理器可以传入指定的BeanDefinition，也就是你可以改变BeanDefinition的属性
         //但是这个时候bean都已经实例化完成了，就算你修改了beanclass也没有用了
         //但是有些属性我们还是可以设置的，比如可以手动设置初始化的方法mbd.setInitMethodName
         //@AutoWired注解的切入点就是在这个后置处理器中找到的并且注入到缓存中
         applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
      }
      catch (Throwable ex) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "Post-processing of merged bean definition failed", ex);
      }
      mbd.postProcessed = true;
   }
}
/**
 * Apply MergedBeanDefinitionPostProcessors to the specified bean definition,
 * invoking their {@code postProcessMergedBeanDefinition} methods.
 * @param mbd the merged bean definition for the bean
 * @param beanType the actual type of the managed bean instance
 * @param beanName the name of the bean
 * @see MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition
 * 这个方法我个人的理解是可以被叫做合并bean过后的bean后置处理器
 * @AutoWired注解和@Value以及@Inject注解都是在这个后置处理器中实现的
 * 具体的后置处理器是AutowiredAnnotationBeanPostProcessor,在里面调用了postProcessMergedBeanDefinition
 */
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof MergedBeanDefinitionPostProcessor) {
         MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
         bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
      }
   }
}

后置处理器中调用的是postProcessMergedBeanDefinition，这个后置处理器是在AutowiredAnnotationBeanPostProcessor，所以我们看下AutowiredAnnotationBeanPostProcessor类中的注入点代码

postProcessMergedBeanDefinition

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
   //找到所有的注入点@AutoWired
   InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
   metadata.checkConfigMembers(beanDefinition);
}

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
      // Fall back to class name as cache key, for backwards compatibility with custom callers.
      String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
      // Quick check on the concurrent map first, with minimal locking.
      /**
       * 先从缓存中获取，如果缓存中没有，就去根据bean的类去找到，找到过后注入到injectionMetadataCache缓存中
       * 我们知道@AutoWired注入可以通过属性、普通方法、构造进行注入，这里对属性和普通方法进行注入
       */
      InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
      if (InjectionMetadata.needsRefresh(metadata, clazz)) {
         synchronized (this.injectionMetadataCache) {
            metadata = this.injectionMetadataCache.get(cacheKey);
            if (InjectionMetadata.needsRefresh(metadata, clazz)) {
               if (metadata != null) {
                  metadata.clear(pvs);
               }
               //如果metadata不为空，则去找注入点，如果注入点为空那么metadata=InjectionMetadata.EMPTY
               metadata = buildAutowiringMetadata(clazz);
               //找到过后放入缓存
               this.injectionMetadataCache.put(cacheKey, metadata);
            }
         }
      }
      return metadata;
   }

   private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
      //注意，这里不是判断clzz是否实现了@AutoWired,@Value @Inject注解，这里的判断很简单
      //1.你传入的clazz如果是java.开头的则证明是java的内置的类，那么就返回false
      //2.你传入的autowiredAnnotationTypes是否是java开头的注解
      if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
         return InjectionMetadata.EMPTY;
      }

      List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
      Class<?> targetClass = clazz;

      /**
       * 下面用了一个do while循环去找注入点，
       * 这里需要注意的是为什么要用do while，很简单的例子就是比如一个UserServce加了一个注解，那么是继承了BaseService
       * 而BaseService中没有加@Componet，但是UserService加了@Component注解，那么这个时候以UserService为bean去找注入点
       * spring会找到他的父类，一级一级的往上找，直到找到最顶层的类，所以在父类中加了@AutoWired等注解，就算父类没有@Component
       * 也是可以找到摈弃注入的
       * 下面的循环中是分了两部分来找的，第一部分是属性的注入，第二部分是普通方法的注入，而构造方法的注入不在这里
       */
      do {
         final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

         //属性的注入点寻找,下面使用的是java8的lambad表达式的方式，这里不关心，关心的是lambad里面的逻辑
         ReflectionUtils.doWithLocalFields(targetClass, field -> {
                //循环每个属性，看下属性是否实现了@AutoWired,@Value @Inject注解,如果没有实现，那么就会返回null
            MergedAnnotation<?> ann = findAutowiredAnnotation(field);
            if (ann != null) {
               //spring规定的是静态属性不能注入，也就是说你写的private static UserSerivce userService;
                     //是不能注入的
               if (Modifier.isStatic(field.getModifiers())) {
                  if (logger.isInfoEnabled()) {
                     logger.info("Autowired annotation is not supported on static fields: " + field);
                  }
                  return;
               }
               //这里读取的是@AutoWired上面的required,这个属性默认是true，sping这里的意思就是说
//             //如果你配置了required属性，如果这个属性为false，那么在注入的过程中如果没有找到，注入失败了，那么就不会报错
//             //如果设置为true，那么如果没有注入成功，会报异常
               boolean required = determineRequiredStatus(ann);
               //找到过后然后放入currElements缓存，这里的放入的对象是AutowiredFieldElement，就是针对属性的注入
               currElements.add(new AutowiredFieldElement(field, required));
            }
         });

         //下面的这个方法是针对普通方法注入的处理
         ReflectionUtils.doWithLocalMethods(targetClass, method -> {
            Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
            if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
               return;
            }
            //这里也是去判断普通注入的方法是否有@AutoWired,@Value @Inject注解
            MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
            //如果方法有注解，并且方法是合法的，那么就进入找寻普通方法注入点的逻辑
            if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
               //相同的是注入的方法不能是静态方法
               if (Modifier.isStatic(method.getModifiers())) {
                  if (logger.isInfoEnabled()) {
                     logger.info("Autowired annotation is not supported on static methods: " + method);
                  }
                  return;
               }
               //方法的参数也不能是空，因为@AutoWired方法的注入是通过方法的参数类型进行注入的
               if (method.getParameterCount() == 0) {
                  if (logger.isInfoEnabled()) {
                     logger.info("Autowired annotation should only be used on methods with parameters: " +
                           method);
                  }
               }
               //和属性注入的逻辑一样
               boolean required = determineRequiredStatus(ann);
               //在这里将方法生成一个属性描述器，这里面判断了是写入方法还是读取方法
//             这里的没隔方法的一些细节逻辑封装的有点多，我在这里大部分是为了把spirng的大部分逻辑和思想得到
               //所以一些特别处理的地方就没有去细看，有兴趣的可以去细看下，比如下面这行代码是如何处理的
               PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
               //封装好了AutowiredMethodElement，然后放入缓存
               currElements.add(new AutowiredMethodElement(method, required, pd));
            }
         });

         //每次循环找到注入点注入到currElements后，加入到elements
         elements.addAll(0, currElements);
         //每次本类找到过后，然后获取父类，一级一级的往上找
         targetClass = targetClass.getSuperclass();
      }
      while (targetClass != null && targetClass != Object.class);
      //这里将找到的注入点elements封装成一个InjectionMetadata返回，如果elements=null，那么封装的是InjectionMetadata.EMPTY
      return InjectionMetadata.forElements(elements, clazz);
   }

   @Nullable
   private MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {
      MergedAnnotations annotations = MergedAnnotations.from(ao);
      for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
         MergedAnnotation<?> annotation = annotations.get(type);
         if (annotation.isPresent()) {
            return annotation;
         }
      }
      return null;
   }
   public AutowiredAnnotationBeanPostProcessor() {
   this.autowiredAnnotationTypes.add(Autowired.class);
   this.autowiredAnnotationTypes.add(Value.class);
   try {
      this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
            ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
      logger.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
   }
   catch (ClassNotFoundException ex) {
      // JSR-330 API not available - simply skip.
   }
}

源码的注释在上面都已经写了，这边总结下spring的依赖注入@AutoWired的找寻注入点的原理：
1.spring在这个后置处理器中提供了两种方式的依赖注入，属性注入和普通非静态方法的注入；
2.首先根据传过来的bean，找到所有的声明的属性和方法，然后循环这个类，因为这个类可能有父类，找寻要找到所有的父类中看是否有注入的属性和方法，是根据是否实现了@AutoWired来找的；
3.如果找到了属性或者方法，那么如果是属性，就构造一个对象AutowiredFieldElement 或者AutowiredMethodElement，放入缓存，属性对象和方法对象都实现了InjectionMetadata.InjectedElement，所以这两个对象中都实现了inject方法，用来后面注入的。
4.InjectElement就是注入的对象点，也就是需要依赖注入的属性或者方法都保存在InjectElement里面，我们来看下InjectElement这个对象的结构:

/**
 * A single injected element.
 * 注入点，spring的依赖注入的注入点就是InjectedElement
 * member可以是Field或者Method
 */
public abstract static class InjectedElement {

   //注入的成员类型，Field或者Member
   protected final Member member;
       //注入点是否是属性Field
   protected final boolean isField;

   //属性的描述器，如果是属性注入的注入点，那么这个pd值是空的，只有方法的注入才有
   @Nullable
   protected final PropertyDescriptor pd;

   @Nullable
   protected volatile Boolean skip;

   protected InjectedElement(Member member, @Nullable PropertyDescriptor pd) {
      //member中可以是Field可以是method
      this.member = member;
      this.isField = (member instanceof Field);
      this.pd = pd;
   }
   ......

其中member可以是属性可以是方法，就根据你存入的是AutowiredMethodElement还是AutowiredFieldElement；
5.最后找到的所有注入点都缓存到对象private final Map<String, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap<>(256)中；

@AutoWired依赖注入

@AutoWired的依赖注入也是在bean的后置处理器中实现的，具体的代码是在populateBean这个方法里面，代码片段如下:

/**
    * 这里调用的又是bean的后置处理器，这里的后置处理器是在bean属性填充过后的bean后置处理器
    * 这个后置处理器正在现在用的最多，spring内部定义的InstantiationAwareBeanPostProcessor实现了这个接口，主要处理的是
    * @AutoWired的后置处理器，依赖注入的在这里调用的，最重要的是postProcessProperties这个方法
    * 所以InstantiationAwareBeanPostProcessor的后置处理器方法postProcessProperties是处理@AutoWired @Resource注解的
    * 具体来说就是：
    * @AutowiredannotationBeanPostProcessor处理的是@AutoWired、@Value，@Inject注解
    * @CommonAnnotationBeanPostProcessor处理的是@Resource注解
    * 都是在postProcessProperties方法中处理的
    */
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof InstantiationAwareBeanPostProcessor) {
         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
         PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
         if (pvsToUse == null) {
            if (filteredPds == null) {
               filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
               return;
            }
         }
         pvs = pvsToUse;
      }
   }
}

主要是调用后置处理器中的方法postProcessProperties

public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
   //在实例化过后调用的后置处理器先将注入点找到并且准入到了缓存injectionMetadataCache中了
   //所以这里的就是从缓存中获取，当然了如果在前面的后置处理器中没有注入成功，那么这个也会去注入，一般不会出现这种情况
   //metadata就是bean类的所有注入点，只包括两种：普通非静态方法的注入点和非静态属性的注入点
   //这里的注入点有两个，属性和犯法，所以下面的调用也分为两种
   InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
   try {
      //开始注入，这里的注入根据是属性和方法调用不同的注入方式
      //AutowiredFieldElement属性的注入
      //AutowiredMethodElement是方法的注入
      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;
}

上面的代码的inject是根据是属性注入还是方法注入调用具体的方法，AutowiredFieldElement中的inject方法和AutowiredMethodElement中的inject方法

AutowiredFieldElement.inejct

/**
       * 这里就是根据属性注入的逻辑
       * @param bean
       * @param beanName
       * @param pvs
       * @throws Throwable
       */
      @Override
      protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
         Field field = (Field) this.member;
         Object value;
         if (this.cached) {
            value = resolvedCachedArgument(beanName, this.cachedFieldValue);
         }
         else {
//          和xml那边一模一样的，就是先通过属性来构造一个依赖描述器
            DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
            desc.setContainingClass(bean.getClass());
            Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
            Assert.state(beanFactory != null, "No BeanFactory available");
            TypeConverter typeConverter = beanFactory.getTypeConverter();
            try {
               //然后通过依赖描述器来找到一个bean，请注意，这里是属性的依赖注入，比如private UserService uservice
//             //那么这里是来找到bean类下面的属性UserService在spring容器中的ben对象，也就是value
               //resolveDependency在这里是先byType，再byName，当byType有多个的时候，就要进行byName,所以在
//             //在spring中写注入@AutoWired对应的属性名称的时候尽量规范一点
               value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
            }
            catch (BeansException ex) {
               throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
            }
            //下面的逻辑是如果开启了缓存cached，默认是false，然后取出注入的属性名称，也就是beanName，然后判断，设置缓存字段值
            synchronized (this) {
               if (!this.cached) {
                  if (value != null || this.required) {
                     this.cachedFieldValue = desc;
                     registerDependentBeans(beanName, autowiredBeanNames);
                     if (autowiredBeanNames.size() == 1) {
                        String autowiredBeanName = autowiredBeanNames.iterator().next();
                        if (beanFactory.containsBean(autowiredBeanName) &&
                              beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
                           this.cachedFieldValue = new ShortcutDependencyDescriptor(
                                 desc, autowiredBeanName, field.getType());
                        }
                     }
                  }
                  else {
                     this.cachedFieldValue = null;
                  }
                  this.cached = true;
               }
            }
         }
         if (value != null) {
            //如果找到了注入的bena，然后通过反射进行注入
            ReflectionUtils.makeAccessible(field);
            field.set(bean, value);
         }
      }
   }

AutowiredMethodElement.inject

/**
       * 方法的注入，方法注入的要点是：
       * 1.方法必须是普通的非静态方法（非构造方法，构造方法不在此处处理）
       * 2.方法的参数个数必须大于0，也就是至少为1个
       * 3.然后根据前两个条件，然后循环每一个方法的参数，请注意，每个参数应该都是一个bean对象，
       * 然后封装一个参数数组，最后通过反射调用方法进行注入
       * spring代码写的很多，但是我们研究spring的源码要看关键部分，关键部分就是它如何进行依赖注入的
       * 通过属性和普通方法，至于一些很细的细节，就算你现在弄清楚了，过一段时间也会忘，所以太细的如果不太理解，就飘过
       * @param bean
       * @param beanName
       * @param pvs
       * @throws Throwable
       */

      @Override
      protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
         if (checkPropertySkipping(pvs)) {
            return;
         }
//       方法的注入，member强制转换成一个Method
         Method method = (Method) this.member;
         Object[] arguments;
         if (this.cached) {
            // Shortcut for avoiding synchronization...
            arguments = resolveCachedArguments(beanName);
         }
         else {
            //得到方法参数的个数，并且封装一个Object arguments
            int argumentCount = method.getParameterCount();
//          //这个数组存放的是每个参数对应的bean在spring容器中的bean对象
            arguments = new Object[argumentCount];
            //这里存放的是每个参数对应在spring容器中的bean对象构建的依赖描述器
            DependencyDescriptor[] descriptors = new DependencyDescriptor[argumentCount];
            Set<String> autowiredBeans = new LinkedHashSet<>(argumentCount);
            Assert.state(beanFactory != null, "No BeanFactory available");
            TypeConverter typeConverter = beanFactory.getTypeConverter();
            //下面的代码逻辑就是循环每个方法参数，然后从spring容器中获取bean，然后填充到arguments中
//          逻辑都和属性注入一样，通过依赖描述器调用resolveDependency来获取一个bean对象
            for (int i = 0; i < arguments.length; i++) {
               MethodParameter methodParam = new MethodParameter(method, i);
               DependencyDescriptor currDesc = new DependencyDescriptor(methodParam, this.required);
               currDesc.setContainingClass(bean.getClass());
               descriptors[i] = currDesc;
               try {
                  Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);
                  if (arg == null && !this.required) {
                     arguments = null;
                     break;
                  }
                  arguments[i] = arg;
               }
               catch (BeansException ex) {
                  throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(methodParam), ex);
               }
            }
            synchronized (this) {
               if (!this.cached) {
                  if (arguments != null) {
                     DependencyDescriptor[] cachedMethodArguments = Arrays.copyOf(descriptors, arguments.length);
                     registerDependentBeans(beanName, autowiredBeans);
                     if (autowiredBeans.size() == argumentCount) {
                        Iterator<String> it = autowiredBeans.iterator();
                        Class<?>[] paramTypes = method.getParameterTypes();
                        for (int i = 0; i < paramTypes.length; i++) {
                           String autowiredBeanName = it.next();
                           if (beanFactory.containsBean(autowiredBeanName) &&
                                 beanFactory.isTypeMatch(autowiredBeanName, paramTypes[i])) {
                              cachedMethodArguments[i] = new ShortcutDependencyDescriptor(
                                    descriptors[i], autowiredBeanName, paramTypes[i]);
                           }
                        }
                     }
                     this.cachedMethodArguments = cachedMethodArguments;
                  }
                  else {
                     this.cachedMethodArguments = null;
                  }
                  this.cached = true;
               }
            }
         }
         if (arguments != null) {
            try {
               //然后进行调用，就类似于setXxx(UserService u1,UsereSerivce u2),两个参数就是argumentgs
               //arguments就是上面循环从spring容器中获取的
               ReflectionUtils.makeAccessible(method);
               method.invoke(bean, arguments);
            }
            catch (InvocationTargetException ex) {
               throw ex.getTargetException();
            }
         }
      }

大概总结下spring的@AutoWired依赖注入的要点：
1.从缓存中获取注入点，然后开始循环注入点；
2.如果是属性的注入点，那么就调用AutowiredFieldElement中的inject方法，在该方法中处理不用看spring源码大家也能知道，无非就是通过反射对feild进行赋值，也就是set方法区赋值，但是这里有点重要的点就是spring的@AutoWired是先byType，在byName的，什么意思呢？在注入的方法中有个方法特别重要就是resolveDependency，这个方法就是根据你注入的属性去spring的容器中找到对应的bean；比如我们有个属性是private UserService userservice；那么spring会根据userserivce去spring容器中找到，找到了直接返回，然后调用field.set进行注入赋值；但是在这个过程中spring的处理方式是：
先根据byType，也就是你的UserService找到对应的bean对象列表，这个时候分为三种情况：
1）.如果为空，则证明在spring容器中不存在这个bean，如果这个时候你的@AutoWired设置了required属性，并且为false，那么就注入不成功；
2）.如果不为空，只有一条数据，则证明在容器中已经找到了相对应的bean，直接返回注入就可了。
3）.如果返回多条，则证明在容器中存在多个相同的Bean对象，那么这个时候就要开始byName,根据字段的byName得到唯一的一个Bean，所以spring的@AutoWired依赖注入是先byType，在byName的。

3.如果是方法的注入点，那就调用AutowiredMethodElement中的inject方法，找bean的方式和属性的是一样的，我只是说byType和byName的方式和属性的是一样的，一样的调用了resolveDependency这个方法；但是方法的注入和属性注入不一样，比如我的注入方法如下：

public void setxxx(UserService userServie){
     .....
}
public void setxxx(UserService userServie,OrderService){
     .....
}

所以方法注入的要看方法的参数，所以spring的方法注入需要遵循两点：
1.方法的参数不能为空，为空谈何注入；
2.方法必须是普通的非静态方法。
那么spring会构建一个arguments数组，然后获取每个参数，然后根据参数去spring容器中找bean，找bean的过程也是先byType再byName，找到过后赋值给arguments[i]=object，最后找到了所有的参数对应的bean过后，执行
method.invoke(target,arguments)进行反射调用方法注入进行注入。

@Autowired例子演示

上面已经把@AutoWired的依赖注入的源码分析，但是我们要如何证明所述，其实属性的注入我就不演示不证明了，这个大家都用非常多，肯定是能注入的，我主要演示下方法的注入，一个参数和多个参数的方法注入：

@Component
public class UserService {


   private OrderService orderService1;

   private OrderService orderService2;

   @Autowired
   public void xxx(OrderService o1,OrderService o2){
      this.orderService1 = o1;
      this.orderService2 = o2;
   }




   public void test()
   {
      System.out.println("orderService1="+ orderService1);
      System.out.println("orderService2="+ orderService2);
   }
}

我的orderService1和orderService2都没有加@AutoWired注解，而是通过xxx方法进行注入的，看输出结果如下

所以spring是肯定能支持普通方法注入和属性注入的
最后附上一张@AutoWired依赖注入的图，仅供参考：

本文地址：https://blog.csdn.net/scjava/article/details/109275867