Compartir tecnología

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

@RequiredArgsConstructor implementa la inyección del constructor

1. @Autowired y@Resource anotación

@Autowired

• @Autowired Es una anotación proporcionada por el marco Spring y se utiliza para ensamblar dependencias automáticamente.
• Se puede utilizar en campos, constructores y métodos de establecimiento.

@Autowired
private ISysUserService userService;
1
2

@Resource

• @Resource Es una anotación proporcionada por Java EE y Spring también la admite para el ensamblaje automático de dependencias.
• Generalmente se utiliza para campos y métodos de establecimiento.

@Resource
private ISysUserService userService;
1
2

2. Inyección de constructor

Usando Lombok @RequiredArgsConstructor

El concepto y uso de springboot @RequiredArgsConstructor-Tencent Cloud Developer Community-Tencent Cloud (tencent.com)

• @RequiredArgsConstructor es una anotación proporcionada por Lombok, que generará automáticamente todosfinal Constructor de campo.
• El uso de la inyección de constructor garantiza que la inyección de dependencia se complete cuando se crea el objeto, lo que garantiza que todas las dependencias no sean nulas.

@RequiredArgsConstructor
@RestController
@RequestMapping("/system/user")
public class SysUserController extends BaseController {
    private final ISysUserService userService;
    private final ISysRoleService roleService;
    private final ISysPostService postService;
    private final ISysDeptService deptService;
    private final ISysUserPostService userPostService;
    
    // 构造函数由 Lombok 自动生成，注入所有 final 字段
}
1
2
3
4
5
6
7
8
9
10
11
12

3. Comparación y ventajas

inyección de campo (@Autowired y@Resource）

• ventaja: El código es conciso y está anotado directamente en los campos.
• defecto：
  • Es difícil realizar pruebas unitarias porque los objetos simulados deben inyectarse mediante reflexión u otros medios.
  • La inyección de dependencia ocurre después de que se crea el objeto, lo que puede causar que las dependencias no se inicialicen por completo.
  • Al violar el principio de inversión de dependencia, la clase depende directamente del contenedor.

inyección constructora

• ventaja：
  • Fuerza que las dependencias se inicialicen completamente cuando se crea el objeto, asegurando que todas las dependencias no sean nulas.
  • Es más fácil realizar pruebas unitarias ya que se pueden inyectar objetos simulados a través del constructor.
  • Está más en línea con el principio de inversión de dependencia y hace que la clase sea más independiente del contenedor.
  • Legibilidad y mantenibilidad del código mejoradas, especialmente cuando hay muchas dependencias.
• defecto: Requiere código de constructor adicional, pero usa el de Lombok @RequiredArgsConstructor Esta carga puede aliviarse.

4. Comparación de ejemplos

usar @Autowired

@RestController
@RequestMapping("/system/user")
public class SysUserController extends BaseController {
    
    @Autowired
    private ISysUserService userService;
    
    @Autowired
    private ISysRoleService roleService;
    
    @Autowired
    private ISysPostService postService;
    
    @Autowired
    private ISysDeptService deptService;
    
    @Autowired
    private ISysUserPostService userPostService;

    // 其他代码
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Usando inyección de constructor

@RequiredArgsConstructor
@RestController
@RequestMapping("/system/user")
public class SysUserController extends BaseController {
    private final ISysUserService userService;
    private final ISysRoleService roleService;
    private final ISysPostService postService;
    private final ISysDeptService deptService;
    private final ISysUserPostService userPostService;

    // 其他代码
}
1
2
3
4
5
6
7
8
9
10
11
12

A través de este método de inyección de constructor, no solo se puede mejorar la solidez y la capacidad de mantenimiento del código, sino que también se pueden utilizar mejor las ventajas de la función de inyección de dependencia de Spring y el código simplificado de Lombok.

beneficio

Inyección del constructor de Spring_blog de inyección del constructor de Spring-CSDN

5. Acerca de las anotaciones

Cuando se utiliza la inyección de constructor, no es necesario agregar anotaciones adicionales, solo es necesario proporcionar el constructor. Spring detectará automáticamente su constructor y realizará la inyección de dependencia.

Utilice inyección de constructor, no se requieren anotaciones adicionales

@RestController
@RequestMapping("/system/user")
public class SysUserController extends BaseController {
    private final ISysUserService userService;
    private final ISysRoleService roleService;
    private final ISysPostService postService;
    private final ISysDeptService deptService;
    private final ISysUserPostService userPostService;

    // 自己编写构造函数
    public SysUserController(ISysUserService userService, 
                             ISysRoleService roleService, 
                             ISysPostService postService, 
                             ISysDeptService deptService, 
                             ISysUserPostService userPostService) {
        this.userService = userService;
        this.roleService = roleService;
        this.postService = postService;
        this.deptService = deptService;
        this.userPostService = userPostService;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Puntos clave del uso de la inyección de constructor

1. Definir el constructor:
   • Defina un constructor en la clase que contenga todas las dependencias requeridas.
2. Inyección automática por resorte:
   • Cuando Spring crea una instancia de Bean, reconoce y llama automáticamente al constructor e inyecta las dependencias requeridas.

Código de muestra

package com.example.demo.controller;

import com.example.demo.service.ISysUserService;
import com.example.demo.service.ISysRoleService;
import com.example.demo.service.ISysPostService;
import com.example.demo.service.ISysDeptService;
import com.example.demo.service.ISysUserPostService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/system/user")
public class SysUserController {

    private final ISysUserService userService;
    private final ISysRoleService roleService;
    private final ISysPostService postService;
    private final ISysDeptService deptService;
    private final ISysUserPostService userPostService;

    // 构造函数注入
    public SysUserController(ISysUserService userService, 
                             ISysRoleService roleService, 
                             ISysPostService postService, 
                             ISysDeptService deptService, 
                             ISysUserPostService userPostService) {
        this.userService = userService;
        this.roleService = roleService;
        this.postService = postService;
        this.deptService = deptService;
        this.userPostService = userPostService;
    }

    // 你的控制器方法
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

En este ejemplo, no es necesario utilizar anotaciones adicionales para anotar el constructor; Spring identificará e inyectará automáticamente la dependencia. (Por supuesto, no se informará ningún error si se marca, pero solo se puede usar @Autowired y no se puede usar @Resouce.@Resource Las anotaciones se utilizan normalmente para la inyección de métodos de establecimiento o de campo)

circunstancias adicionales

1. Múltiples constructores:
   • Si hay varios constructores en una clase y solo uno de ellos tiene parámetros de inyección, Spring usará este constructor para la inyección.
   • Si hay varios constructores con parámetros inyectados, debe usar @Autowired anotación para especificar explícitamente qué constructor usar.

Código de muestra (múltiples constructores)

package com.example.demo.controller;

import com.example.demo.service.ISysUserService;
import com.example.demo.service.ISysRoleService;
import com.example.demo.service.ISysPostService;
import com.example.demo.service.ISysDeptService;
import com.example.demo.service.ISysUserPostService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/system/user")
public class SysUserController {

    private final ISysUserService userService;
    private final ISysRoleService roleService;
    private final ISysPostService postService;
    private final ISysDeptService deptService;
    private final ISysUserPostService userPostService;

    // 使用 @Autowired 明确指定使用哪个构造函数
    @Autowired
    public SysUserController(ISysUserService userService, 
                             ISysRoleService roleService, 
                             ISysPostService postService, 
                             ISysDeptService deptService, 
                             ISysUserPostService userPostService) {
        this.userService = userService;
        this.roleService = roleService;
        this.postService = postService;
        this.deptService = deptService;
        this.userPostService = userPostService;
    }

    // 另一个构造函数
    public SysUserController(ISysUserService userService) {
        this.userService = userService;
        this.roleService = null;
        this.postService = null;
        this.deptService = null;
        this.userPostService = null;
    }

    // 你的控制器方法
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

En este ejemplo, dado que hay varios constructores, es necesario utilizar @Autowired Anotaciones para especificar explícitamente qué constructor usa Spring para la inyección de dependencia.