spring源码解析之IOC容器（四）——属性注入

　　上一篇跟踪了bean的创建过程，接下来，我们继续跟踪bean的属性填充的过程。先回到doCreateBean方法，代码如下：

 protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
             throws BeanCreationException {

         // Instantiate the bean.
         BeanWrapper instanceWrapper = null;
         if (mbd.isSingleton()) {
             //如果是单例，先把缓存中的同名Bean清除
             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
         }
         //如果缓存中没有
         if (instanceWrapper == null) {
             //则创建一个实例
             instanceWrapper = createBeanInstance(beanName, mbd, args);
         }
         final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
         Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
         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.
         //这里是对单例的循环引用的处理，单例&&允许循环依赖&&正在被创建同时满足，才为true
         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                 isSingletonCurrentlyInCreation(beanName));
         if (earlySingletonExposure) {
             if (logger.isDebugEnabled()) {
                 logger.debug("Eagerly caching bean '" + beanName +
                         "' to allow for resolving potential circular references");
             }
             addSingletonFactory(beanName, new ObjectFactory<Object>() {
                 @Override
                 public Object getObject() throws BeansException {
                     return getEarlyBeanReference(beanName, mbd, bean);
                 }
             });
         }

         //这里是对bean的初始化，依赖注入往往是在这里进行的，这个exposedObject在初始化完成之后会作为依赖注入完成之后的Bean
         // Initialize the bean instance.
         Object exposedObject = bean;
         try {
             //属性的填充
             populateBean(beanName, mbd, instanceWrapper);
             if (exposedObject != null) {
                 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<String>(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 " +
                                 "'getBeanNamesOfType' 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;
     }

　　对于bean的创建，IOC容器其实是采用反射和cglib技术来生成的，我们可以跟踪一下createBeanInstance方法：

 protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
         // Make sure bean class is actually resolved at this point.
         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());
         }

         //使用工厂方法对Bean进行实例化
         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);
             }
         }

         //使用构造函数对Bean实例化
         // Need to determine the constructor...
         Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
         if (ctors != null ||
                 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
                 mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
             return autowireConstructor(beanName, mbd, ctors, args);
         }

         //使用默认的构造函数对Bean进行实例化
         // No special handling: simply use no-arg constructor.
         return instantiateBean(beanName, mbd);
     }

　　1、如果指定了工厂方法，则使用工厂进行创建；

　　2、如果没有指定工厂方法，则看有没指定某个构造器进行实例化；

　　3、都没有，则采用默认的构造器进行实例化。进入默认的构造器方法：

 protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
         try {
             Object beanInstance;
             final BeanFactory parent = this;
             if (System.getSecurityManager() != null) {
                 beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                     @Override
                     public Object run() {
                         return getInstantiationStrategy().instantiate(mbd, beanName, parent);
                     }
                 }, getAccessControlContext());
             }
             else {
                 beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
             }
             BeanWrapper bw = new BeanWrapperImpl(beanInstance);
             initBeanWrapper(bw);
             return bw;
         }
         catch (Throwable ex) {
             throw new BeanCreationException(
                     mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
         }
     }

　　虽然getInstantiationStrategy()方法获取的是CglibSubclassingInstantiationStrategy实例，但是CglibSubclassingInstantiationStrategy中只有一个instantiate带一个参数和一个可变参数的方法，和这里调用的并不是同一个方法，所以，这里调用的是它的父类SimpleInstantiationStrategy中的instantiate方法，进入：

 public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
         // Don't override the class with CGLIB if no overrides.
         if (bd.getMethodOverrides().isEmpty()) {
             Constructor<?> constructorToUse;
             synchronized (bd.constructorArgumentLock) {
                 //这里取得指定的构造器或者生产对象的工厂方法来对Bean进行实例化
                 constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
                 if (constructorToUse == null) {
                     final Class<?> clazz = bd.getBeanClass();
                     if (clazz.isInterface()) {
                         throw new BeanInstantiationException(clazz, "Specified class is an interface");
                     }
                     try {
                         if (System.getSecurityManager() != null) {
                             constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
                                 @Override
                                 public Constructor<?> run() throws Exception {
                                     return clazz.getDeclaredConstructor((Class[]) null);
                                 }
                             });
                         }
                         else {
                             constructorToUse =    clazz.getDeclaredConstructor((Class[]) null);
                         }
                         bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                     }
                     catch (Throwable ex) {
                         throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                     }
                 }
             }
             //使用反射进行实例化
             return BeanUtils.instantiateClass(constructorToUse);
         }
         else {
             //使用cglb进行实例化
             // Must generate CGLIB subclass.
             return instantiateWithMethodInjection(bd, beanName, owner);
         }
     }

　　这段代码可以看到，IOC是使用反射和cglib来进行实例化对象的。好了，我们回到之前的方法，到populateBean(beanName, mbd, instanceWrapper)方法进行跟踪：

 protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
         //在前面解析的过程中，XML中设置的属性已经填充到beanDefinition 的propertyValues属性中
         PropertyValues pvs = mbd.getPropertyValues();

         if (bw == null) {
             if (!pvs.isEmpty()) {
                 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.
         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;
         }

         //开始进行依赖注入的操作
         if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
                 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
             MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

             //按属性的名字来进行注入
             // Add property values based on autowire by name if applicable.
             if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                 autowireByName(beanName, mbd, bw, newPvs);
             }

             //按属性的类型来进行注入
             // Add property values based on autowire by type if applicable.
             if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                 autowireByType(beanName, mbd, bw, newPvs);
             }

             pvs = newPvs;
         }

         boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
         boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

         if (hasInstAwareBpps || needsDepCheck) {
             PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
             if (hasInstAwareBpps) {
                 for (BeanPostProcessor bp : getBeanPostProcessors()) {
                     if (bp instanceof InstantiationAwareBeanPostProcessor) {
                         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                         pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                         if (pvs == null) {
                             return;
                         }
                     }
                 }
             }
             if (needsDepCheck) {
                 checkDependencies(beanName, mbd, filteredPds, pvs);
             }
         }

         //对属性进行注入
         applyPropertyValues(beanName, mbd, bw, pvs);
     }

　　可以看到：

　　1、我们可以在XML中指定autowired的值，是按名称还是类型来进行注入；

　　2、真正进行属性注入的是applyPropertyValues方法，进入：

 protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
         if (pvs == null || pvs.isEmpty()) {
             return;
         }

         if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
             ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
         }

         MutablePropertyValues mpvs = null;
         List<PropertyValue> original;

         if (pvs instanceof MutablePropertyValues) {
             mpvs = (MutablePropertyValues) pvs;
             if (mpvs.isConverted()) {
                 // Shortcut: use the pre-converted values as-is.
                 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;
         }
         //获取解析器
         BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

         // Create a deep copy, resolving any references for values.
         List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
         boolean resolveNecessary = false;
         for (PropertyValue pv : original) {
             //如果已经转换过，就直接存入
             if (pv.isConverted()) {
                 deepCopy.add(pv);
             }
             else {
                 //获取属性名称
                 String propertyName = pv.getName();
                 //获取属性值
                 Object originalValue = pv.getValue();
                 //将值进行转换，比如属性的值有可能是数组、集合，或者对象，并且该对象也需要进行属性的注入，
                 //那么还会进行递归调用getBean方法，将该对象生成好之后再注入给当前的属性
                 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);
                 }
                 // Possibly store converted value in merged bean definition,
                 // in order to avoid re-conversion for every created bean instance.
                 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();
         }

         //设置依赖注入的地方
         // Set our (possibly massaged) deep copy.
         try {
             bw.setPropertyValues(new MutablePropertyValues(deepCopy));
         }
         catch (BeansException ex) {
             throw new BeanCreationException(
                     mbd.getResourceDescription(), beanName, "Error setting property values", ex);
         }
     }

　　至此，一个完整的bean就算创建完成了，要用的时候，直接找IOC容器拿就行了。