Spring IOC源码剖析之依赖关系注入

之前我们已经分析了容器初始化生成bean所包含的java对象的过程，接下来我们继续分析在生成对象之后，Spring IOC容器是如何将bean的属性依赖关系注入到bean实例对象中并进行设置的，方法populateBean就是对bean属性的依赖注入进行处理的具体实现：

对于源码的理解，以注释添加在对应代码块上方

   //将bean属性设置到实例对象中  
   protected void populateBean(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw) {  
       //获取容器在解析bean定义资源时为BeanDefiniton中设置的属性值  
       PropertyValues pvs = mbd.getPropertyValues();  
       //如果实例对象为null  
       if (bw == null) {  
           //如果属性值不为空  
           if (!pvs.isEmpty()) {  
               throw new BeanCreationException(  
                       mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");  
           }  
           else {  
               //如果实例对象为null，属性值也为空，不需设置属性值，直接返回  
               return;  
           }  
       }  
       //在设置属性之前，需调用bean的后置处理器  
       boolean continueWithPropertyPopulation = true;  
       if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {  
           for (BeanPostProcessor bp : getBeanPostProcessors()) {  
               if (bp instanceof InstantiationAwareBeanPostProcessor) {  
                   InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  
                   if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {  
                       continueWithPropertyPopulation = false;  
                       break;  
                   }  
               }  
           }  
       }  
       if (!continueWithPropertyPopulation) {  
           return;  
       }  
       /**接下来开始依赖注入， 
       *首先处理autowire自动装配的注入
       */ 
       if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||  
               mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  
           MutablePropertyValues newPvs = new MutablePropertyValues(pvs);  
           //对autowire自动装配的处理，根据bean的名称自动装配注入  
           if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {  
               autowireByName(beanName, mbd, bw, newPvs);  
           }  
           //根据bean的类型自动装配注入  
           if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  
               autowireByType(beanName, mbd, bw, newPvs);  
           }  
           pvs = newPvs;  
       }  
       //检查容器是否持有用于处理单态模式bean关闭时的后置处理器  
       boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();  
       /**bean实例对象没有依赖，
       *即没有继承基类
       */  
       boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);  
       if (hasInstAwareBpps || needsDepCheck) {  
           //从实例对象中提取属性描述符  
           PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw);  
           if (hasInstAwareBpps) {  
               for (BeanPostProcessor bp : getBeanPostProcessors()) {  
                   if (bp instanceof InstantiationAwareBeanPostProcessor) {  
                       InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  
                       //使用BeanPostProcessor处理器处理属性值  
                       pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);  
                       if (pvs == null) {  
                           return;  
                       }  
                   }  
               }  
           }  
           //如果bean实例对象存在依赖
           if (needsDepCheck) {  
               //为要设置的属性进行依赖检查  
               checkDependencies(beanName, mbd, filteredPds, pvs);  
           }  
       }  
       //对属性进行注入  
       applyPropertyValues(beanName, mbd, bw, pvs);  
   }  

方法applyPropertyValues执行对属性进行注入，如下：

   //解析并注入依赖属性  
   protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {  
       //如果属性值为null或为空，直接返回
       if (pvs == null || pvs.isEmpty()) {  
           return;  
       }  
       //封装属性值  
       MutablePropertyValues mpvs = null;  
       List original;  
       if (System.getSecurityManager()!= null) {  
           if (bw instanceof BeanWrapperImpl) {  
               ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());  
           }  
       }  
       if (pvs instanceof MutablePropertyValues) {  
           mpvs = (MutablePropertyValues) pvs;  
           //如果属性值已经转换  
           if (mpvs.isConverted()) {  
               try {  
                   /**为实例化对象设置属性值  
                   *注意，此方法为对属性值的依赖注入的实现
                   */
                   bw.setPropertyValues(mpvs);  
                   return;  
               }  
               catch (BeansException ex) {  
                   throw new BeanCreationException(  
                           mbd.getResourceDescription(), beanName, "Error setting property values", ex);  
               }  
           }  
           //获取属性值对象的原始类型值 
           original = mpvs.getPropertyValueList();  
       }  
       else {  
           original = Arrays.asList(pvs.getPropertyValues());  
       }  
       //获取用户自定义的类型转换  
       TypeConverter converter = getCustomTypeConverter();  
       if (converter == null) {  
           converter = bw;  
       }  
       /**创建一个bean定义属性值解析器，  
       *用来将bean定义中的属性值解析为bean实例对象的实际值
       */
       BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);  
       //创建拷贝属性的解析值并将拷贝的数据注入到实例对象中  
       List deepCopy = new ArrayList(original.size());  
       boolean resolveNecessary = false;  
       for (PropertyValue pv : original) {  
           //如果属性值已经过转换
           if (pv.isConverted()) {  
              //将属性值加入拷贝属性列表中
               deepCopy.add(pv);  
           }  
           //如果属性值未转换，则需转换  
           else {  
               String propertyName = pv.getName();  
               //转换之前的属性值  
               Object originalValue = pv.getValue();  
               /**方法resolveValueIfNecessary执行对属性值的解析
               *转换属性值，如：将引用转换为IOC容器中实例化对象的引用
               */ 
               Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);  
               //转换之后的属性值  
               Object convertedValue = resolvedValue;  
               //判断属性值是否可转换  
               boolean convertible = bw.isWritableProperty(propertyName) &&  
                       !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);  
               //如何可以转换
               if (convertible) {  
                   //使用用户自定义的类型转换器转换属性值  
                   convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);  
               }  
               /**存储转换后的属性值，
               *避免每次属性注入时的都需要进行转换  
               */ 
               if (resolvedValue == originalValue) {  
                   if (convertible) {  
                       //设置属性转换之后的值  
                       pv.setConvertedValue(convertedValue);  
                   }  
                   //将属性值加入拷贝属性列表中
                   deepCopy.add(pv);  
               }  
               /**如果属性是可转换的，
               *并且属性原始值是字符串类型，   
               *并且属性的原始类型值不是动态生成的字符串，
               *并且属性的原始值不是集合或者数组类型。
               */ 
               else if (convertible && originalValue instanceof TypedStringValue &&  
                       !((TypedStringValue) originalValue).isDynamic() &&  
                       !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {  
                   pv.setConvertedValue(convertedValue);  
                   //将属性值加入拷贝属性列表中
                   deepCopy.add(pv);  
               }  
               else {  
                   resolveNecessary = true;  
                   //重新封装属性的值  
                   deepCopy.add(new PropertyValue(pv, convertedValue));  
               }  
           }  
       }  
       if (mpvs != null && !resolveNecessary) {  
           //标记属性值已转换过  
           mpvs.setConverted();  
       }  
       //进行属性依赖注入  
       try {  
           /**方法setPropertyValues为实例化对象设置属性值  
           *此方法为对属性值的依赖注入的实现
           */
           bw.setPropertyValues(new MutablePropertyValues(deepCopy));  
       }  
       catch (BeansException ex) {  
           throw new BeanCreationException(  
                   mbd.getResourceDescription(), beanName, "Error setting property values", ex);  
       }  
    }

上述源码中，对属性的注入过程可分为：

1. 当属性值类型不需转换时，则不需解析属性值，直接进行依赖注入；
2. 当属性值需进行类型转换时，如，对其他对象的引用等，那么首先需解析属性值，然后对解析后的属性值进行依赖注入。

对属性值的解析是在类BeanDefinitionValueResolver中的方法resolveValueIfNecessary中进行的，而对属性值的依赖注入是通过方法bw.setPropertyValues实现的，我们先分析一下对属性值的解析过程：

当容器在对属性进行依赖注入时，如果发现属性值需要进行类型转换，例如，属性值是容器中另一个bean实例对象的引用，则容器首先需根据属性值将所引用的对象解析出来，然后才能将该引用对象注入到目标实例对象的属性中去，对属性进行解析的由resolveValueIfNecessary方法实现，其源码如下：

   //解析属性值，对注入类型进行转换  
   public Object resolveValueIfNecessary(Object argName, Object value) {  
       //对引用类型的属性进行解析  
       if (value instanceof RuntimeBeanReference) {  
           RuntimeBeanReference ref = (RuntimeBeanReference) value;  
           //调用引用类型属性的解析方法  
           return resolveReference(argName, ref);  
       }  
       //对属性值是容器中bean名称引用的解析  
       else if (value instanceof RuntimeBeanNameReference) {  
           String refName = ((RuntimeBeanNameReference) value).getBeanName();  
           refName = String.valueOf(evaluate(refName));  
           //从容器中获取指定名称的Bean  
           if (!this.beanFactory.containsBean(refName)) {  
               throw new BeanDefinitionStoreException(  
                       "Invalid bean name '" + refName + "' in bean reference for " + argName);  
           }  
           return refName;  
       }  
       //对属性值是bean中的内部类的解析
       else if (value instanceof BeanDefinitionHolder) {  
           BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;  
           return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());  
       }  
       //对属性值是bean定义的解析
       else if (value instanceof BeanDefinition) {  
           BeanDefinition bd = (BeanDefinition) value;  
           return resolveInnerBean(argName, "(inner bean)", bd);  
       }  
       //对属性值是集合数组类型的解析  
       else if (value instanceof ManagedArray) {  
           ManagedArray array = (ManagedArray) value;  
           //获取数组的类型  
           Class elementType = array.resolvedElementType;  
           if (elementType == null) {  
               //获取数组元素的类型  
               String elementTypeName = array.getElementTypeName();  
               if (StringUtils.hasText(elementTypeName)) {  
                   try {  
                       //通过反射机制创建指定类型的对象  
                       elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());  
                       array.resolvedElementType = elementType;  
                   }  
                   catch (Throwable ex) {  
                       throw new BeanCreationException(  
                               this.beanDefinition.getResourceDescription(), this.beanName,  
                               "Error resolving array type for " + argName, ex);  
                   }  
               }  
               /**对于没有获取到数组的类型，也没有获取到数组元素的类型的情况，  
               *则直接设置数组的类型为Object  
               */
               else {  
                   elementType = Object.class;  
               }  
           }  
           //创建指定类型的数组  
           return resolveManagedArray(argName, (List) value, elementType);  
       }  
       //对属性值是list类型的解析  
       else if (value instanceof ManagedList) {  
           return resolveManagedList(argName, (List) value);  
       }  
       //对属性值是set类型的解析
       else if (value instanceof ManagedSet) {  
           return resolveManagedSet(argName, (Set) value);  
       }  
       //对属性值是map类型的解析  
       else if (value instanceof ManagedMap) {  
           return resolveManagedMap(argName, (Map) value);  
       }  
       /**对属性值是props类型的解析，  
       *props其实就是key和value均为字符串的map
       */
       else if (value instanceof ManagedProperties) {  
           Properties original = (Properties) value;  
           Properties copy = new Properties();  
           for (Map.Entry propEntry : original.entrySet()) {  
               Object propKey = propEntry.getKey();  
               Object propValue = propEntry.getValue();  
               if (propKey instanceof TypedStringValue) {  
                   propKey = evaluate((TypedStringValue) propKey);  
               }  
               if (propValue instanceof TypedStringValue) {  
                   propValue = evaluate((TypedStringValue) propValue);  
               }  
               copy.put(propKey, propValue);  
           }  
           return copy;  
       }  
       //对属性值是字符串类型的解析
       else if (value instanceof TypedStringValue) {  
           TypedStringValue typedStringValue = (TypedStringValue) value;  
           Object valueObject = evaluate(typedStringValue);  
           try {  
               //获取属性的目标类型  
               Class resolvedTargetType = resolveTargetType(typedStringValue);  
               if (resolvedTargetType != null) {  
                   //对目标类型的属性进行解析，递归调用  
                   return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);  
               }  
               //如果没有获取到属性的目标对象，则按Object类型返回  
               else {  
                   return valueObject;  
               }  
           }  
           catch (Throwable ex) {  
               throw new BeanCreationException(  
                       this.beanDefinition.getResourceDescription(), this.beanName,  
                       "Error converting typed String value for " + argName, ex);  
           }  
       }  
       else {  
           return evaluate(value);  
       }  
   }  

其中对引用类型的属性值进行解析的由方法resolveReference实现：

   //解析引用类型的属性值  
   private Object resolveReference(Object argName, RuntimeBeanReference ref) {  
       try {  
           //获取引用的bean名称  
           String refName = ref.getBeanName();  
           refName = String.valueOf(evaluate(refName));  
           /**如果引用的对象在父类容器中，  
           *则从父类容器中获取指定的引用对象
           */
           if (ref.isToParent()) {  
               if (this.beanFactory.getParentBeanFactory() == null) {  
                   throw new BeanCreationException(  
                           this.beanDefinition.getResourceDescription(), this.beanName,  
                           "Can't resolve reference to bean '" + refName +  
                           "' in parent factory: no parent factory available");  
               }  
               return this.beanFactory.getParentBeanFactory().getBean(refName);  
           }  
           /**从当前的容器中获取指定的引用bean对象，  
           *如果指定的bean没有被实例化，
           *则会递归触发引用bean的初始化和依赖注入
           */
           else {  
               Object bean = this.beanFactory.getBean(refName);  
               this.beanFactory.registerDependentBean(refName, this.beanName);  
               return bean;  
           }  
       }  
       catch (BeansException ex) {  
           throw new BeanCreationException(  
                   this.beanDefinition.getResourceDescription(), this.beanName,  
                   "Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);  
       }  
   }   

其中对array类型的属性值进行解析的由方法resolveManagedArray实现：

   //对array类型的属性值进行解析
   private Object resolveManagedArray(Object argName, List ml, Class elementType) {  
       //创建一个指定类型的数组，用于存放和返回解析后的数组  
       Object resolved = Array.newInstance(elementType, ml.size());  
       //递归解析array的每个元素，并将解析后的值设置到resolved数组中
       for (int i = 0; i < ml.size(); i++) {  
           Array.set(resolved, i,  
               resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));  
       }  
       return resolved;  
   }  

其中对list类型的属性值进行解析的由方法resolveManagedList实现：

   //对list类型的属性值进行解析  
   private List resolveManagedList(Object argName, List ml) {  
       List