Spring三种注入方式属性注入setter注入与构造器注入

你的名字 2022-09-04 09:53 326阅读 0赞

### Spring三种注入方式属性注入setter注入与构造器注入 ###

*  1. @Autowired，@Resource，@Inject 三个注解的区别
 *   *  1.1 @Autowired
     *  1.2 @Inject
     *  1.3 @Resource
 *  2. Spring 3种依赖注入方式
 *   *  2.1 基于 field 注入（属性注入）
     *   *  2.1.1 field概述
         *  2.1.1 field特点
     *  2.2 基于 setter 注入
     *  2.3 基于 constructor 注入（构造器注入）
 *  3. @Autowired注解警告Field injection is not recommended
 *  4. Spring开发团队建议注入方式

# 1. @Autowired，@Resource，@Inject 三个注解的区别 #

## 1.1 @Autowired ##

@Autowired为Spring 框架提供的注解，需要导入包org.springframework.beans.factory.annotation.Autowired。

装配顺序：  
1.按照type在上下文中查找匹配的bean,查找type为Svc的bean  
2.如果有多个bean，则按照name进行匹配如果有@Qualifier注解，则按照@Qualifier指定的name进行匹配,查找name为svcA的bean如果没有，则按照变量名进行匹配查找name为svc的bean。  
3.匹配不到，则报错。（@Autowired(required=false)，如果设置required为false(默认为true)，则注入失败时不会抛出异常）。

## 1.2 @Inject ##

在 Spring 的环境下，@Inject和@Autowired 是相同的，因为它们的依赖注入都是使用AutowiredAnnotationBeanPostProcessor来处理的。

@Inject是 JSR-330 定义的规范，如果使用这种方式，切换到Guice也是可以的。  
Guice 是 google 开源的轻量级 DI 框架

如果硬要说两个的区别，首先@Inject是 Java EE 包里的，在 SE 环境需要单独引入。另一个区别在于@Autowired可以设置required=false而@Inject并没有这个属性。

## 1.3 @Resource ##

@Resource是 JSR-250 定义的注解。Spring 在 CommonAnnotationBeanPostProcessor实现了对JSR-250的注解的处理，其中就包括@Resource。  
@Resource有两个重要的属性：name和type，而Spring 将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。

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

# 2. Spring 3种依赖注入方式 #

## 2.1 基于 field 注入（属性注入） ##

### 2.1.1 field概述 ###

所谓基于 field 注入，就是在bean的变量上使用注解进行依赖注入。本质上是通过反射的方式直接注入到 field。这是我平常开发中看的最多也是最熟悉的一种方式，同时，也正是 Spring 团队所不推荐的方式。比如：

// 方式一：Autowired注入,@Autowired(required=false)注入失败不校验
        @Autowired
        @Qualifier("InjectionAServiceImpl")
        InjectionService injectionService;

### 2.1.1 field特点 ###

优点：简洁，通俗易懂。  
缺点：  
1.容易违背了单一职责原则 。因为依赖简单，很容易过多依赖，不想构造器或者setter参数会很多，很明显地发现 something is wrong。

2.依赖注入与容器本身耦合。依赖注入框架的核心思想之一就是受容器管理的类不应该去依赖容器所使用的依赖。换句话说，这个类应该是一个简单的 POJO(Plain Ordinary Java Object)能够被单独实例化并且你也能为它提供它所需的依赖。

## 2.2 基于 setter 注入 ##

通过对应变量的setXXX()方法以及在方法上面使用注解，来完成依赖注入。比如：

// 方式三：setter注入
        private InjectionService injectionService;
        @Autowired
        public void setInjectionService(@Qualifier("InjectionAServiceImpl") InjectionService injectionService) { 
            this.injectionService = injectionService;
        }

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

## 2.3 基于 constructor 注入（构造器注入） ##

将各个必需的依赖全部放在带有注解构造方法的参数中，并在构造方法中完成对应变量的初始化，这种方式，就是基于构造方法的注入。比如：

// 方式二：构造器注入
        private final InjectionService injectionService;
        @Autowired
        public InjectionController(@Qualifier("InjectionAServiceImpl")InjectionService injectionService) { 
            this.injectionService = injectionService;
        }

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

# 3. @Autowired注解警告Field injection is not recommended #

在使用 IDEA 进行 Spring 开发的时候，当你在字段上面使用@Autowired注解的时候，你会发现 IDEA 会有警告提示：

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 的方式进行依赖注入。对于必须的依赖，永远使用断言来确认。

将光标放到@Autowired处，使用Alt + Enter 快捷进行修改之后，代码就会变成基于 Constructor 的注入方式。  
如果按照 Spring 团队的建议，如果svc是必须的依赖，应该使用Assert.notNull(svc, “svc must not be null”)来确认。

# 4. 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 注入。  
当然你可以在同一个类中使用这两种方法。构造器注入更适合强制性的注入旨在不变性，Setter 注入更适合可变性的注入。

让我们看看 Spring 这样推荐的理由，首先是基于构造方法注入，  
❝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.❞  
Spring 团队提倡使用基于构造方法的注入，因为这样一方面可以将依赖注入到一个不可变的变量中 (注：final 修饰的变量)，另一方面也可以保证这些变量的值不会是 null。此外，经过构造方法完成依赖注入的组件 (注：比如各个 service)，在被调用时可以保证它们都完全准备好了。与此同时，从代码质量的角度来看，一个巨大的构造方法通常代表着出现了代码异味，这个类可能承担了过多的责任。

而对于基于 setter 的注入，他们是这么说的：  
❝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.❞

基于 setter 的注入，则只应该被用于注入非必需的依赖，同时在类中应该对这个依赖提供一个合理的默认值。如果使用 setter 注入必需的依赖，那么将会有过多的 null 检查充斥在代码中。使用 setter 注入的一个优点是，这个依赖可以很方便的被改变或者重新注入。