Spring 之autowired

Spring中autowired主要用于装配树形值，其关键类为BeanWrapperImpl,阅读代码发现其关键方法setPropertyValue有如下一段代码。

 PropertyHandler ph = getLocalPropertyHandler(actualName);
             if (ph == null || !ph.isWritable()) {
                 if (pv.isOptional()) {
                     if (logger.isDebugEnabled()) {
                         logger.debug("Ignoring optional value for property '" + actualName +
                                 "' - property not found on bean class [" + getRootClass().getName() + "]");
                     }
                     return;
                 }
                 else {
                     throw createNotWritablePropertyException(propertyName);
                 }
             }
             Object oldValue = null;
             try {
                 Object originalValue = pv.getValue();
                 Object valueToApply = originalValue;
                 if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
                     if (pv.isConverted()) {
                         valueToApply = pv.getConvertedValue();
                     }
                     else {
                         if (isExtractOldValueForEditor() && ph.isReadable()) {
                             try {
                                 oldValue = ph.getValue();
                             }
                             catch (Exception ex) {
                                 if (ex instanceof PrivilegedActionException) {
                                     ex = ((PrivilegedActionException) ex).getException();
                                 }
                                 if (logger.isDebugEnabled()) {
                                     logger.debug("Could not read previous value of property '" +
                                             this.nestedPath + propertyName + "'", ex);
                                 }
                             }
                         }
                         valueToApply = convertForProperty(
                                 propertyName, oldValue, originalValue, ph.toTypeDescriptor());
                     }
                     pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
                 }
                 ph.setValue(this.wrappedObject, valueToApply);

显然最终都是调用setPropertyValue来设置属性值的。真实注入的时候是发生在getBean的时候，在实例化完成后会调用populateBean方法。查看populateBean方法发现如下代码：

 protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
         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);
     }

注意如下代码：

InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);

在给属性赋值之前会调用InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法，获取最终的PropertyValues。

在Spring注入的InstantionAwaireBeanPostProcessor中比较关键的子类就是处理@Autowired的子类，AutowiredAnnotationBeanPostProcessor。下如战士postProcessPropertyValues的实现过程，只列出了几个关键的方法。

(1) findAutowiringMetadata方法的主要功能是对InjectMetadata添加了本地缓存,真实的解析InjectMetadata会使用反射，添加缓存可以名小减少对反射的依赖。真实的生成InjectMetadata是buildAutowiringMetadata方法。

     private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
         LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>();
         Class<?> targetClass = clazz;

         do {
             final LinkedList<InjectionMetadata.InjectedElement> currElements =
                     new LinkedList<InjectionMetadata.InjectedElement>();

             ReflectionUtils.doWithLocalFields(targetClass, new ReflectionUtils.FieldCallback() {
                 @Override
                 public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
                     AnnotationAttributes ann = findAutowiredAnnotation(field);
                     if (ann != null) {
                         if (Modifier.isStatic(field.getModifiers())) {
                             if (logger.isWarnEnabled()) {
                                 logger.warn("Autowired annotation is not supported on static fields: " + field);
                             }
                             return;
                         }
                         boolean required = determineRequiredStatus(ann);
                         currElements.add(new AutowiredFieldElement(field, required));
                     }
                 }
             });

             ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback() {
                 @Override
                 public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
                     Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
                     if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                         return;
                     }
                     AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
                     if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                         if (Modifier.isStatic(method.getModifiers())) {
                             if (logger.isWarnEnabled()) {
                                 logger.warn("Autowired annotation is not supported on static methods: " + method);
                             }
                             return;
                         }
                         if (method.getParameterTypes().length == 0) {
                             if (logger.isWarnEnabled()) {
                                 logger.warn("Autowired annotation should be used on methods with parameters: " + method);
                             }
                         }
                         boolean required = determineRequiredStatus(ann);
                         PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                         currElements.add(new AutowiredMethodElement(method, required, pd));
                     }
                 }
             });

             elements.addAll(0, currElements);
             targetClass = targetClass.getSuperclass();
         }
         while (targetClass != null && targetClass != Object.class);

         return new InjectionMetadata(clazz, elements);
     }

buildAutowiringMetadata

其实doWithLocalFields和doWithLocalMethods比较类似，都使用策略模式的实现回调方法来实现。这种回调方式是常用的方法。

     ReflectionUtils.doWithLocalFields(targetClass, new ReflectionUtils.FieldCallback() {
                 @Override
                 public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
                     AnnotationAttributes ann = findAutowiredAnnotation(field);
                     if (ann != null) {
                         if (Modifier.isStatic(field.getModifiers())) {
                             if (logger.isWarnEnabled()) {
                                 logger.warn("Autowired annotation is not supported on static fields: " + field);
                             }
                             return;
                         }
                         boolean required = determineRequiredStatus(ann);
                         currElements.add(new AutowiredFieldElement(field, required));
                     }
                 }
             });

doWithLocalFields

     public static void doWithLocalFields(Class<?> clazz, FieldCallback fc) {
         for (Field field : getDeclaredFields(clazz)) {
             try {
                 fc.doWith(field);
             }
             catch (IllegalAccessException ex) {
                 throw new IllegalStateException("Not allowed to access field '" + field.getName() + "': " + ex);
             }
         }
     }

doWithLocalFields

注意到@Autowired不支持静态注入的原因，就是增加了判断签名为static的时候，并没有解析。

InjectElement有两个关键子类，AutowiredMethodElement主要解决method上面的注解，AutowiredFieldElement主要解决field上面的注解。不同之处就是field会从容器查找filed对应的bean,method会将每一个参数都注入。其最关键的方法均为resolveDependency方法。其中观察resolveDependency方法的调用中有个关键方法findAutowireCandidates。

     protected Map<String, Object> findAutowireCandidates(
             String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {

         String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                 this, requiredType, true, descriptor.isEager());
         Map<String, Object> result = new LinkedHashMap<String, Object>(candidateNames.length);
         for (Class<?> autowiringType : this.resolvableDependencies.keySet()) {
             if (autowiringType.isAssignableFrom(requiredType)) {
                 Object autowiringValue = this.resolvableDependencies.get(autowiringType);
                 autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
                 if (requiredType.isInstance(autowiringValue)) {
                     result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
                     break;
                 }
             }
         }
         for (String candidateName : candidateNames) {
             if (!isSelfReference(beanName, candidateName) && isAutowireCandidate(candidateName, descriptor)) {
                 addCandidateEntry(result, candidateName, descriptor, requiredType);
             }
         }
         if (result.isEmpty() && !indicatesMultipleBeans(requiredType)) {
             // Consider fallback matches if the first pass failed to find anything...
             DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
             for (String candidateName : candidateNames) {
                 if (!isSelfReference(beanName, candidateName) && isAutowireCandidate(candidateName, fallbackDescriptor)) {
                     addCandidateEntry(result, candidateName, descriptor, requiredType);
                 }
             }
             if (result.isEmpty()) {
                 // Consider self references before as a final pass
                 for (String candidateName : candidateNames) {
                     if (isSelfReference(beanName, candidateName) && isAutowireCandidate(candidateName, fallbackDescriptor)) {
                         addCandidateEntry(result, candidateName, descriptor, requiredType);
                     }
                 }
             }
         }
         return result;
     }

首先处理的是resolevableDependencies，如果已经注册依赖，直接从注册的依赖中提取。否则直接调用getType方法获取bean。注册依赖可能是容易被忽略的。

在refresh中就有直接注册依赖的调用：

    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        ....//省略部分代码
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);
        ......//省略部分代码
        }
}