目录

一、@Autowired和@Resource简介

二、@Autowired和@Resource的区别

1. @Autowired 默认按类型装配 (spring提供的)
2. @Resource 默认按照名称进行装配 (JDK1.6开始支持的注解)
3. @Autowired 和 @Resource 作用域不同

三、@Autowired和@Resource的正确使用姿势

正文开始

一、@Autowired和@Resource简介

@Autowired、@Resource 可以对成员变量、方法或构造函数进行标注，来完成自动装配的工作。

二、@Autowired和@Resource的区别

1. @Autowired 默认按类型装配（这个注解是属于spring的），默认情况下必须要求依赖对象必须存在，如果要允许null值，可以设置它的required属性为false，如@Autowired(required=false) ，如果我们想使用名称装配可以结合 @Qualifier 注解进行使用，如下：

  @Autowired(required = false)
  @Qualifier("baseDao")
  private BaseDao baseDao;

• @Autowired 实现：

注解驱动配置会向spring容器中注册AutowiredAnnotationBeanPostProcessor。
当 Spring 容器启动时，AutowiredAnnotationBeanPostProcessor 将扫描 Spring 容器中所有 Bean，当发现 Bean 中拥有 @Autowired 注释时就找到和其匹配（默认按类型匹配）的 Bean，并注入到对应的地方中去。

2. @Resource 默认按照名称进行装配 (JDK1.6开始支持的注解)。名称可以通过name属性进行指定。也提供按照byType 注入。

• 如果没有指定name属性，当注解写在字段上时，默认取字段名，按照名称查找。
• 当注解标注在属性的setter方法上，即默认取属性名作为bean名称寻找依赖对象。
• 当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

  @Resource(name = "baseDao")
  private BaseDao baseDao;

  @Resource(type = BaseDao.class)
  private BaseDao baseDao2;

• @Resource装配顺序

• 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常
• 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常
• 如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常
• 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配；

3. @Autowired 和 @Resource 作用域不同

• @Autowired 可以作用在construct，field，setter方法（可以有多个参数，并且参数上可以使用@Qualifies进行标注）

• @Resource 只可以使用在field，setter方法上（只能是单个单数的setter方法）

三、@Autowired和@Resource的正确使用姿势

在日常工作中，我们使用Idea写代码的时候，看到之前的项目中显示有warning的提示，去看了下，是如下代码

@Autowired
private JdbcTemplate jdbcTemplate;

提示的警告信息

Field injection is not recommended Inspection info: Spring Team recommends: "Always use constructor based dependency injection in your beans. Always use assertions for mandatory dependencies".

这段是Spring工作组的建议，大致翻译一下：

属性字段注入的方式不推荐，检查到的问题是：Spring团队建议:"始终在bean中使用基于构造函数的依赖项注入，始终对强制性依赖项使用断言"

如图

Field注入警告

注入方式

• 基于构造函数的依赖注入

public class UserServiceImpl implents UserService{
    private UserDao userDao;
    
    @Autowired
    public UserServiceImpl(UserDao userDao){
        this.userDao = userDao;
    }
}

• 基于Setter的依赖注入

public class UserServiceImpl implents UserService{
     private UserDao userDao;
     
     @Autowired
     public setUserDao(UserDao userDao){
         this.userDao = userDao;
     }
 }

• 基于字段的依赖注入

public class UserServiceImpl implents UserService{
     @Autowired
     private UserDao userDao;
 }

基于字段的依赖注入方式会在Idea当中吃到黄牌警告，但是这种使用方式使用的也最广泛，因为简洁方便.您甚至可以在一些Spring指南中看到这种注入方法，尽管在文档中不建议这样做.(有点执法犯法的感觉)

如图

Spring自己的文档

基于字段的依赖注入缺点

• 对于有final修饰的变量不好使

Spring的IOC对待属性的注入使用的是set形式，但是final类型的变量在调用class的构造函数的这个过程当中就得初始化完成，这个是基于字段的依赖注入做不到的地方．只能使用基于构造函数的依赖注入的方式

• 掩盖单一职责的设计思想

我们都知道在OOP的设计当中有一个单一职责思想，如果你采用的是基于构造函数的依赖注入的方式来使用Spring的IOC的时候，当你注入的太多的时候，这个构造方法的参数就会很庞大，类似于下面。

当你看到这个类的构造方法那么多参数的时候，你自然而然的会想一下:这个类是不是违反了单一职责思想?.但是使用基于字段的依赖注入不会让你察觉，你会很沉浸在@Autowired当中

public class VerifyServiceImpl implents VerifyService{
    
  private AccountService accountService;
  private UserService userService;
  private IDService idService;
  private RoleService roleService;
  private PermissionService permissionService;
  private EnterpriseService enterpriseService;
  private EmployeeService employService;
  private TaskService taskService;
  private RedisService redisService;
  private MQService mqService;

  public SystemLogDto(AccountService accountService, 
                      UserService userService, 
                      IDService idService, 
                      RoleService roleService, 
                      PermissionService permissionService, 
                      EnterpriseService enterpriseService, 
                      EmployeeService employService, 
                      TaskService taskService, 
                      RedisService redisService, 
                      MQService mqService) {
      this.accountService = accountService;
      this.userService = userService;
      this.idService = idService;
      this.roleService = roleService;
      this.permissionService = permissionService;
      this.enterpriseService = enterpriseService;
      this.employService = employService;
      this.taskService = taskService;
      this.redisService = redisService;
      this.mqService = mqService;
  }
}

• 与Spring的IOC机制紧密耦合

当你使用基于字段的依赖注入方式的时候，确实可以省略构造方法和setter这些个模板类型的方法，但是，你把控制权全给Spring的IOC了，别的类想重新设置下你的某个注入属性，没法处理(当然反射可以做到)。

本身Spring的目的就是解藕和依赖反转，结果通过再次与类注入器（在本例中为Spring）耦合，失去了通过自动装配类字段而实现的对类的解耦，从而使类在Spring容器之外无效。

• 隐藏依赖性

当你使用Spring的IOC的时候，被注入的类应当使用一些public类型(构造方法，和setter类型方法)的方法来向外界表达:我需要什么依赖.但是基于字段的依赖注入的方式，基本都是private形式的，private把属性都给封印到class当中了。

• 无法对注入的属性进行安检

基于字段的依赖注入方式，你在程序启动的时候无法拿到这个类，只有在真正的业务使用的时候才会拿到，一般情况下，这个注入的都是非null的，万一要是null怎么办，在业务处理的时候错误才爆出来，时间有点晚了，如果在启动的时候就暴露出来，那么bug就可以很快得到修复(当然你可以加注解校验)。

如果你想在属性注入的时候，想根据这个注入的对象操作点东西，你无法办到。我碰到过的例子：一些配置信息啊，有些人总是会配错误，等到了自己测试业务阶段才知道配错了，例如线程初始个数不小心配置成了3000，机器真的是狂叫啊！这个时候就需要再某些Value注入的时候做一个检测机制。

结论

通过上面，我们可以看到，基于字段的依赖注入方式有很多缺点,我们应当避免使用基于字段的依赖注入，推荐的方法是使用基于构造函数和基于setter的依赖注入。对于必需的依赖项，建议使用基于构造函数的注入，以使它们成为不可变的，并防止它们为null。对于可选的依赖项，建议使用基于Setter的注入。

相关文章链接：
https://www.jianshu.com/p/872440c92e8a
https://segmentfault.com/a/1190000021713094
https://mp.weixin.qq.com/s/Ba_AVEcyWEp6skMwxQ-x5A