Java

@Autowired使用

构造函数注入

  1. public Class Outer {
  2.     private Inner inner;
  3.     @Autowired
  4.     public Outer(Inner inner) {
  5.         this.inner = inner;
  6.     }
  7. }

属性注入

  1. public Class Outer {
  2.     @Autowired
  3.     private Inner inner;
  4. }

方法注入

  1. public Class Outer {
  2.     private Inner inner;
  3.     public Inner getInner() {
  4.         return inner;
  5.     }
  6.     @Autowired
  7.     public void setInner(Inner inner) {
  8.         this.inner = inner;
  9.     }
  10. }

目前绝大部分的代码都使用第2、第3种。第1种在bean实例化时完成，而第2、第3种的实现原理都是一样的，在属性填充时完成。这里将介绍第二第三种的是实现原理
在开始之前，如果自己设计@Autowired，应该怎么实现？做法还是比较简单的

  • 通过反射查找bean的class下所有注解了**@Autowired**的字段和方法

  • 获取到字段，通过**getBean**(字段)获取到对应bean，然后再通过反射调用field的set将bean注入

    @Autowired源码分析

    AutowiredAnnotationBeanPostProcessor类
    该类是@Autowired的具体实现类，先预览一下类方法
    @Autowired 的实现原理 - 图1
    发现实际有机会介入bean的创建操作只有可能是后置处理器，用于后置处理的有3个方法，其中一个过时不用，分别是postProcessMergedBeanDefinition、postProcessProperties后置处理，再看一下这2个方法的具体代码

    1. public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
    2.       implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
    4.   ...
    6.   @Override
    7.   public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    8.       // 1. 寻找bean中所有被@Autowired注释的属性，并将属性封装成InjectedElement类型
    9.       InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
    10.       metadata.checkConfigMembers(beanDefinition);
    11.   }
    13.   ...
    15.   @Override
    16.   public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    17.       // 1. 寻找通过@Autowired注解的属性或者方法
    18.       InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    19.       try {
    20.           // 2. 注入
    21.           metadata.inject(bean, beanName, pvs);
    22.       } catch (BeanCreationException ex) {
    23.           throw ex;
    24.       } catch (Throwable ex) {
    25.           throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    26.       }
    27.       return pvs;
    28.   }
    30.   ...
    31. }

    跟猜想是一样的，首先先找出所有注解了@Autowired的属性或者方法，然后进行注入，当然postProcessMergedBeanDefinition后置处理器的调用肯定是在postProcessProperties之前的，这里回顾一下spring bean的创建过程。
    2个处理器已用黄色标出
    @Autowired 的实现原理 - 图2

    1、查找所有@Autowired

    ```java // 寻找bean中所有被@Autowired注释的属性，并将属性封装成InjectedElement类型 InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) { // Fall back to class name as cache key, for backwards compatibility with custom callers. // 获取缓存的key值，一般以beanName做key String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName()); // Quick check on the concurrent map first, with minimal locking. // 从缓存中获取metadata InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey); // 检测metadata是否需要更新 if (InjectionMetadata.needsRefresh(metadata, clazz)) { synchronized (this.injectionMetadataCache) { metadata = this.injectionMetadataCache.get(cacheKey); if (InjectionMetadata.needsRefresh(metadata, clazz)) { if (metadata != null) { metadata.clear(pvs); } // 通过clazz类，查找所有@Autowired的属性或者方法，并封装成InjectionMetadata类型 metadata = buildAutowiringMetadata(clazz); // 将metadata加入缓存 this.injectionMetadataCache.put(cacheKey, metadata); } } } return metadata; }

  1. 可以看到spring依然在用缓存的方式提高性能，继续跟踪核心代码`buildAutowiringMetadata(clazz)`
  2. ```java
  3. private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
  4.     // 查看clazz是否有Autowired注解
  5.     if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
  6.         return InjectionMetadata.EMPTY;
  7.     }
  8.     // 这里需要注意AutowiredFieldElement，AutowiredMethodElement均继承了InjectionMetadata.InjectedElement
  9.     // 因此这个列表是可以保存注解的属性和被注解的方法的
  10.     List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
  11.     Class<?> targetClass = clazz;
  13.     // 1. 通过do while循环，递归的往直接继承的父类寻找@Autowired
  14.     do {
  15.         final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
  17.         // 2. 通过反射，获取所有属性，doWithLocalFields则是循环的对每个属性应用以下匿名方法
  18.         ReflectionUtils.doWithLocalFields(targetClass, field -> {
  19.             // 判断当前field属性是否含有@Autowired的注解
  20.             MergedAnnotation<?> ann = findAutowiredAnnotation(field);
  21.             if (ann != null) {
  22.                 // 返回该属性在类中的修饰符，如果等于static常量，则抛出异常，@Autowired不允许注解在静态属性上
  23.                 if (Modifier.isStatic(field.getModifiers())) {
  24.                     if (logger.isInfoEnabled()) {
  25.                         logger.info("Autowired annotation is not supported on static fields: " + field);
  26.                     }
  27.                     return;
  28.                 }
  29.                 // @Autowired有required属性，获取required的值，默认为true
  30.                 boolean required = determineRequiredStatus(ann);
  31.                 // 3. 将field封装成InjectedElement，并添加到集合中，这里用的是AutowiredFieldElement
  32.                 currElements.add(new AutowiredFieldElement(field, required));
  33.             }
  34.         });
  36.         // 4. @Autowired可以注解在方法上
  37.         ReflectionUtils.doWithLocalMethods(targetClass, method -> {
  38.             Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
  39.             if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
  40.                 return;
  41.             }
  42.             MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
  43.             if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
  44.                 if (Modifier.isStatic(method.getModifiers())) {
  45.                     if (logger.isInfoEnabled()) {
  46.                         logger.info("Autowired annotation is not supported on static methods: " + method);
  47.                     }
  48.                     return;
  49.                 }
  50.                 if (method.getParameterCount() == 0) {
  51.                     if (logger.isInfoEnabled()) {
  52.                         logger.info("Autowired annotation should only be used on methods with parameters: " +
  53.                                     method);
  54.                     }
  55.                 }
  56.                 boolean required = determineRequiredStatus(ann);
  57.                 PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
  58.                 // 5. 将方法封装成InjectedElement，并添加到集合中，这里用的是AutowiredMethodElement
  59.                 currElements.add(new AutowiredMethodElement(method, required, pd));
  60.             }
  61.         });
  63.         elements.addAll(0, currElements);
  64.         // 返回直接继承的父类
  65.         targetClass = targetClass.getSuperclass();
  66.     }
  67.     // 如果父类不为空则需要把父类的@Autowired属性或方法也找出
  68.     while (targetClass != null && targetClass != Object.class);
  69.     // 6. new InjectionMetadata(clazz, elements)，将找到的所有的待注入属性或方法生成metadata返回
  70.     return InjectionMetadata.forElements(elements, clazz);
  71. }
  • 外层 **do … while …** 的循环被用于递归的查找父类的**@Autowired**属性或方法
  • 通过反射的方式获取到所有属性并循环验证每一个属性是否被**@Autowired**注解
  • 将查找到包含**@Autowired**注解的filed封装成**AutowiredFieldElement**，加入到列表中
  • 循环查找在方法上的注解
  • 将找到的方法封装成**AutowiredMethodElement**，并加入列表

这里需要特别强调一点，InjectedElement被AutowiredFieldElement、AutowiredMethodElement所继承，他们都有各自的inject函数，实现各自的注入。因此改ArrayList elements是拥有2种类型的属性
@Autowired 的实现原理 - 图3

  • 将找到的所有元素列表和clazz作为参数生成metadata数据返回

    2、注入

    ```java // 注入 metadata.inject(bean, beanName, pvs);

public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable { // 获取所有需要被注入的元素 Collection checkedElements = this.checkedElements; Collection elementsToIterate = (checkedElements != null ? checkedElements : this.injectedElements); // 迭代的元素不为空 if (!elementsToIterate.isEmpty()) { for (InjectedElement element : elementsToIterate) { if (logger.isTraceEnabled()) { logger.trace(“Processing injected element of bean ‘“ + beanName + “‘: “ + element); } // 循环注入，这里有可能是AutowiredFieldElement也可能AutowiredMethodElement，因此调用的inject是2个不同的方法 element.inject(target, beanName, pvs); } } }

  1. 利用for循环，遍历刚刚查到到的elements列表，进行注入。<br />在上面有特别提醒，这里的element有可能是`AutowiredFieldElement`类型、或`AutowiredMethodElement`类型。各自代表`@Autowired`注解在属性上、以及注解在方法上的2种不同元素。因此他们调用的`element.inject(target, beanName, pvs);`也是不一样的
  2. <a name="n00T1"></a>
  3. #### 2.1 字段注入(`AutowiredFieldElement`)
  4. ```java
  5. private class AutowiredFieldElement extends InjectionMetadata.InjectedElement {
  6.     @Override
  7.     protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
  8.         Field field = (Field) this.member;
  9.         Object value;
  10.         if (this.cached) {
  11.             value = resolvedCachedArgument(beanName, this.cachedFieldValue);
  12.         }
  13.         else {
  14.             // 专门用于注入的包装类，包装构造函数参数，方法参数或字段
  15.             DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
  16.             // 设置class
  17.             desc.setContainingClass(bean.getClass());
  18.             // 需要被自动注入的beanNames，这里只有可能 = 1，方法注入时才有可能为多个
  19.             Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
  20.             Assert.state(beanFactory != null, "No BeanFactory available");
  21.             TypeConverter typeConverter = beanFactory.getTypeConverter();// 获取类型转换器
  22.             try {
  23.                 // 通过beanFactory获取属性对应的值，比如需要调用getBean("b")获取依赖的属性单例，并且通过自动转型转为需要的类型
  24.                 value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
  25.             }
  26.             catch (BeansException ex) {
  27.                 throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
  28.             }
  29.             synchronized (this) {
  30.                 if (!this.cached) {
  31.                     if (value != null || this.required) {
  32.                         this.cachedFieldValue = desc;
  33.                         // 注册依赖，
  34.                         registerDependentBeans(beanName, autowiredBeanNames);
  35.                         // 因为是属性注入，因此这里只有可能等于1
  36.                         if (autowiredBeanNames.size() == 1) {
  37.                             String autowiredBeanName = autowiredBeanNames.iterator().next();
  38.                             if (beanFactory.containsBean(autowiredBeanName) &&
  39.                                 beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
  40.                                 // 缓存当前value
  41.                                 this.cachedFieldValue = new ShortcutDependencyDescriptor(
  42.                                     desc, autowiredBeanName, field.getType());
  43.                             }
  44.                         }
  45.                     }
  46.                     else {
  47.                         this.cachedFieldValue = null;
  48.                     }
  49.                     this.cached = true;
  50.                 }
  51.             }
  52.         }
  53.         if (value != null) {
  54.             // 通过反射，将value值设置到bean中
  55.             ReflectionUtils.makeAccessible(field);
  56.             field.set(bean, value);
  57.         }
  58.     }
  59. }

上方大部分的工作都在做待注入bean的获取以及类型的转换，如果深究下去可以再把spring Ioc讲一遍，但是核心还是getBean(字段)获取到对应bean…这里就关心核心的语句，就是这2句

  1. if (value != null) {
  2.     // 通过反射，将value值设置到bean中
  3.     ReflectionUtils.makeAccessible(field);
  4.     field.set(bean, value);
  5. }

spring通过反射的方式，调用field的set进行属性的注入

2.2 方法注入(AutowiredMethodElement)

  1. private class AutowiredMethodElement extends InjectionMetadata.InjectedElement {
  3.     @Override
  4.     protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
  5.         if (checkPropertySkipping(pvs)) {
  6.             return;
  7.         }
  8.         // @Autowired标注在方法上
  9.         Method method = (Method) this.member;
  10.         Object[] arguments;
  11.         if (this.cached) {
  12.             // Shortcut for avoiding synchronization...
  13.             // 有缓存
  14.             arguments = resolveCachedArguments(beanName);
  15.         }
  16.         else {
  17.             // 没缓存，直接获取方法上所有的参数
  18.             int argumentCount = method.getParameterCount();
  19.             arguments = new Object[argumentCount];
  20.             DependencyDescriptor[] descriptors = new DependencyDescriptor[argumentCount];
  21.             Set<String> autowiredBeans = new LinkedHashSet<>(argumentCount);
  22.             Assert.state(beanFactory != null, "No BeanFactory available");
  23.             TypeConverter typeConverter = beanFactory.getTypeConverter();
  24.             // 循环所有参数
  25.             for (int i = 0; i < arguments.length; i++) {
  26.                 MethodParameter methodParam = new MethodParameter(method, i);
  27.                 DependencyDescriptor currDesc = new DependencyDescriptor(methodParam, this.required);
  28.                 currDesc.setContainingClass(bean.getClass());
  29.                 descriptors[i] = currDesc;
  30.                 try {
  31.                     // 通过beanFactory，获取代注入的bean，并进行类型转换
  32.                     Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);
  33.                     if (arg == null && !this.required) {
  34.                         arguments = null;
  35.                         break;
  36.                     }
  37.                     arguments[i] = arg;
  38.                 }
  39.                 catch (BeansException ex) {
  40.                     throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(methodParam), ex);
  41.                 }
  42.             }
  43.             synchronized (this) {
  44.                 if (!this.cached) {
  45.                     if (arguments != null) {
  46.                         DependencyDescriptor[] cachedMethodArguments = Arrays.copyOf(descriptors, arguments.length);
  47.                         // 注册依赖
  48.                         registerDependentBeans(beanName, autowiredBeans);
  49.                         // 如果自动注入的个数 = 参数个数，则缓存
  50.                         if (autowiredBeans.size() == argumentCount) {
  51.                             Iterator<String> it = autowiredBeans.iterator();
  52.                             Class<?>[] paramTypes = method.getParameterTypes();
  53.                             for (int i = 0; i < paramTypes.length; i++) {
  54.                                 String autowiredBeanName = it.next();
  55.                                 if (beanFactory.containsBean(autowiredBeanName) &&
  56.                                     beanFactory.isTypeMatch(autowiredBeanName, paramTypes[i])) {
  57.                                     // 缓存
  58.                                     cachedMethodArguments[i] = new ShortcutDependencyDescriptor(
  59.                                         descriptors[i], autowiredBeanName, paramTypes[i]);
  60.                                 }
  61.                             }
  62.                         }
  63.                         // 缓存方法
  64.                         this.cachedMethodArguments = cachedMethodArguments;
  65.                     }
  66.                     else {
  67.                         this.cachedMethodArguments = null;
  68.                     }
  69.                     this.cached = true;
  70.                 }
  71.             }
  72.         }
  73.         if (arguments != null) {
  74.             try {
  75.                 // 反射调用注入方法，将获取到的所有bean作为参数
  76.                 ReflectionUtils.makeAccessible(method);
  77.                 method.invoke(bean, arguments);
  78.             }
  79.             catch (InvocationTargetException ex) {
  80.                 throw ex.getTargetException();
  81.             }
  82.         }
  83.     }
  85. }

这里与属性注入最大的区别在于，@Autowired注解在方法上，方法可以拥有多个参数，因此这里需要通过循环将一个个获取，而获取bean的方式于上面一样，本质都是通过getBean获取。
而核心语句还是2句

  1. // 反射调用注入方法，将获取到的所有bean作为参数
  2. ReflectionUtils.makeAccessible(method);
  3. method.invoke(bean, arguments);

与属性注入不同的是，当@Autowired注解在方法上，例如注解在setter方法上，则只需要直接调用该setter方法将参数数组传入即可以，即使用invoke触发方法，具体属性赋值的过程在setter方法中由用户自行编写。