这个 Spring 问题把我问懵了

• @Autowired, @Resource,  @Inject 三个注解的区别

• 当你在使用@Autowired时，是否有出现过Field injection is not recommended的警告？你知道这是为什么吗？

• Spring 依赖注入有哪几种方式？官方是怎么建议使用的呢？

@Autowired, @Resource,  @Inject 三个注解的区别

@Autowired

public interface Svc {

    void sayHello();
}

@Service
public class SvcA implements Svc {

    @Override
    public void sayHello() {
        System.out.println("hello, this is service A");
    }

}

@Service
public class SvcB implements Svc {

    @Override
    public void sayHello() {
        System.out.println("hello, this is service B");
    }

}

@Service
public class SvcC implements Svc {

    @Override
    public void sayHello() {
        System.out.println("hello, this is service C");
    }
}

@SpringBootTest
public class SimpleTest {

    @Autowired
    // @Qualifier("svcA")
    Svc svc;

    @Test
    void rc() {
        Assertions.assertNotNull(svc);
        svc.sayHello();
    }

}

• 如果有
  @Qualifier
  注解，则按照
  @Qualifier
  指定的
  name
  进行匹配，
  查找name为svcA的bean
  
• 如果没有，则按照变量名进行匹配，
  查找name为svcA的bean
  

@Inject

Guice 是 google 开源的轻量级 DI 框架

@Resource

1. 如果同时指定了
   name
   和
   type
   ，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。
   
2. 如果指定了
   name
   ，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。
   
3. 如果指定了
   type
   ，则从上下文中找到类型匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。
   
4. 如果既没有指定
   name
   ，又没有指定
   type
   ，则默认按照
   byName
   方式进行装配；如果没有匹配，按照
   byType
   h进行装配。
   

IDEA 提示 Field injection is not recommended

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".

不建议使用基于 field 的注入方式。

Spring 开发团队建议：在你的Spring Bean 永远使用基于constructor 的方式进行依赖注入。对于必须的依赖，永远使用断言来确认。

@Service
public class HelpService {
    @Autowired
    @Qualifier("svcB")
    private Svc svc;

    public void sayHello() {
        svc.sayHello();
    }
}

public interface Svc {
    void sayHello();
}

@Service
public class SvcB implements Svc {
    @Override
    public void sayHello() {
        System.out.println("hello, this is service B");
    }
}

@Service
public class HelpService {
    private final Svc svc;
    
    @Autowired
    public HelpService(@Qualifier("svcB") Svc svc) {
        // Assert.notNull(svc, "svc must not be null");
        this.svc = svc;
    }
    
    public void sayHello() {
        svc.sayHello();
    }
}

• 基于 field 注入（属性注入）
  
• 基于 setter 注入
  
• 基于 constructor 注入（构造器注入）
  

1. 基于 field 注入

@Autowired
private Svc svc;

2. 基于 setter 方法注入

private Helper helper;

@Autowired
public void setHelper(Helper helper) {
    this.helper = helper;
}

注：在
Spring 4.3
及以后的版本中，setter 上面的
@Autowired
注解是可以不写的。

3. 基于 constructor 注入

private final Svc svc;
    
@Autowired
public HelpService(@Qualifier("svcB") Svc svc) {
    this.svc = svc;
}

在
Spring 4.3
及以后的版本中，如果这个类只有一个构造方法，那么这个构造方法上面也可以不写
@Autowired
注解。

基于 field 注入的好处

基于 field 注入的坏处

成也萧何败也萧何

这个问题在我司的项目代码真的很常见。

• 你的类和依赖容器强耦合，不能在容器外使用
  
• 你的类不能绕过反射（例如单元测试的时候）进行实例化，必须通过依赖容器才能实例化，这更像是集成测试
  

Spring 开发团队的建议

Since you can mix constructor-based and setter-based DI, it is a good rule of thumb to use constructors for mandatory dependencies and setter methods or configuration methods for optional dependencies.

• 强制依赖就用构造器方式
  
• 可选、可变的依赖就用setter 注入
  

The Spring team generally advocates constructor injection as it enables one to implement application components as immutable objects and to ensure that required dependencies are not null. Furthermore constructor-injected components are always returned to client (calling) code in a fully initialized state. As a side note, a large number of constructor arguments is a bad code smell, implying that the class likely has too many responsibilities and should be refactored to better address proper separation of concerns.

Setter injection should primarily only be used for optional dependencies that can be assigned reasonable default values within the class. Otherwise, not-null checks must be performed everywhere the code uses the dependency. One benefit of setter injection is that setter methods make objects of that class amenable to reconfiguration or re-injection later.

小结

juejin.cn/post/6844904056230690824