今天接下去讲我们的内容，上次的解析了AnnotationBeanUtils这个类的运用和源码。今天主要关注的是Autowired和 AutowiredAnnotationBeanPostProcessor这2个类。首先我们来看一下Autowired标签的定义。
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Autowired { /** * * <p>Defaults to {@code true}. */ boolean required() default true; }
从标签的定义和上面的注释可以知道，该标签可以用于构造函数、方法、参数、标签上。为了使这个标签生效，我们需要一个解析这个标签的类，Spring 为我们提供解析的类就是AutowiredAnnotationBeanPostProcessor，这是个BeanPostProcessor类。关于BeanPostProcessor大家可以查阅相关资料，之后等我读到这个接口的时候，会具体的和大家一起探讨。这里我们以参数注入为例，来分析了一下，这个类到底做了哪些事情。这个参数注入主要是它的一个内部类AutowiredFieldElement来处理。
而这个类的inject()方法被调用是在AutowiredAnnotationBeanPostProcessor的postProcessPropertyValues方法上。
@Override public PropertyValues postProcessPropertyValues( PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException { InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs); try { metadata.inject(bean, beanName, pvs); } catch (BeanCreationException ex) { throw ex; } catch (Throwable ex) { throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex); } return pvs; }
从这里我们知道 findAutowiringMetadata()方法这里获取注入元数据信息，然后调用InjectionMetadata.inject()的方法。在以参数注入就是调用AutowiredFieldElement.inject()方法。
这些类型的关系，将在之后解释。让我们具体来看一下 AutowiredFieldElement.inject()方法。
@Override protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable { Field field = (Field) this.member; Object value; if (this.cached) { value = resolvedCachedArgument(beanName, this.cachedFieldValue); } else { DependencyDescriptor desc = new DependencyDescriptor(field, this.required); desc.setContainingClass(bean.getClass()); Set<String> autowiredBeanNames = new LinkedHashSet<String>(1); TypeConverter typeConverter = beanFactory.getTypeConverter(); try { //通过BeanFactory的resolveDependency()方法解决依赖的值。也就是这个参数需要注入的值 value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter); } catch (BeansException ex) { throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex); } synchronized (this) { if (!this.cached) { if (value != null || this.required) { this.cachedFieldValue = desc; registerDependentBeans(beanName, autowiredBeanNames); if (autowiredBeanNames.size() == 1) { String autowiredBeanName = autowiredBeanNames.iterator().next(); if (beanFactory.containsBean(autowiredBeanName)) { if (beanFactory.isTypeMatch(autowiredBeanName, field.getType())) { this.cachedFieldValue = new ShortcutDependencyDescriptor( desc, autowiredBeanName, field.getType()); } } } } else { this.cachedFieldValue = null; } this.cached = true; } } } if (value != null) {//这里就是通过反射设置参数可见性，然后把值设置到该参数上。 ReflectionUtils.makeAccessible(field); field.set(bean, value); } }
接下来，我们需要知道，AutowiredAnnotationBeanPostProcessor的postProcessPropertyValues()方法什么时候被调用。在这个函数上，我们关注2个参数，一个是PropertyDescriptor
类型的数组，一个beanName。beanName就是我们实例化的对象，其中PropertyDescriptor就是描述这个名为beanName的Bean的参数内容。在AbstractAutowireCapableBeanFactory的
doCreateBean（）方法里，有一个populateBean（）里面调用了postProcessPropertyValues（）。从方法名称上，我们知道创建Bean(doCreateBean)>填充Bean(populateBean)。在这个populateBean()里面有如一下这么一段代码：
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); } }
在for循环里面，判断每一个BeanPostProcessor ，看这个BeanPostProcessor 是否实现InstantiationAwareBeanPostProcessor这个接口，刚好，我们知道AutowiredAnnotationBeanPostProcessors实现了这个接口，重载了InstantiationAwareBeanPostProcessor的postProcessPropertyValues()方法。到此为止，我们知道Bean的Autowired的注入实现。那么我们在回到postProcessPropertyValues的findAutowiringMetadata(),从上面已经点出这个方法是找出注入元数据信息。那么它是如何查找的，看如下代码：
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, PropertyValues pvs) { // Fall back to class name as cache key, for backwards compatibility with custom callers. String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName()); // Quick check on the concurrent map first, with minimal locking. InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey); if (InjectionMetadata.needsRefresh(metadata, clazz)) { synchronized (this.injectionMetadataCache) { metadata = this.injectionMetadataCache.get(cacheKey); if (InjectionMetadata.needsRefresh(metadata, clazz)) { if (metadata != null) { metadata.clear(pvs); } try { metadata = buildAutowiringMetadata(clazz); this.injectionMetadataCache.put(cacheKey, metadata); } catch (NoClassDefFoundError err) { throw new IllegalStateException("Failed to introspect bean class [" + clazz.getName() + "] for autowiring metadata: could not find class that it depends on", err); } } } } return metadata; }
其中的关键代码就是InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);这句话。从这里我们知道他是从this.injectionMetadataCache,这是一个Map,key为beanName,value为注入元数据InjectionMetadata。即直接从这个Map中获取，那么接下来我们就要知道这个注入信息是什么时候放入到这个缓存Map上的。从上面代码上，我们看到
this.injectionMetadataCache.put(cacheKey, metadata);这段代码，这代码就是把注入信息放到this.injectionMetadataCache上。那么，从这里我们可以猜测，findAutowiringMetadata()这个方法肯定被调用了多次，在Bean实例化过程中。从查看代码，印证了我的想法。
再回到AutowiredAnnotationBeanPostProcessor的BeanPostProcessor,之前我们知道他实现InstantiationAwareBeanPostProcessor这个接口。在这里，我要说AutowiredAnnotationBeanPostProcessor还实现了MergedBeanDefinitionPostProcessor这个接口，这个MergedBeanDefinitionPostProcessor接口只有一个函数postProcessMergedBeanDefinition()，该方法就是用来整合BeanDefinition。让我们自己毛估估也知道，这个对Bean内部的参数描述PropertyDescriptor也应该在专门用来整合Bean定义的这种BeanPostProcessors。从 AutowiredAnnotationBeanPostProcessor的如下代码，它果然实现postProcessMergedBeanDefinition函数。在其中调用了findAutowiringMetadata()。
@Override public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) { if (beanType != null) { InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null); metadata.checkConfigMembers(beanDefinition); } }
第一次调用findAutowiringMetadata()的时候，我们this.injectionMetadataCache.get()得到metadata为null,这样就会进入if{}段代码,接着 调用 buildAutowiringMetadata（）从该Bean的字节码中得到注入元信息。接着我们把得到的注入源信息InjectionMetadata放到this.injectionMetadataCache上。那么我们看一下这个方法。
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 only 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); }
从上面，我们知道这个方法主要通过ReflectionUtils.doWithLocalFields()和ReflectionUtils.doWithLocalMethods()来得到源注入信息。到这里，我们可以大致知道依赖注入了。瞎 main提供一下test，大家可以通过debug知道Bean的创建流程。
@Test public void testResourceInjection2() { DefaultListableBeanFactory bf = new DefaultListableBeanFactory(); AutowiredAnnotationBeanPostProcessor bpp = new AutowiredAnnotationBeanPostProcessor(); bpp.setBeanFactory(bf); bf.addBeanPostProcessor(bpp); RootBeanDefinition bd1 = new RootBeanDefinition(Uss.class); bd1.setScope(RootBeanDefinition.SCOPE_SINGLETON); bf.registerBeanDefinition("uss", bd1); RootBeanDefinition bd2 = new RootBeanDefinition(Tss.class); bd2.setScope(RootBeanDefinition.SCOPE_SINGLETON); bf.registerBeanDefinition("tss", bd2); Uss uss = (Uss) bf.getBean("uss"); Tss tss = (Tss) bf.getBean("tss"); System.out.println(uss.getTss() == tss); System.out.println(tss.getUss() == uss); }
public class Uss { private String id; @Autowired private Tss tss; public String getId() { return id; } public void setId(String id) { this.id = id; } public Tss getTss() { return tss; } public void setTss(Tss tss) { this.tss = tss; } }
public class Tss { private String id; @Autowired private Uss uss; public String getId() { return id; } public void setId(String id) { this.id = id; } public Uss getUss() { return uss; } public void setUss(Uss uss) { this.uss = uss; } }
在这里，还有一些东西没有讲的非常的清楚，第一，是我自己有些代码还不太清楚，整体把握不住，还有些要等到我看到了其他内容在和大家一起分享。