Leitfaden zur Eingabevalidierung mit Spring Boot

{"id":1,"name":"John Doe Updated","email":"john.doe.updated@example.com","password":"newP@ssW0rd!"}

Wenn Sie als Entwickler mit Java arbeiten, kennen Sie wahrscheinlich Spring Boot – ein leistungsstarkes Framework, das die Entwicklung eigenständiger, produktionsreifer Anwendungen auf Spring-Basis vereinfacht. Zu den zahlreichen Funktionen gehört Bean Validation, ein wichtiger Bestandteil jeder Anwendung, um die Datenintegrität sicherzustellen und die Benutzererfahrung zu verbessern.

Bean Validation lässt sich in Spring-Boot-Anwendungen zur Validierung von Eingaben und Formularen, zur Datenvalidierung vor dem Speichern in einer Datenbank sowie zur Durchsetzung verschiedener Sicherheitsrichtlinien einsetzen. Mit Bean Validation können Entwickler Fehler vermeiden, die Gesamtqualität der Anwendung verbessern und sicherstellen, dass die Daten in der gesamten Anwendung konsistent sind.

In diesem Artikel erfahren Sie mehr über die verschiedenen Einsatzmöglichkeiten von Bean Validation und wie Sie die Funktion in Spring Boot implementieren, um sie effektiv in Ihren eigenen Projekten einzusetzen.

Was ist Bean Validation?

Mit Bean Validation können Sie Einschränkungen für die Datenmodelle Ihrer Anwendung festlegen. So stellen Sie sicher, dass die Daten bestimmte Regeln erfüllen, bevor sie verarbeitet oder gespeichert werden. Dies wird durch die Integration der Jakarta Bean Validation ermöglicht, die eine Reihe von Annotationen und Schnittstellen zum Definieren und Überprüfen von Einschränkungen bereitstellt.

Durch den Einsatz von Bean Validation können Entwickler Zeit und Ressourcen sparen, indem sie Fehler und Inkonsistenzen früh im Entwicklungsprozess erkennen. Außerdem trägt Bean Validation zu einer besseren Benutzererfahrung bei, da weniger fehlerhafte Daten eingegeben werden.

Sehen wir uns einige gängige Anwendungsfälle für Bean Validation bei der Anwendungsentwicklung an:

Eingabe- und Formularvalidierung

Zu den häufigsten Anwendungsfällen von Bean Validation gehört die Validierung von Eingaben und Formularen. Damit lässt sich sicherstellen, dass Benutzer Daten im richtigen Format eingeben (z. B. bei der Validierung eines Registrierungsformulars mit E-Mail-Adressen, Benutzernamen und Passwörtern).

Datenvalidierung vor dem Speichern in einer Datenbank

Eine weitere Anwendung von Bean Validation ist die Validierung von Daten vor dem Speichern in einer Datenbank. So lässt sich sicherstellen, dass die eingegebenen Daten konsistent und korrekt sind. Das beugt Fehlern vor und verringert das Risiko einer Datenbeschädigung.

Durchsetzung von Sicherheitsrichtlinien

Bean Validation kann auch zur Durchsetzung von Sicherheitsrichtlinien eingesetzt werden. Dazu werden Benutzereingaben oder aus der Datenbank geladene Daten überprüft, um sicherzustellen, dass sie bestimmte Kriterien erfüllen, etwa Anforderungen an die Passwortstärke. Validierung spielt eine wichtige Rolle bei der Abwehr von Injection-Angriffen und hilft, Sicherheitslücken wie gespeichertes Cross-Site-Scripting (XSS) zu verhindern.

Validierung der Geschäftslogik

Bean Validation lässt sich zur Überprüfung der Geschäftslogik einsetzen und stellt sicher, dass bestimmte Anforderungen oder Standards erfüllt werden. Durch definierte Validierungsregeln, etwa zur Passwortkomplexität oder zu zulässigen Mengen und Preisen von Bestellpositionen, kann Bean Validation Daten automatisch prüfen und die erforderlichen Regeln durchsetzen. Dadurch entfällt die manuelle Prüfung, und die Anwendung erfüllt die festgelegten Standards und Anforderungen.

Bean Validation in Spring Boot implementieren

In diesem Tutorial implementieren Sie Bean Validation für eine einfache CRUD-Anwendung (Create, Read, Update, Delete) mit einer In-Memory-Datenbank. Benutzer geben ihren Namen, ihre E-Mail-Adresse und ihr Passwort an. Diese Angaben müssen bestimmte Kriterien erfüllen, um akzeptiert zu werden. Die hier verwendete High-Level-Architektur besteht aus einem Backend-Server mit RESTful-APIs und einer H2-In-Memory-Datenbank.

Wenn eine Clientanwendung den Webservice aufruft (also die Anwendung aus diesem Tutorial), wird die Anfrage an den UserController. gesendet. Anschließend validiert der Controller die Anfragedaten. Sind die Daten gültig, wird die Anfrage an das UserRepository weitergeleitet, das mit der In-Memory-Datenbank kommuniziert und die entsprechende Antwort zurückgibt. Andernfalls sind die Daten ungültig, und die Anfrage wird mit einer Fehlermeldung an den Client zurückgesendet:

Voraussetzungen

Bevor Sie mit der Implementierung beginnen, stellen Sie sicher, dass die folgenden Tools und Technologien installiert sind:

• Java Development Kit (JDK) in Version 17 oder höher.

• Eine IDE wie IntelliJ IDEA oder Eclipse. In diesem Tutorial wird IntelliJ IDEA Community Edition verwendet.

• Maven in Version 3.8.6 oder höher.

Ein neues Spring-Boot-Projekt erstellen

Um ein neues Spring-Boot-Projekt zu erstellen, rufen Sie den Spring Initializr auf und wählen Sie die folgenden Optionen aus:

• Projekttyp: Maven Project

• Sprache: Java

• Paketierung: Jar

• Java-Version: 17

• Spring Boot: 3.1.0 (SNAPSHOT)
  

Geben Sie im Abschnitt Project Metadata die folgenden Angaben ein:

• Gruppe: com.example

• Artefakt: simple-crud-bean-validation

• Name: simple-crud-bean-validation

• Beschreibung: Eine einfache CRUD-Anwendung mit Spring Boot

• Paketname: com.example.simplecrud

Fügen Sie außerdem die folgenden Abhängigkeiten hinzu:

• Web: Spring Web

• Validierung: Bean Validation

• H2 Database: H2 Database

• Spring Data JPA: Spring Data and Hibernate

Klicken Sie auf Generate, um das Projekt als ZIP-Datei herunterzuladen. Entpacken Sie die ZIP-Datei anschließend und importieren Sie das Projekt in Ihre bevorzugte IDE.

Die Anwendung implementieren

Wir verwenden die Standardprojektstruktur für Spring-Boot-Anwendungen. Hier sehen Sie die vollständige Projektstruktur:

User-Modell

Erstellen Sie zunächst zum Implementieren der Anwendung das Verzeichnis model unter src/main/java/com/example/simplecrudbeanvalidation. Erstellen Sie dann im Verzeichnis model eine Datei namens User.java und fügen Sie der User-Klasse die folgenden Felder und Bean-Validation-Annotationen hinzu:

1import jakarta.persistence.*;
2import jakarta.validation.constraints.*;
3
4@Entity
5@Table(name="users")
6public class User {
7
8    @Id
9    @GeneratedValue(strategy = GenerationType.IDENTITY)
10    private Long id;
11
12    @NotNull
13    @NotEmpty
14    @Pattern(regexp = "[a-zA-Z0-9 ]")
15    private String name;
16
17    @NotNull
18    @NotEmpty
19    @Email
20    @Pattern(regexp=".+@.+\\..+")
21    private String email;
22
23    @NotNull
24    @NotEmpty
25    @Size(min = 8, max = 64)
26    private String password;
27
28    public Long getId() {
29        return id;
30    }
31
32    public void setId(Long id) {
33        this.id = id;
34    }
35
36    public String getName() {
37        return name;
38    }
39
40    public void setName(String name) {
41        this.name = name;
42    }
43
44    public String getEmail() {
45        return email;
46    }
47
48    public void setEmail(String email) {
49        this.email = email;
50    }
51
52    public String getPassword() {
53        return password;
54    }
55
56    public void setPassword(String password) {
57        this.password = password;
58    }
59
60    public User(Long id, String name, String email, String password){
61        this.id = id;
62        this.name = name;
63        this.email = email;
64        this.password = password;
65    }
66
67    //default constructor
68    public User(){}
69}

Dieser Code definiert eine Java-Klasse namens User, die mithilfe von Annotationen der Jakarta Persistence API (JPA) eine Datenbanktabelle namens users abbildet. Die Klasse enthält vier Instanzvariablen – id, name, email und password – mit den entsprechenden Gettern und Settern. Für jedes dieser Felder gelten bestimmte Validierungsregeln, etwa @NotNull, @NotEmpty, @Email, @Size und @Pattern. Mit @Pattern wird festgelegt, dass das Passwort acht bis 64 Zeichen lang sein und mindestens eine Ziffer, einen Kleinbuchstaben, einen Großbuchstaben und ein Sonderzeichen enthalten muss. Außerdem wird @Pattern für die Eigenschaft name verwendet, um Script-Injection zu verhindern. Die Klasse dient als Modell zum Speichern und Abrufen von Benutzerdaten in einer Datenbank.

User-Repository

Erstellen Sie für CRUD-Vorgänge mit einer In-Memory-Datenbank das Verzeichnis repository unter src/main/java/com/example/simplecrudbeanvalidation. Erstellen Sie dann im Verzeichnis directory eine Datei namens UserRepository.java, in der Sie die Schnittstelle UserRepository wie folgt definieren:

1import com.example.simplecrudbeanvalidation.model.User;
2import org.springframework.data.repository.CrudRepository;
3import org.springframework.stereotype.Repository;
4
5@Repository
6public interface UserRepository extends CrudRepository<User, Long> {
7}

Dieser Code definiert eine Java-Schnittstelle namens UserRepository, die die von Spring Data JPA bereitgestellte Schnittstelle CrudRepository erweitert. Die Schnittstelle UserRepository legt zwei generische Parameter für CrudRepository fest: User als Entitätstyp, den dieses Repository verwaltet, und Long als Typ des Primärschlüssels der Entität.

Durch die Erweiterung von CrudRepository erbt UserRepository mehrere Methoden für CRUD-Vorgänge mit der Entität User. Mit diesen Methoden können Sie mit einer In-Memory-Datenbank interagieren und User-Objekte verwalten, ohne eine komplexe Konfiguration oder einen vollwertigen Datenbankserver zu benötigen.

User-Controller

Erstellen Sie zunächst im Verzeichnis src/main/java/com/example/simplecrudbeanvalidation ein Verzeichnis namens controller, um die Klasse UserController mit den RESTful-API-Endpunkten und der Validierungslogik anzulegen. Erstellen Sie im Verzeichnis controller eine Datei namens UserController.java mit folgendem Inhalt:

1import com.example.simplecrudbeanvalidation.model.User;
2import com.example.simplecrudbeanvalidation.repository.UserRepository;
3import jakarta.validation.Valid;
4import org.springframework.beans.factory.annotation.Autowired;
5import org.springframework.http.ResponseEntity;
6import org.springframework.validation.annotation.Validated;
7import org.springframework.web.bind.annotation.*;
8import java.util.List;
9import java.util.Optional;
10
11@RestController
12@RequestMapping("/api/users")
13@Validated
14public class UserController
15{
16   @Autowired
17   private UserRepository userRepository;
18
19   @GetMapping
20   public List<User> getAllUsers() {
21       return (List<User>) userRepository.findAll();
22   }
23
24   @GetMapping("/{id}")
25   public ResponseEntity<User> getUserById(@PathVariable Long id) {
26       Optional<User> userOptional = userRepository.findById(id);
27       if (userOptional.isPresent()) {
28           return ResponseEntity.ok(userOptional.get());
29       } else {
30           return ResponseEntity.notFound().build();
31       }
32   }
33
34   @PostMapping
35   public User createUser(@Valid @RequestBody User user) {
36       return userRepository.save(user);
37   }
38
39   @PutMapping("/{id}")
40   public ResponseEntity<User> updateUser(@PathVariable Long id, @Valid @RequestBody User updatedUser) {
41       Optional<User> userOptional = userRepository.findById(id);
42       if (userOptional.isPresent()) {
43           User user = userOptional.get();
44           user.setName(updatedUser.getName());
45           user.setEmail(updatedUser.getEmail());
46           user.setPassword(updatedUser.getPassword());
47           userRepository.save(user);
48           return ResponseEntity.ok(user);
49       } else {
50           return ResponseEntity.notFound().build();
51       }
52   }
53
54   @DeleteMapping("/{id}")
55   public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
56       if (userRepository.existsById(id)) {
57           userRepository.deleteById(id);
58           return ResponseEntity.ok().build();
59       } else {
60           return ResponseEntity.notFound().build();
61       }
62   }
63}

Dieser Code definiert eine Spring-Boot-RestController-Klasse namens UserController, die HTTP-Anfragen zur Verwaltung von User-Objekten verarbeitet. Die Klasse enthält fünf Methoden für verschiedene HTTP-Anfragen: alle Benutzer abrufen, einen einzelnen Benutzer anhand seiner ID abrufen, einen neuen Benutzer erstellen, einen vorhandenen Benutzer aktualisieren und einen Benutzer löschen.

Mit der Annotation @Autowired wird die Abhängigkeit UserRepository in die Klasse UserController eingefügt. Die Klasse UserController ist über die Annotation @RequestMapping dem Endpunkt /api/users zugeordnet. Damit werden eingehende HTTP-Anfragen an diesen Controller weitergeleitet. Außerdem aktiviert die Annotation @Validated die Validierung von Anfrageparametern. Insgesamt stellt dieser Code eine RESTful-API für CRUD-Vorgänge mit User-Objekten bereit, die Spring Data und eine In-Memory-Datenbank verwendet.

In-Memory-Datenbank konfigurieren

Öffnen Sie zum Konfigurieren der In-Memory-Datenbank die Datei application.properties unter src/main/resources/ und fügen Sie die folgenden Konfigurationen hinzu:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

Diese Spring-Boot-Konfiguration richtet eine H2-In-Memory-Datenbank namens testdb ein und konfiguriert deren Treiber, Benutzernamen und Passwort. Außerdem wird der H2-Dialekt für Hibernate-basierte Datenbankvorgänge festgelegt.

Unit-Tests für Bean Validation

Sobald Sie die In-Memory-Datenbank konfiguriert haben, können Sie mit Unit-Tests für Bean Validation beginnen. Erstellen Sie dazu das Verzeichnis controller unter src/test/java/com/example/simplecrudbeanvalidation. Erstellen Sie dann im Verzeichnis controller eine Datei namens UserControllerTest.java und schreiben Sie Tests, um zu überprüfen, ob die Bean-Validation-Regeln wie erwartet funktionieren.

Fügen Sie der Klasse UserControllerTest den folgenden Code hinzu:

1import com.example.simplecrudbeanvalidation.model.User;
2import com.example.simplecrudbeanvalidation.repository.UserRepository;
3import com.fasterxml.jackson.databind.ObjectMapper;
4import org.junit.jupiter.api.Test;
5import org.springframework.beans.factory.annotation.Autowired;
6import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
7import org.springframework.boot.test.context.SpringBootTest;
8import org.springframework.boot.test.mock.mockito.MockBean;
9import org.springframework.http.MediaType;
10import org.springframework.test.web.servlet.MockMvc;
11import java.util.Arrays;
12import java.util.Optional;
13import static org.hamcrest.Matchers.hasSize;
14import static org.mockito.Mockito.*;
15import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
16import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
17
18@SpringBootTest
19@AutoConfigureMockMvc
20public class UserControllerTest {
21
22    @Autowired
23    private MockMvc mockMvc;
24
25    @MockBean
26    private UserRepository userRepository;
27
28    @Autowired
29    private ObjectMapper objectMapper;
30
31    @Test
32    public void createUser_validData_success() throws Exception {
33        User newUser = new User(null, "John Doe", "john.doe@example.com", "p@ssW0rd!");
34        User savedUser = new User(1L, newUser.getName(), newUser.getEmail(), newUser.getPassword());
35
36        when(userRepository.save(any(User.class))).thenReturn(savedUser);
37
38        mockMvc.perform(post("/api/users")
39                        .contentType(MediaType.APPLICATION_JSON)
40                        .content(objectMapper.writeValueAsString(newUser)))
41                .andExpect(status().isOk())
42                .andExpect(jsonPath("$.id").value(savedUser.getId()))
43                .andExpect(jsonPath("$.name").value(savedUser.getName()))
44                .andExpect(jsonPath("$.email").value(savedUser.getEmail()))
45                .andExpect(jsonPath("$.password").value(savedUser.getPassword()));
46    }
47
48    @Test
49    public void createUser_invalidData_failure() throws Exception {
50        User invalidUser = new User(null, "", "invalid-email", "123");
51
52        mockMvc.perform(post("/api/users")
53                        .contentType(MediaType.APPLICATION_JSON)
54                        .content(objectMapper.writeValueAsString(invalidUser)))
55                .andExpect(status().isBadRequest());
56    }
57
58    @Test
59    public void getAllUsers() throws Exception {
60        User user1 = new User(1L, "John Doe", "john.doe@example.com", "p@ssW0rd!");
61        User user2 = new User(2L, "Jane Doe", "jane.doe@example.com", "p@ssW0rd!");
62        when(userRepository.findAll()).thenReturn(Arrays.asList(user1, user2));
63        mockMvc.perform(get("/api/users"))
64                .andExpect(status().isOk())
65                .andExpect(jsonPath("$", hasSize(2)))
66                .andExpect(jsonPath("$[0].id").value(user1.getId()))
67                .andExpect(jsonPath("$[0].name").value(user1.getName()))
68                .andExpect(jsonPath("$[0].email").value(user1.getEmail()))
69                .andExpect(jsonPath("$[0].password").value(user1.getPassword()))
70                .andExpect(jsonPath("$[1].id").value(user2.getId()))
71                .andExpect(jsonPath("$[1].name").value(user2.getName()))
72                .andExpect(jsonPath("$[1].email").value(user2.getEmail()))
73                .andExpect(jsonPath("$[1].password").value(user2.getPassword()));
74    }
75
76    @Test
77    public void getUserById_found() throws Exception {
78        User user = new User(1L, "John Doe", "john.doe@example.com", "p@ssW0rd!");
79        when(userRepository.findById(user.getId())).thenReturn(Optional.of(user));
80        mockMvc.perform(get("/api/users/{id}", user.getId()))
81                .andExpect(status().isOk())
82                .andExpect(jsonPath("$.id").value(user.getId()))
83                .andExpect(jsonPath("$.name").value(user.getName()))
84                .andExpect(jsonPath("$.email").value(user.getEmail()))
85                .andExpect(jsonPath("$.password").value(user.getPassword()));
86    }
87
88    @Test
89    public void getUserById_notFound() throws Exception {
90        Long userId = 1L;
91        when(userRepository.findById(userId)).thenReturn(Optional.empty());
92        mockMvc.perform(get("/api/users/{id}", userId))
93                .andExpect(status().isNotFound());
94    }
95}

Dieser Code enthält eine Reihe von JUnit-Tests für die Klasse UserController. Die Tests verwenden die Klasse MockMvc, um HTTP-Anfragen an den Endpunkt /api/users zu simulieren und zu überprüfen, ob die entsprechenden Methoden in der Klasse UserController diese korrekt verarbeiten. Die Tests decken unter anderem folgende Szenarien ab: Erstellen eines neuen Benutzers mit gültigen und ungültigen Daten, Abrufen aller Benutzer sowie Abrufen eines Benutzers anhand seiner ID, sowohl wenn der Benutzer vorhanden ist als auch wenn nicht.

Mit der Annotation @SpringBootTest wird der Anwendungskontext geladen. Die Annotation @MockBean dient dazu, die Abhängigkeit UserRepository der Klasse UserController zu simulieren. Insgesamt stellen diese Tests sicher, dass die Klasse UserController korrekt funktioniert und angemessen auf verschiedene HTTP-Anfragen reagiert.

Öffnen Sie zum Ausführen der Tests ein Terminal oder eine Shell, wechseln Sie in das Stammverzeichnis Ihres Projekts und führen Sie den folgenden Befehl aus:

mvn test

Sie sollten sehen, dass alle Tests erfolgreich durchlaufen wurden:

…output omitted…
[INFO] Results:
[INFO] 
[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0
[INFO] 
[INFO] ------------------------------------------------------------------------
…output omitted…

APIs ausführen und testen

Klicken Sie in IntelliJ mit der rechten Maustaste auf die Datei SimpleCrudBeanValidationApplication.java und wählen Sie Run 'SimpleCrudBeanValidationApplication.main()' aus:

Alternativ können Sie Ihre Anwendung im Terminal oder in der Shell mit den folgenden Befehlen ausführen:

mvn clean install
java -jar target/simple-crud-bean-validation-0.0.1-SNAPSHOT.jar

Nach dem Start der Spring-Boot-Anwendung können Sie die CRUD-Vorgänge mit curl-Befehlen im Terminal oder in der Shell testen. Das entspricht dem Aufruf dieser APIs durch eine Frontend-Anwendung oder Postman.

Beginnen Sie zum Testen der CRUD-Vorgänge damit, einen Benutzer anzulegen:

curl -X POST -H "Content-Type: application/json" -d '{"name":"John Doe","email":"john.doe@example.com","password":"p@ssW0rd!"}' http://localhost:8080/api/users

Die Ausgabe sieht dann so aus:

{"id":1,"name":"John Doe","email":"john.doe@example.com","password":"p@ssW0rd!"} 

Rufen Sie anschließend alle Benutzer ab:

curl -X GET http://localhost:8080/api/users

Die Ausgabe sieht dann so aus:

{"id":1,"name":"John Doe","email":"john.doe@example.com","password":"p@ssW0rd!"}

Rufen Sie als Nächstes Ihren Benutzer anhand der ID ab. Ersetzen Sie <id> durch die ID des Benutzers, den Sie abrufen möchten:

curl -X GET http://localhost:8080/api/users/<id>

Die Ausgabe sieht dann so aus:

{"id":1,"name":"John Doe","email":"john.doe@example.com","password":"p@ssW0rd!"}

Aktualisieren Sie den Benutzer, indem Sie <id> durch die ID des Benutzers ersetzen, den Sie aktualisieren möchten:

curl -X PUT -H "Content-Type: application/json" -d '{"name":"John Doe Updated","email":"john.doe.updated@example.com","password":"newP@ssW0rd!"}' http://localhost:8080/api/users/<id>

Die Ausgabe sieht dann so aus:

{"id":1,"name":"John Doe Updated","email":"john.doe.updated@example.com","password":"newP@ssW0rd!"}

Löschen Sie anschließend einen Benutzer, indem Sie <id> durch die ID des Benutzers ersetzen, den Sie löschen möchten:

curl -X DELETE http://localhost:8080/api/users/<id>

Dieser Befehl gibt keine Ausgabe zurück.

Mit diesen curl-Befehlen können Sie die CRUD-Operationen Ihrer User-RESTful-API testen. Denken Sie daran, <id> in jedem Befehl durch die entsprechende User-ID zu ersetzen. Wenn Sie diese Schritte ausführen, können Sie mit Ihrer Spring-Boot-Anwendung interagieren und überprüfen, ob die Bean-Validation-Bedingungen zur Laufzeit wie erwartet funktionieren.

Wenn Sie diese curl-Anfragen erneut mit ungültigen Einträgen ausführen, etwa mit einer ungültigen E-Mail-Adresse, einem ungültigen Passwort oder leeren Werten, gibt die API einen Fehler wegen einer fehlerhaften Anfrage zurück. Diese Fehlermeldung zeigt an, dass die Validierung auf Controller-Ebene, auch als Bean Validation bekannt, nicht erfolgreich war.

Sehen wir uns einige Beispiele für fehlerhafte Anfragen an. Hier erstellen Sie einen Benutzer mit einer ungültigen E-Mail-Adresse:

curl -X POST -H "Content-Type: application/json" -d '{"name":"John Doe","email":"johexample","password":"p@ssW0rd!"}' http://localhost:8080/api/users

Die Ausgabe sieht folgendermaßen aus:

{"timestamp":"2023-03-28T10:27:21.884+00:00","status":400,"error":"Bad Request","path":"/api/users"}

Und hier erstellen Sie einen Benutzer mit einem ungültigen Passwort:

curl -X POST -H "Content-Type: application/json" -d '{"name":"John Doe","email":"joh@example.com","password":"test"}' http://localhost:8080/api/users

Die Ausgabe sieht folgendermaßen aus:

{"timestamp":"2023-03-28T10:29:30.793+00:00","status":400,"error":"Bad Request","path":"/api/users"}

Fazit zur Validierung

In diesem Artikel haben Sie erfahren, wie Sie Bean Validation in Spring Boot in einer einfachen CRUD-Anwendung implementieren. Sie haben mit Spring Initializr ein Projekt erstellt, die erforderlichen Abhängigkeiten hinzugefügt und ein User-Modell mit Bean-Validation-Annotationen implementiert. Außerdem haben Sie ein UserRepository und einen UserController mit RESTful-API-Endpunkten implementiert, die Bean Validation nutzen, und Tests geschrieben, um zu überprüfen, ob die Bean-Validation-Bedingungen wie erwartet funktionieren.

Um die Sicherheit Ihrer Anwendung weiter zu verbessern, verwenden Sie Snyk Code, ein SAST-Tool, das unsichere Code-Muster erkennt, die zu Injection-Angriffen führen können. Mit der Erweiterung Snyk Security plugin for IntelliJ IDE können Sie diese Analyse in Ihren Entwicklungs-Workflow integrieren.

Nachdem Sie nun wissen, wie Bean Validation in Spring Boot funktioniert, können Sie sie in Ihren eigenen Projekten implementieren, die Datenintegrität sicherstellen und die Benutzererfahrung verbessern. Den fertigen Code finden Sie im folgenden GitHub-Repository.