spring--3--spring中的非注解方式自动注入

清疚 2022-12-28 04:23 197阅读 0赞

# spring中非注解方式的自动注入 #

xml配置文件配置的自动注入。这是一种过时的技术，现在基本上没人用了。

我以一个例子来说明一下这个技术

## 1 项目xml配置 ##

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        
    	
        <bean id="person" class="cn.lx.spring.v1.Person" autowire="byType"></bean>
    
        <bean id="user" class="cn.lx.spring.v1.User">
            <property name="age" value="12"></property>
            <property name="name" value="LX"></property>
        </bean>
    
    </beans>

## 2 一些基本类 ##

**User**

public class User { 
    
        private String name;
        private String password;
        private int age;
    
        public User() { 
        }
    
        public User(String name, String password) { 
            this.name = name;
            this.password = password;
        }
    
        @Override
        public String toString() { 
            return "User{" +
                    "name='" + name + '\'' +
                    ", password='" + password + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() { 
            return name;
        }
    
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public String getPassword() { 
            return password;
        }
    
        public void setPassword(String password) { 
            this.password = password;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    }

**Person**

public class Person { 
    
        private User user;
    
        private String type;
        
        public Person() { 
        }
    
        public Person(User user) { 
            this.user = user;
        }
    
        @Override
        public String toString() { 
            return "Person{" +
                    "user=" + user +
                    ", type='" + type + '\'' +
                    '}';
        }
    
        public String getType() { 
            return type;
        }
    
        public void setType(String type) { 
            this.type = type;
        }
    
        public User getUser() { 
            return user;
        }
    
        public void setUser(User user) { 
            this.user = user;
        }
    }

**启动入口**

public static void main(String[] args) { 
        //声明一个可以读取xml配置文件的容器
        ClassPathXmlApplicationContext classPathXmlApplicationContext=new
                ClassPathXmlApplicationContext();
    
        //设置配置文件
        classPathXmlApplicationContext.setConfigLocation("spring-context.xml");
    
        //刷新容器,这是spring中最重要的方法，看懂了这个方法，bean的生命周期也就懂了
        classPathXmlApplicationContext.refresh();
    
        Person person = (Person) classPathXmlApplicationContext.getBean("person");
     
        System.out.println(person);
    
    }

**效果**

Person{ user=User{ name='LX', password='null', age=12}, type='null'}

## 3 bean创建 ##

了解bean的生命周期，直接debug进入bean实例化的方法

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center]

如上图所示，`doCreateBean`方法开始创建`Person`对象

/** * Actually create the specified bean. Pre-creation processing has already happened * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks. * <p>Differentiates between default bean instantiation, use of a * factory method, and autowiring a constructor. * @param beanName the name of the bean * @param mbd the merged bean definition for the bean * @param args explicit arguments to use for constructor or factory method invocation * @return a new instance of the bean * @throws BeanCreationException if the bean could not be created * @see #instantiateBean * @see #instantiateUsingFactoryMethod * @see #autowireConstructor */
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException { 
    
        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) { 
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) { 
            //这里使用调用构造方法反射实例化，此处没有对属性赋值
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) { 
            mbd.resolvedTargetType = beanType;
        }
    
        // Allow post-processors to modify the merged bean definition.
        synchronized (mbd.postProcessingLock) { 
            if (!mbd.postProcessed) { 
                try { 
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) { 
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                    "Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }
    
        // Eagerly cache singletons to be able to resolve circular references
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                          isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) { 
            if (logger.isTraceEnabled()) { 
                logger.trace("Eagerly caching bean '" + beanName +
                             "' to allow for resolving potential circular references");
            }
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
    
        // Initialize the bean instance.
        Object exposedObject = bean;
        try { 
            //属性赋值，自动注入就是在此处完成的
            populateBean(beanName, mbd, instanceWrapper);
            //初始化
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) { 
            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { 
                throw (BeanCreationException) ex;
            }
            else { 
                throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
            }
        }
    
        if (earlySingletonExposure) { 
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) { 
                if (exposedObject == bean) { 
                    exposedObject = earlySingletonReference;
                }
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                    for (String dependentBean : dependentBeans) { 
                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    if (!actualDependentBeans.isEmpty()) { 
                        throw new BeanCurrentlyInCreationException(beanName,
                                                                   "Bean with name '" + beanName + "' has been injected into other beans [" +
                                                                   StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                                                                   "] in its raw version as part of a circular reference, but has eventually been " +
                                                                   "wrapped. This means that said other beans do not use the final version of the " +
                                                                   "bean. This is often the result of over-eager type matching - consider using " +
                                                                   "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }
    
        // Register bean as disposable.
        try { 
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) { 
            throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }
    
        return exposedObject;
    }

看似上面很长，其实核心方法就三个

(1) `createBeanInstance` 使用反射调用构造方法实例化

(2) `populateBean` 属性赋值，自动注入就是在此处完成的

(3) `initializeBean` 初始化

(3)不是重点，我们重点看（1）(2)中的自动注入

### 3.1 createBeanInstance 实例化阶段 ###

/** * Create a new instance for the specified bean, using an appropriate instantiation strategy: * factory method, constructor autowiring, or simple instantiation. * @param beanName the name of the bean * @param mbd the bean definition for the bean * @param args explicit arguments to use for constructor or factory method invocation * @return a BeanWrapper for the new instance * @see #obtainFromSupplier * @see #instantiateUsingFactoryMethod * @see #autowireConstructor * @see #instantiateBean */
    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { 
        // Make sure bean class is actually resolved at this point.
        //获取需要实例化的bean的类型
        Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { 
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                            "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        }
    
        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) { 
            return obtainFromSupplier(instanceSupplier, beanName);
        }
    
        //工厂方法实例化对象
        if (mbd.getFactoryMethodName() != null) { 
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }
    
        // Shortcut when re-creating the same bean...
        //重新创建对象的快捷方式
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) { 
            synchronized (mbd.constructorArgumentLock) { 
                if (mbd.resolvedConstructorOrFactoryMethod != null) { 
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        if (resolved) { 
            if (autowireNecessary) { 
                return autowireConstructor(beanName, mbd, null, null);
            }
            else { 
                return instantiateBean(beanName, mbd);
            }
        }
    /********************************构造方法自动注入*******************************/
        // Candidate constructors for autowiring?
        //可以使用SmartInstantiationAwareBeanPostProcessor这个增强器来干预使用哪个构造方法实例化对象
        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        /** * mbd.getResolvedAutowireMode() 获取自动注入的模式 * 如果指定了autowire="constructor"，就开始贪婪匹配构造方法，实例化对象 */
        if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { 
            //constructor自动注入实例化对象，见6
            return autowireConstructor(beanName, mbd, ctors, args);
        }
    
        // Preferred constructors for default construction?
        //获取首选的默认构造方法
        ctors = mbd.getPreferredConstructors();
        if (ctors != null) { 
            return autowireConstructor(beanName, mbd, ctors, null);
        }
    
        // No special handling: simply use no-arg constructor.
        //使用无参构造方法
        return instantiateBean(beanName, mbd);
    }

### 3.2 populateBean 属性赋值阶段 ###

/** * Populate the bean instance in the given BeanWrapper with the property values * from the bean definition. * @param beanName the name of the bean * @param mbd the bean definition for the bean * @param bw the BeanWrapper with bean instance */
    @SuppressWarnings("deprecation")  // for postProcessPropertyValues
    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { 
    /***************************************************************************************/
        //bw是spring对实例的一种包装，里面除了实例，还有实例类的class对象等等
       if (bw == null) { 
          if (mbd.hasPropertyValues()) { 
             throw new BeanCreationException(
                   mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
          }
          else { 
             // Skip property population phase for null instance.
             return;
          }
       }
    /***************************************************************************************/
       // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
       // state of the bean before properties are set. This can be used, for example,
       // to support styles of field injection.
        //InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法，手动赋值
       if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { 
          for (BeanPostProcessor bp : getBeanPostProcessors()) { 
             if (bp instanceof InstantiationAwareBeanPostProcessor) { 
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { 
                   return;
                }
             }
          }
       }
    /***************************************************************************************/
        /** * xml中的property标签内容会解析到BeanDefinition中的PropertyValues中 * <property name="age" value="12"></property> * <property name="name" value="LX"></property> */
       PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
    
         /** * xml中指定自动注入的类型 * (1)<beans default-autowire="byType"> beans中指定 * (2) <bean autowire="byType"></bean> bean中指定 * 一种可以指定4种 byType、byName、no、default */
       int resolvedAutowireMode = mbd.getResolvedAutowireMode();
       if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) { 
          MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
          // Add property values based on autowire by name if applicable.
          if (resolvedAutowireMode == AUTOWIRE_BY_NAME) { 
             //byName自动注入
             autowireByName(beanName, mbd, bw, newPvs);
          }
          // Add property values based on autowire by type if applicable.
          if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) { 
              //byType自动注入
             autowireByType(beanName, mbd, bw, newPvs);
          }
          pvs = newPvs;
       }
        
       /***************************************************************************************/
    
        //@Autowired、@Resource注解功能在此处实现
       boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
       boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
    
       PropertyDescriptor[] filteredPds = null;
       if (hasInstAwareBpps) { 
          if (pvs == null) { 
             pvs = mbd.getPropertyValues();
          }
          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;
             }
          }
       }
       if (needsDepCheck) { 
          if (filteredPds == null) { 
             filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
          }
          checkDependencies(beanName, mbd, filteredPds, pvs);
       }
    
    /***************************************************************************************/
       if (pvs != null) { 
           //将属性值设置到对象中
          applyPropertyValues(beanName, mbd, bw, pvs);
       }
    }

## 4 byType自动注入 ##

autowireByType(beanName, mbd, bw, newPvs);

进入该方法

/** * Abstract method defining "autowire by type" (bean properties by type) behavior. * <p>This is like PicoContainer default, in which there must be exactly one bean * of the property type in the bean factory. This makes bean factories simple to * configure for small namespaces, but doesn't work as well as standard Spring * behavior for bigger applications. * @param beanName the name of the bean to autowire by type * @param mbd the merged bean definition to update through autowiring * @param bw the BeanWrapper from which we can obtain information about the bean * @param pvs the PropertyValues to register wired objects with */
    protected void autowireByType(
        String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { 
    
        //获取自定义的TypeConverter
        //TypeConverter是定义类型转换的接口
        TypeConverter converter = getCustomTypeConverter();
        if (converter == null) { 
            //BeanWrapper是TypeConverter的子接口
            converter = bw;
        }
    
        Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
        //5.1 获取bean中非简单属性的名字（不是基础属性，基础属性的包装属性，string）
        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
        for (String propertyName : propertyNames) { 
            try { 
                //得到对应属性名字的属性描述
                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.
                //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);
                    DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                    //5.2解析依赖，获取依赖对应的对象
                    Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                    if (autowiredArgument != null) { 
                        //加入到MutablePropertyValues中，等待applyPropertyValues(beanName, mbd, bw, pvs);统一赋值
                        pvs.add(propertyName, autowiredArgument);
                    }
                    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);
            }
        }
    }

### 4.1 获取bean中非简单属性的名字 ###

/** * Return an array of non-simple bean properties that are unsatisfied. * These are probably unsatisfied references to other beans in the * factory. Does not include simple properties like primitives or Strings. * @param mbd the merged bean definition the bean was created with * @param bw the BeanWrapper the bean was created with * @return an array of bean property names * @see org.springframework.beans.BeanUtils#isSimpleProperty */
    protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) { 
       Set<String> result = new TreeSet<>();
        //得到需要设置值的所有属性的键值对
       PropertyValues pvs = mbd.getPropertyValues();
        /** * 获取当前bean的属性描述(必然包含当前类的class描述，它也是属性) * pd.getWriteMethod() 会获取当前属性set方法对象 * pd.getPropertyType() 获取当前属性的类型 * isExcludedFromDependencyCheck 当前属性是否被排除（排除cglib生成的类的内部属性， * spring容器的内部属性（实现了spring中的aware接口），这个需要通过BeanPostProcessor接口注入） * !pvs.contains(pd.getName()) 已有的属性集合中不包含（非手动注入过的属性） * !BeanUtils.isSimpleProperty(pd.getPropertyType()) 非简单属性 */
       PropertyDescriptor[] pds = bw.getPropertyDescriptors();
       for (PropertyDescriptor pd : pds) { 
          if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
                !BeanUtils.isSimpleProperty(pd.getPropertyType())) { 
             result.add(pd.getName());
          }
       }
       return StringUtils.toStringArray(result);
    }

**总结**：

> 由此我们可以推断能自动注入的属性必须具备以下几点
> 
> （1）有对应的set方法
> 
> （2）非cglib生成的类的内部属性
> 
> （3）非通过spring中aware接口设置的属性，也就是说你可以注入容器内部属性，但是不能实现这个属性的aware接口
> 
> （4）非配置文件中手动注入的属性（property标签）
> 
> （5）非简单属性

### 4.2解析依赖，获取依赖对应的对象 ###

public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
                                    @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException { 
    
        /** * descriptor.getDependencyType() 解析set方法，获取set方法注入属性的类型 * Optional、ObjectFactory、ObjectProvider、javaxInjectProviderClass * 都是类型判断，这些类型有特殊的对象创建方式 */
        descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
        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 { 
            //空方法，无实现
            Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
                descriptor, requestingBeanName);
            if (result == null) { 
                //这里是真正获取依赖对象的方法
                result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
            }
            return result;
        }
    }

**解析依赖**

这里只是简单看一下方法的流程，具体的解析在注解方式的自动注入里面详细说明。

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类型
          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());
             try { 
                return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
             }
             catch (UnsupportedOperationException ex) { 
                // A custom TypeConverter which does not support TypeDescriptor resolution...
                return (descriptor.getField() != null ?
                      converter.convertIfNecessary(value, type, descriptor.getField()) :
                      converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
             }
          }
    
          //处理List<User> users这种类型的自动注入
          Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
          if (multipleBeans != null) { 
             return multipleBeans;
          }
    
           //根据类型获取匹配的bean（注解方式注入也是调用findAutowireCandidates这个方法处理）
          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;
    
           //说明有多个和该属性相同类型的bean
          if (matchingBeans.size() > 1) { 
              //获取配置中指定的候选bean
             autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
              //没有肯定报异常了
             if (autowiredBeanName == null) { 
                if (isRequired(descriptor) || !indicatesMultipleBeans(type)) { 
                   return descriptor.resolveNotUnique(descriptor.getResolvableType(), 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;
                }
             }
              //有就获取指定的候选bean
             instanceCandidate = matchingBeans.get(autowiredBeanName);
          }
           //说明只有一个和该属性相同类型的bean
          else { 
             // We have exactly one match.
             Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
             autowiredBeanName = entry.getKey();
              //instanceCandidate可以是已经实例化的对象，也可以是对应类型的class对象
             instanceCandidate = entry.getValue();
          }
    
          if (autowiredBeanNames != null) { 
             autowiredBeanNames.add(autowiredBeanName);
          }
           
           //如果是class类型，就实例化
          if (instanceCandidate instanceof Class) { 
             //该方法里面调用beanFactory.getBean(beanName)实例化
             instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
          }
           //赋值给result，返回result
          Object result = instanceCandidate;
           
           //对象是否为NullBean
          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);
       }
    }

**找到所有指定类型bean**

/** * Find bean instances that match the required type. * Called during autowiring for the specified bean. * @param beanName the name of the bean that is about to be wired * @param requiredType the actual type of bean to look for * (may be an array component type or collection element type) * @param descriptor the descriptor of the dependency to resolve * @return a Map of candidate names and candidate instances that match * the required type (never {@code null}) * @throws BeansException in case of errors * @see #autowireByType * @see #autowireConstructor */
    protected Map<String, Object> findAutowireCandidates(
        @Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) { 
    
        //找到容器中所有的符合requiredType类型的bean的名字（包括没有实例化的）
        String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
            this, requiredType, true, descriptor.isEager());
        Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
        /** * this.resolvableDependencies 有4个对象，都是容器内部对象 * ApplicationEventPublisher * ResourceLoader * ApplicationContext * BeanFactory * 这4中类型的属性在此处可以自动注入 */
        for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) { 
            Class<?> autowiringType = classObjectEntry.getKey();
            //autowiringType和requiredType类型相同或autowiringType是requiredType的超类
            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)) { 
                // 获取依赖candidate
                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;
    }

## 5 byName自动注入 ##

autowireByName(beanName, mbd, bw, newPvs);

进入该方法

/** * Fill in any missing property values with references to * other beans in this factory if autowire is set to "byName". * @param beanName the name of the bean we're wiring up. * Useful for debugging messages; not used functionally. * @param mbd bean definition to update through autowiring * @param bw the BeanWrapper from which we can obtain information about the bean * @param pvs the PropertyValues to register wired objects with */
    protected void autowireByName(
          String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { 
    
        //同样的方法，获取bean中的非简单属性的名字
       String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
        //遍历
       for (String propertyName : propertyNames) { 
          if (containsBean(propertyName)) { 
              //根据名字获取到对应的bean对象
             Object bean = getBean(propertyName);
              //添加到属性集合中，等待调用 applyPropertyValues(beanName, mbd, bw, pvs);
             pvs.add(propertyName, 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");
             }
          }
       }
    }

了解了byTpe，byName方式就非常简单了，只需要找到需要自动注入的属性名字，然后调用getBean方法获取容器中对应的Bean对象，设置到实例对象中就行了。

## 6 constructor自动注入 ##

我们这里单独指定`person`是构造方法自动注入

接下来，我们进入`autowireConstructor(beanName, mbd, ctors, args)`这个方法

进入`ConstructorResolver`的`autowireConstructor`方法

/** * "autowire constructor" (with constructor arguments by type) behavior. * Also applied if explicit constructor argument values are specified, * matching all remaining arguments with beans from the bean factory. * <p>This corresponds to constructor injection: In this mode, a Spring * bean factory is able to host components that expect constructor-based * dependency resolution. * @param beanName the name of the bean * @param mbd the merged bean definition for the bean * @param chosenCtors chosen candidate constructors (or {@code null} if none) * @param explicitArgs argument values passed in programmatically via the getBean method, * or {@code null} if none (-> use constructor argument values from bean definition) * @return a BeanWrapper for the new instance */
    public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
                                           @Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) { 
    
        //创建并初始化BeanWrapper
        BeanWrapperImpl bw = new BeanWrapperImpl();
        this.beanFactory.initBeanWrapper(bw);
    
        Constructor<?> constructorToUse = null;
        ArgumentsHolder argsHolderToUse = null;
        Object[] argsToUse = null;
    
        /** * getBean方法可以自定构造方法参数值 * <T> T getBean(Class<T> requiredType, Object... args) throws BeansException; */
        if (explicitArgs != null) { 
            argsToUse = explicitArgs;
        }
        else { 
            Object[] argsToResolve = null;
            synchronized (mbd.constructorArgumentLock) { 
                //获取缓存的构造方法和参数（主要为方便创建Protype类型的对象）
                constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse != null && mbd.constructorArgumentsResolved) { 
                    // Found a cached constructor...
                    argsToUse = mbd.resolvedConstructorArguments;
                    if (argsToUse == null) { 
                        //获取部分准备好的构造方法参数
                        argsToResolve = mbd.preparedConstructorArguments;
                    }
                }
            }
            //解析部分准备好的构造方法参数
            if (argsToResolve != null) { 
                argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
            }
        }
    
        if (constructorToUse == null || argsToUse == null) { 
            // Take specified constructors, if any.
            /** * 如果指定了构造方法，就从指定的构造方法找出最合适的构造方法 * 在bean实例化之前，会调用这个AutowiredAnnotationBeanPostProcessor增强器的 * determineCandidateConstructors方法，该方法返回有@Autowired注解的构造方法 * chosenCtors就是determineCandidateConstructors方法的返回值 */
            Constructor<?>[] candidates = chosenCtors;
            //为空的话，就先获取所有构造方法，然后从中找出最合适的构造方法实例化
            if (candidates == null) { 
                Class<?> beanClass = mbd.getBeanClass();
                try { 
                    /** * mbd.isNonPublicAccessAllowed() 判断是否允许使用非public的构造方法实例化对象 * beanClass.getDeclaredConstructors() 获取所有的构造方法 * beanClass.getConstructors() 只获取public的构造方法 */
                    candidates = (mbd.isNonPublicAccessAllowed() ?
                                  beanClass.getDeclaredConstructors() : beanClass.getConstructors());
                }
                catch (Throwable ex) { 
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                    "Resolution of declared constructors on bean Class [" + beanClass.getName() +
                                                    "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
                }
            }
    
    /*******************************单构造方法************************************/        
            if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) { 
                Constructor<?> uniqueCandidate = candidates[0];
                //构造方法参数个数为0，实际就是默认构造方法
                if (uniqueCandidate.getParameterCount() == 0) { 
                    //缓存构造方法和参数
                    synchronized (mbd.constructorArgumentLock) { 
                        mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                        mbd.constructorArgumentsResolved = true;
                        mbd.resolvedConstructorArguments = EMPTY_ARGS;
                    }
                    //使用该构造方法实例化
                    bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
                    return bw;
                }
            }
    
    /*******************************多构造方法************************************/         
            // Need to resolve the constructor.
            //要么指定了构造方法，要么开启了自动注入构造
            boolean autowiring = (chosenCtors != null ||
                                  mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
            ConstructorArgumentValues resolvedValues = null;
    
            int minNrOfArgs;
            if (explicitArgs != null) { 
                minNrOfArgs = explicitArgs.length;
            }
            else { 
                //获取beanDefinition中缓存的构造方法参数值ConstructorArgumentValues
                ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                resolvedValues = new ConstructorArgumentValues();
                //6.1解析对应的Bean的构造方法，并将方法参数封装到resolvedValues中
                minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
            }
    
            /** * 对构造方法进行排序,会按照如下顺序 * public并且方法参数越多越靠前 * 非public并且方法参数越多越靠前 */
            AutowireUtils.sortConstructors(candidates);
            int minTypeDiffWeight = Integer.MAX_VALUE;
            Set<Constructor<?>> ambiguousConstructors = null;
            LinkedList<UnsatisfiedDependencyException> causes = null;
    
            for (Constructor<?> candidate : candidates) { 
                //获取当前构造方法的参数数量
                int parameterCount = candidate.getParameterCount();
    
                //满足下面三个条件，说明该构造方法可用，直接使用当前构造方法和参数
                if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) { 
                    // Already found greedy constructor that can be satisfied ->
                    // do not look any further, there are only less greedy constructors left.
                    break;
                }
                //匹配的参数数量不够，继续下一个构造方法
                if (parameterCount < minNrOfArgs) { 
                    continue;
                }
    
                ArgumentsHolder argsHolder;
                //获取构造方法的参数类型
                Class<?>[] paramTypes = candidate.getParameterTypes();
                if (resolvedValues != null) { 
                    try { 
                        /** * 解析@ConstructorProperties注解 * 这个注解实际上就是显示指定构造方法的参数名 * 通过此注解可以直接获取参数名 */
                        String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
                        if (paramNames == null) { 
                            //没有手动标注参数名，就使用ParameterNameDiscoverer解析构造方法的参数名
                            ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                            if (pnd != null) { 
                              
                                /** * 获取构造方法的参数名 * 实际上流程很简单，都是反射的知识 * Parameter[] parameters=Constructor.getParameters() 获取所有的参数 * parameter.getName() 遍历获取每个参数的参数名字 */
                                paramNames = pnd.getParameterNames(candidate);
                            }
                        }
                        
                        /** * 6.2创建ArgumentsHolder * getUserDeclaredConstructor(candidate) * 从名字上理解，就是获取用户声明的构造方法，这主要是避免这么一种情况， * 当前这个构造方法所属的类是由cglib生成的子类，那么此时，就不能使用子类的 * 必须得获取原始类的构造方法 */
                        argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
                                                         getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
                    }
                    catch (UnsatisfiedDependencyException ex) { 
                        if (logger.isTraceEnabled()) { 
                            logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
                        }
                        // Swallow and try next constructor.
                        if (causes == null) { 
                            causes = new LinkedList<>();
                        }
                        causes.add(ex);
                        continue;
                    }
                }
                else { 
                    // Explicit arguments given -> arguments length must match exactly.
                    if (parameterCount != explicitArgs.length) { 
                        continue;
                    }
                    argsHolder = new ArgumentsHolder(explicitArgs);
                }
    
                /** * mbd.isLenientConstructorResolution()获取构造方法的匹配模式（宽松、严格） * 使用算法计算出当前构造方法的权重值（值越小越匹配） */
                int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                                      argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
                // Choose this constructor if it represents the closest match.
                //使用权重值小的构造方法
                if (typeDiffWeight < minTypeDiffWeight) { 
                    //将当前构造方法设置为使用的构造方法
                    constructorToUse = candidate;
                    argsHolderToUse = argsHolder;
                     //将当前参数设置为构造方法使用的参数
                    argsToUse = argsHolder.arguments;
                    //覆盖上一个构造方法的权重值
                    minTypeDiffWeight = typeDiffWeight;
                    ambiguousConstructors = null;
                }
                else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) { 
                    if (ambiguousConstructors == null) { 
                        ambiguousConstructors = new LinkedHashSet<>();
                        ambiguousConstructors.add(constructorToUse);
                    }
                    ambiguousConstructors.add(candidate);
                }
            }
    
            //找不到合适的构造方法，抛异常
            if (constructorToUse == null) { 
                if (causes != null) { 
                    UnsatisfiedDependencyException ex = causes.removeLast();
                    for (Exception cause : causes) { 
                        this.beanFactory.onSuppressedException(cause);
                    }
                    throw ex;
                }
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                "Could not resolve matching constructor " +
                                                "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
            }
            else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) { 
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                "Ambiguous constructor matches found in bean '" + beanName + "' " +
                                                "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
                                                ambiguousConstructors);
            }
    
            //缓存当前使用的构造方法和参数，以备下次实例化对象使用
            if (explicitArgs == null && argsHolderToUse != null) { 
                argsHolderToUse.storeCache(mbd, constructorToUse);
            }
        }
    
        Assert.state(argsToUse != null, "Unresolved constructor arguments");
        //instantiate 实例化对象
        bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
        return bw;
    }

### 6.1解析对应的Bean的构造方法，并将方法参数封装到ConstructorArgumentValues中 ###

/** * Resolve the constructor arguments for this bean into the resolvedValues object. * This may involve looking up other beans. * <p>This method is also used for handling invocations of static factory methods. */
    private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
                                            ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) { 
    
        //获取定制的类型转换器
        TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
        TypeConverter converter = (customConverter != null ? customConverter : bw);
        BeanDefinitionValueResolver valueResolver =
            new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
    
        //获取构造方法参数数量
        int minNrOfArgs = cargs.getArgumentCount();
    
        //遍历构造方法参数，解析参数
        for (Map.Entry<Integer, ConstructorArgumentValues.ValueHolder> entry : cargs.getIndexedArgumentValues().entrySet()) { 
            //参数位置索引，从0开始
            int index = entry.getKey();
            if (index < 0) { 
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                "Invalid constructor argument index: " + index);
            }
            if (index + 1 > minNrOfArgs) { 
                minNrOfArgs = index + 1;
            }
            //获取值持有者
            ConstructorArgumentValues.ValueHolder valueHolder = entry.getValue();
            //该参数已经被解析
            if (valueHolder.isConverted()) { 
                resolvedValues.addIndexedArgumentValue(index, valueHolder);
            }
            //该参数未被解析
            else { 
                //去容器中获取当前参数对应的值
                Object resolvedValue =
                    valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
                //使用解析后的值构建值持有者
                ConstructorArgumentValues.ValueHolder resolvedValueHolder =
                    new ConstructorArgumentValues.ValueHolder(resolvedValue, valueHolder.getType(), valueHolder.getName());
                //将原始的保存
                resolvedValueHolder.setSource(valueHolder);
                //解析后的值持有者保存到resolvedValues中
                resolvedValues.addIndexedArgumentValue(index, resolvedValueHolder);
            }
        }
    
        //遍历所有泛型参数持有者
        for (ConstructorArgumentValues.ValueHolder valueHolder : cargs.getGenericArgumentValues()) { 
            if (valueHolder.isConverted()) { 
                resolvedValues.addGenericArgumentValue(valueHolder);
            }
            else { 
                Object resolvedValue =
                    valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
                ConstructorArgumentValues.ValueHolder resolvedValueHolder = new ConstructorArgumentValues.ValueHolder(
                    resolvedValue, valueHolder.getType(), valueHolder.getName());
                resolvedValueHolder.setSource(valueHolder);
                resolvedValues.addGenericArgumentValue(resolvedValueHolder);
            }
        }
    
        return minNrOfArgs;
    }

### 6.2创建ArgumentsHolder ###

/** * Create an array of arguments to invoke a constructor or factory method, * given the resolved constructor argument values. */
    private ArgumentsHolder createArgumentArray(
        String beanName, RootBeanDefinition mbd, @Nullable ConstructorArgumentValues resolvedValues,
        BeanWrapper bw, Class<?>[] paramTypes, @Nullable String[] paramNames, Executable executable,
        boolean autowiring, boolean fallback) 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<>(paramTypes.length);
        Set<String> autowiredBeanNames = new LinkedHashSet<>(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 = null;
            //ConstructorArgumentValues中获取参数（6.1中解析的）
            if (resolvedValues != null) { 
                //获取指定参数位置的值持有者
                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 { 
                    //executable就是当前的构造方法，通过构造方法和参数索引构建一个方法参数对象
                    MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
                    try { 
                        //解析原始参数值，获取对应的参数值对象
                        convertedValue = converter.convertIfNecessary(originalValue, paramType, methodParam);
                    }
                    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());
                    }
                    Object sourceHolder = valueHolder.getSource();
                    if (sourceHolder instanceof ConstructorArgumentValues.ValueHolder) { 
                        Object sourceValue = ((ConstructorArgumentValues.ValueHolder) sourceHolder).getValue();
                        args.resolveNecessary = true;
                        args.preparedArguments[paramIndex] = sourceValue;
                    }
                }
                //封装解析的值
                args.arguments[paramIndex] = convertedValue;
                args.rawArguments[paramIndex] = originalValue;
            }
            //参数没有被解析过，解析
            else { 
                MethodParameter methodParam = MethodParameter.forExecutable(executable, 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, fallback);
                    //设置到ArgumentsHolder中
                    args.rawArguments[paramIndex] = autowiredArgument;
                    args.arguments[paramIndex] = autowiredArgument;
                    args.preparedArguments[paramIndex] = 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 (logger.isDebugEnabled()) { 
                logger.debug("Autowiring by type from bean name '" + beanName +
                             "' via " + (executable instanceof Constructor ? "constructor" : "factory method") +
                             " to bean named '" + autowiredBeanName + "'");
            }
        }
    
        //最终返回ArgumentsHolder
        return args;
    }

**获取参数匹配的对象**

/** * Template method for resolving the specified argument which is supposed to be autowired. */
    @Nullable
    protected Object resolveAutowiredArgument(MethodParameter param, String beanName,
                                              @Nullable Set<String> autowiredBeanNames, TypeConverter typeConverter, boolean fallback) { 
    
        Class<?> paramType = param.getParameterType();
        if (InjectionPoint.class.isAssignableFrom(paramType)) { 
            InjectionPoint injectionPoint = currentInjectionPoint.get();
            if (injectionPoint == null) { 
                throw new IllegalStateException("No current InjectionPoint available for " + param);
            }
            return injectionPoint;
        }
        try { 
            //看到这个方法没有，无论是构造方法，还是属性，最终都是调用这个方法解析依赖，获取依赖对象
            //这个方法我会在注解方式的自动注入中详细剖析源码，见下一篇文章
            return this.beanFactory.resolveDependency(
                new DependencyDescriptor(param, true), beanName, autowiredBeanNames, typeConverter);
        }
        catch (NoUniqueBeanDefinitionException ex) { 
            throw ex;
        }
        catch (NoSuchBeanDefinitionException ex) { 
            if (fallback) { 
                // Single constructor or factory method -> let's return an empty array/collection
                // for e.g. a vararg or a non-null List/Set/Map parameter.
                if (paramType.isArray()) { 
                    return Array.newInstance(paramType.getComponentType(), 0);
                }
                else if (CollectionFactory.isApproximableCollectionType(paramType)) { 
                    return CollectionFactory.createCollection(paramType, 0);
                }
                else if (CollectionFactory.isApproximableMapType(paramType)) { 
                    return CollectionFactory.createMap(paramType, 0);
                }
            }
            throw ex;
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/df7f5ae73d9343b7ab11bfc84c0a3e1d.png