Technologieaustausch

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

@RequiredArgsConstructor implementiert die Konstruktorinjektion

1. @Autowired Und@Resource Anmerkung

@Autowired

• @Autowired Es handelt sich um eine vom Spring-Framework bereitgestellte Annotation, mit der Abhängigkeiten automatisch zusammengestellt werden.
• Kann für Felder, Konstruktoren und Setter-Methoden verwendet werden.

@Autowired
private ISysUserService userService;
1
2

@Resource

• @Resource Es handelt sich um eine von Java EE bereitgestellte Annotation, die von Spring auch für die automatische Zusammenstellung von Abhängigkeiten unterstützt wird.
• Wird im Allgemeinen für Felder und Setter-Methoden verwendet.

@Resource
private ISysUserService userService;
1
2

2. Konstruktorinjektion

Mit Lombok @RequiredArgsConstructor

Das Konzept und die Verwendung von Springboot @RequiredArgsConstructor-Tencent Cloud Developer Community-Tencent Cloud (tencent.com)

• @RequiredArgsConstructor ist eine von Lombok bereitgestellte Annotation, die alle automatisch generiertfinal Feldkonstruktor.
• Die Verwendung der Konstruktorinjektion stellt sicher, dass die Abhängigkeitsinjektion abgeschlossen ist, wenn das Objekt erstellt wird, und stellt sicher, dass alle Abhängigkeiten ungleich Null sind.

@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. Vergleich und Vorteile

Feldinjektion (@Autowired Und@Resource）

• Vorteil: Der Code ist prägnant und direkt in den Feldern mit Anmerkungen versehen.
• Mangel：
  • Schwieriger Unit-Test, da Scheinobjekte über Reflexion oder auf andere Weise eingefügt werden müssen.
  • Die Abhängigkeitsinjektion erfolgt nach der Objekterstellung, was dazu führen kann, dass Abhängigkeiten unvollständig initialisiert werden.
  • Unter Verstoß gegen das Abhängigkeitsinversionsprinzip hängt die Klasse direkt vom Container ab.

Konstruktorinjektion

• Vorteil：
  • Erzwingen Sie die vollständige Initialisierung von Abhängigkeiten, wenn das Objekt erstellt wird, und stellen Sie sicher, dass alle Abhängigkeiten ungleich Null sind.
  • Einfacherer Unit-Test, da Scheinobjekte über den Konstruktor eingefügt werden können.
  • Es entspricht eher dem Prinzip der Abhängigkeitsumkehr und macht die Klasse unabhängiger vom Container.
  • Verbesserte Lesbarkeit und Wartbarkeit des Codes, insbesondere bei vielen Abhängigkeiten.
• Mangel: Erfordert zusätzlichen Konstruktorcode, verwendet aber den von Lombok @RequiredArgsConstructor Diese Belastung kann gemildert werden.

4. Beispielvergleich

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

Konstruktorinjektion verwenden

@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

Durch diese Methode der Konstruktorinjektion können nicht nur die Robustheit und Wartbarkeit des Codes verbessert werden, sondern auch die Abhängigkeitsinjektionsfunktionen von Spring und die Vorteile des vereinfachten Codes von Lombok besser genutzt werden.

Nutzen

Spring's Constructor Injection_spring Constructor Injection-CSDN Blog

5. Über Anmerkungen

Bei Verwendung der Konstruktorinjektion müssen keine zusätzlichen Anmerkungen hinzugefügt werden, Sie müssen lediglich den Konstruktor bereitstellen. Spring erkennt Ihren Konstruktor automatisch und führt eine Abhängigkeitsinjektion durch.

Verwenden Sie die Konstruktorinjektion, keine zusätzlichen Anmerkungen erforderlich

@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

Wichtige Punkte bei der Verwendung der Konstruktorinjektion

1. Definieren Sie den Konstruktor:
   • Definieren Sie in der Klasse einen Konstruktor, der alle erforderlichen Abhängigkeiten enthält.
2. Automatische Federeinspritzung:
   • Wenn Spring eine Bean-Instanz erstellt, erkennt und ruft es den Konstruktor automatisch auf und fügt die erforderlichen Abhängigkeiten ein.

Beispielcode

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 diesem Beispiel ist es nicht erforderlich, zusätzliche Anmerkungen zum Kommentieren des Konstruktors zu verwenden. Spring erkennt die Abhängigkeit automatisch und fügt sie ein. (Wenn markiert, wird natürlich kein Fehler gemeldet, aber nur @Autowired kann verwendet werden, @Resouce kann nicht verwendet werden.@Resource Anmerkungen werden normalerweise für die Injektion von Feld- oder Setter-Methoden verwendet.

zusätzliche Umstände

1. Mehrere Konstrukteure:
   • Wenn eine Klasse mehrere Konstruktoren enthält und nur einer von ihnen über Injektionsparameter verfügt, verwendet Spring diesen Konstruktor für die Injektion.
   • Wenn mehrere Konstruktoren mit injizierten Parametern vorhanden sind, müssen Sie diese verwenden @Autowired Annotation, um explizit anzugeben, welcher Konstruktor verwendet werden soll.

Beispielcode (mehrere Konstruktoren)

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

Da es in diesem Beispiel mehrere Konstruktoren gibt, müssen Sie diese verwenden @Autowired Anmerkungen, um explizit anzugeben, welchen Konstruktor Spring für die Abhängigkeitsinjektion verwendet.