背景
做为一名 Java 程序员，日常开发中使用最多的便是 Spring，工作了很多年，很多人都停留在使用的层面上，甚至连最基本的概念都没搞懂。笔者在 Java 领域也辛勤耕耘了几年，为了避免浮于表面，在今年6月份开始看 Spring 的源码，其优秀的设计确实值得每一个 Java 开发者去学习。使用 Spring 进行依赖注入我们最常使用的注解是 @Autowired，最近有同事用到了 @Resource 注解，可能了解到我在看 Spring，因此有向我请教和 @Autowired 有什么区别。鉴于多数人可能对这两者的区别不甚理解，而网上大多数文章又只给出结论，甚至结论中也存在一些错误，因此有必要开一篇文章进行深入分析。知其然，还要知其所以然。
@Autowired 和 @Resource 的区别
这里先给出结论，后面我们将会带着结论去分析，结论到底是否正确。
区别一：所属不同。
@Autowired 是 spring-beans 模块提供的注解。
@Resource 是 JSR 250 规范提出的注解，由 JDK 自带。
区别二：装配方式不同。两者都可以标注在属性或 setter 方法上。
@Autowired 注解只能按照类型装配依赖，如果需要按照名称装配还需要指定 @Qualifier 注解。
@Resource 默认依赖 bean 的名称为属性名，并且可以通过其属性 name 进行指定。默认依赖的 bean 的类型为属性的类型，并且可以通过 type 属性进行指定。 如果未指定依赖的 bean 的名称并且属性名对应的 bean 在容器中不存在时才会按照类型进行注入，否则按照名称进行注入依赖。
区别三：是否强依赖不同。
@Autowired 指定的依赖默认必须存在，可以通过 requied 属性指定不存在。
@Resource 指定的依赖必须存在。
原理分析
@Autowired 注入分析
Spring 使用 AutowiredAnnotationBeanPostProcessor 对 @Autowired 进行处理。具体来说注入属性的方法位于 AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject，注入方法参数的方法位于 AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement#inject，它们的处理方式基本类似。以注入属性的流程为例进行分析，查看属性注入相关代码如下。
private class AutowiredMethodElement extends InjectionMetadata.InjectedElement { public AutowiredFieldElement(Field field, boolean required) { super(field, null); this.required = required; } // 注入属性 @Override protected void inject(Object bean, @Nullable String beanName, @Nullable 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<>(1); Assert.state(beanFactory != null, "No BeanFactory available"); TypeConverter typeConverter = beanFactory.getTypeConverter(); try { // 解析依赖 value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter); } catch (BeansException ex) { throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex); } ... 省略部分代码 } if (value != null) { ReflectionUtils.makeAccessible(field); field.set(bean, value); } } }
可以看到，Spring 对 @Autowired 标注的属性的注入只是将属性转换为依赖描述符 DependencyDescriptor ，然后调用 BeanFactory 解析依赖的方法。转换为依赖描述符时需要指定是否依赖是必须的，这个值在实例化 AutowiredFieldElement 时指定。AutowiredAnnotationBeanPostProcessor 实例化 AutowiredFieldElement 的相关代码如下。
// 注解属性名 private String requiredParameterName = "required"; // 依赖必须存在的属性值 private boolean requiredParameterValue = true; // 构建注入元数据 private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) { if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) { return InjectionMetadata.EMPTY; } List<InjectionMetadata.InjectedElement> elements = new ArrayList<>(); Class<?> targetClass = clazz; do { final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>(); ReflectionUtils.doWithLocalFields(targetClass, field -> { MergedAnnotation<?> ann = findAutowiredAnnotation(field); if (ann != null) { if (Modifier.isStatic(field.getModifiers())) { ... 省略日志打印 return; } // 循环属性，将 @Autowired 标注的属性转换为 AutowiredFieldElement boolean required = determineRequiredStatus(ann); currElements.add(new AutowiredFieldElement(field, required)); } }); ... 省略方法参数上 @Autowired 注解的处理 elements.addAll(0, currElements); targetClass = targetClass.getSuperclass(); } while (targetClass != null && targetClass != Object.class); return InjectionMetadata.forElements(elements, clazz); } // 判断依赖是否必须存在 protected boolean determineRequiredStatus(MergedAnnotation<?> ann) { // The following (AnnotationAttributes) cast is required on JDK 9+. return determineRequiredStatus((AnnotationAttributes) ann.asMap(mergedAnnotation -> new AnnotationAttributes(mergedAnnotation.getType()))); } // 判断依赖是否必须存在 @Deprecated protected boolean determineRequiredStatus(AnnotationAttributes ann) { return (!ann.containsKey(this.requiredParameterName) || this.requiredParameterValue == ann.getBoolean(this.requiredParameterName)); }
Spring 构建注入元数据时通过反射获取属性，然后将属性转换为 AutowiredFieldElement ，而 required 的值的获取则会读取注解中的 required 属性，如果不存在或值为 true 则依赖必须存在。
至此，可以看出 @Autowired 的处理只是把属性或方法参数转换为依赖描述符，然后调用 BeanFactory 依赖注入的方法，至于依赖是否必须存在则可以由 @Autowired 的 required 属性值进行指定。AutowireCapableBeanFactory#resolveDependency 方法完成真正的依赖注入，其会根据依赖的类型注入 0 到多个 bean 。例如如果依赖是一个 Map，则 Spring 会把 Map 值类型对应的 bean 全部存在到 map 中，而如果依赖的是普通的类型而 Spring 中存在多个相同类型的 bean，Spring 又无法确定使用哪一个则需要使用 @Primary 指定主要的 bean 或使用 @Qualifier 指定依赖的 bean 的名称。由于篇幅问题，感兴趣的小伙伴可自行查阅相关代码。
@Resource 注入分析
除了对 Spring 自带注解的支持，Spring 对 JSR 250 等各种规范也进行了支持，对 @Resource 的处理 Spring 使用 CommonAnnotationBeanPostProcessor 进行。注入 @Resource 标注的属性或方法的相关代码如下。
public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable { protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName) throws NoSuchBeanDefinitionException { Object resource; Set<String> autowiredBeanNames; String name = element.name; if (factory instanceof AutowireCapableBeanFactory) { AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory; DependencyDescriptor descriptor = element.getDependencyDescriptor(); // fallbackToDefaultTypeMatch 默认为 true, isDefaultName 表示是否使用默认的属性名称，name 表示属性名称 if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) { // 优先按照 bean 名称进行依赖注入，不存在则按照类型进行注入 autowiredBeanNames = new LinkedHashSet<>(); resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null); if (resource == null) { throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object"); } } else { resource = beanFactory.resolveBeanByName(name, descriptor); autowiredBeanNames = Collections.singleton(name); } } else { resource = factory.getBean(name, element.lookupType); autowiredBeanNames = Collections.singleton(name); } if (factory instanceof ConfigurableBeanFactory) { ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory; for (String autowiredBeanName : autowiredBeanNames) { if (requestingBeanName != null && beanFactory.containsBean(autowiredBeanName)) { beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName); } } } return resource; } }
可以看到，Spring 会对根据 LookupElement 进行判断，如果使用默认的属性名，并且属性名在 Spring 中不存在对应的 bean，则会委托给 AutowireCapableBeanFactory#resolveDependency 进行处理，此时和 @Autowired 注解保持一致。如果 @Resource 指定了 bean 名称或者属性名对应的 bean 在容器中存在，Spring 会按照名称进行依赖注入。而非绝对的未指定名称则按照类型注入，这点需要注意。
总结
本篇介绍了 Spring 依赖注入中 @Autowired 和 @Resource 的区别，并从源码角度进行了分析。网上的博客质量参差不齐，初学 Spring 时我也在网上查了一些资料，一度认为 @Resource 未指定名称就会按照类型进行注入，这种错误的想法在看到相关源码之后自然能够一眼辨认出来，希望大家看网上文章时时刻持有怀疑态度，经过验证之后才能确认。最后欢迎大家留言评论交流。
