Condivisione della tecnologia

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

@RequiredArgsConstructor implementa l'iniezione del costruttore

1. @Autowired E@Resource annotazione

@Autowired

• @Autowired È un'annotazione fornita dal framework Spring e viene utilizzata per assemblare automaticamente le dipendenze.
• Può essere utilizzato su campi, costruttori e metodi setter.

@Autowired
private ISysUserService userService;
1
2

@Resource

• @Resource È un'annotazione fornita da Java EE e Spring la supporta anche per l'assemblaggio automatico delle dipendenze.
• Generalmente utilizzato per campi e metodi setter.

@Resource
private ISysUserService userService;
1
2

2. Iniezione del costruttore

Usando Lombok @RequiredArgsConstructor

Il concetto e l'utilizzo di springboot @RequiredArgsConstructor-Tencent Cloud Developer Community-Tencent Cloud (tencent.com)

• @RequiredArgsConstructor è un'annotazione fornita da Lombok, che genererà automaticamente allfinal Costruttore di campi.
• L'utilizzo dell'inserimento del costruttore garantisce che l'inserimento delle dipendenze venga completato al momento della creazione dell'oggetto, garantendo che tutte le dipendenze siano diverse da null.

@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. Confronto e vantaggi

iniezione sul campo (@Autowired E@Resource）

• vantaggio: Il codice è conciso e annotato direttamente sui campi.
• discordanza：
  • Difficile eseguire test unitari perché gli oggetti simulati devono essere iniettati tramite riflessione o altri mezzi.
  • L'inserimento delle dipendenze avviene dopo la creazione dell'oggetto, il che potrebbe causare l'inizializzazione incompleta delle dipendenze.
  • Violando il principio di inversione delle dipendenze, la classe dipende direttamente dal contenitore.

iniezione del costruttore

• vantaggio：
  • Forza la completa inizializzazione delle dipendenze al momento della creazione dell'oggetto, garantendo che tutte le dipendenze siano diverse da null.
  • Più semplice il test unitario poiché gli oggetti fittizi possono essere inseriti tramite il costruttore.
  • È più in linea con il principio di inversione delle dipendenze e rende la classe più indipendente dal contenitore.
  • Leggibilità e manutenibilità del codice migliorate, soprattutto quando sono presenti molte dipendenze.
• discordanza: Richiede codice costruttore aggiuntivo, ma utilizza quello di Lombok @RequiredArgsConstructor Questo peso può essere alleviato.

4. Confronto di esempi

utilizzo @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

Utilizzando l'iniezione del costruttore

@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

Attraverso questo metodo di iniezione del costruttore, non solo è possibile migliorare la robustezza e la manutenibilità del codice, ma è anche possibile utilizzare meglio i vantaggi della funzione di iniezione delle dipendenze di Spring e del codice semplificato di Lombok.

beneficio

Blog del costruttore Spring Injection_spring Constructor Injection-CSDN

5. Informazioni sulle annotazioni

Quando si utilizza l'iniezione del costruttore, non è necessario aggiungere ulteriori annotazioni, è sufficiente fornire solo il costruttore. Spring rileverà automaticamente il tuo costruttore ed eseguirà l'iniezione delle dipendenze.

Utilizza l'iniezione del costruttore, non sono necessarie annotazioni aggiuntive

@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

Punti chiave dell'utilizzo dell'iniezione del costruttore

1. Definire il costruttore:
   • Definire un costruttore nella classe che contenga tutte le dipendenze richieste.
2. Iniezione automatica a molla:
   • Quando Spring crea un'istanza Bean, riconosce e chiama automaticamente il costruttore e inserisce le dipendenze richieste.

Codice d'esempio

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

In questo esempio, non è necessario utilizzare annotazioni aggiuntive per annotare il costruttore, Spring identificherà e inietterà automaticamente la dipendenza. (Ovviamente, se contrassegnato non verrà segnalato alcun errore, ma è possibile utilizzare solo @Autowired e @Resouce non può essere utilizzato.@Resource Le annotazioni vengono generalmente utilizzate per l'iniezione del metodo sul campo o setter)

circostanze aggiuntive

1. Costruttori multipli:
   • Se sono presenti più costruttori in una classe e solo uno di essi ha parametri di iniezione, Spring utilizzerà questo costruttore per l'iniezione.
   • Se sono presenti più costruttori con parametri inseriti, è necessario utilizzare @Autowired annotazione per specificare esplicitamente quale costruttore utilizzare.

Codice di esempio (più costruttori)

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

In questo esempio, poiché sono presenti più costruttori, è necessario utilizzare @Autowired Annotazioni per specificare esplicitamente quale costruttore Spring utilizza per l'inserimento delle dipendenze.