Guide de validation des entrées avec Spring Boot

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

Si vous développez en Java, vous connaissez probablement Spring Boot, le framework robuste qui simplifie le développement d’applications autonomes basées sur Spring et adaptées à la production. Parmi ses nombreuses fonctionnalités figure Bean Validation, un élément essentiel de toute application pour garantir l’intégrité des données et améliorer l’expérience utilisateur.

Dans les applications Spring Boot, Bean Validation peut servir à valider les entrées et les formulaires, à vérifier les données avant leur enregistrement dans une base de données et à appliquer différentes politiques de sécurité. Grâce à Bean Validation, les développeurs peuvent prévenir les erreurs, améliorer la qualité globale de l’application et garantir la cohérence des données dans toute l’application.

Dans cet article, vous découvrirez les différentes utilisations de Bean Validation et comment l’implémenter dans Spring Boot, afin de pouvoir l’exploiter efficacement dans vos propres projets.

Qu’est-ce que Bean Validation ?

Bean Validation permet d’appliquer des contraintes aux modèles de données de votre application afin de vérifier que les données respectent certaines règles avant leur traitement ou leur stockage. Cela repose sur l’intégration de Jakarta Bean Validation, qui fournit un ensemble d’annotations et d’interfaces pour définir et vérifier les contraintes.

En appliquant Bean Validation, les développeurs peuvent gagner du temps et économiser des ressources en détectant les erreurs et les incohérences dès les premières étapes du développement. De plus, Bean Validation contribue à améliorer l’expérience utilisateur globale en réduisant la quantité de données incorrectes saisies.

Examinons quelques cas d’utilisation courants de Bean Validation dans le développement d’applications :

Validation des entrées et des formulaires

La validation des entrées et des formulaires est l’un des cas d’utilisation les plus courants de Bean Validation. Elle permet de vérifier que les utilisateurs saisissent des données au bon format (par exemple, validation d’un formulaire d’inscription contenant une adresse e-mail, un nom d’utilisateur et un mot de passe).

Validation des données avant leur enregistrement dans une base de données

Bean Validation permet également de valider les données avant leur enregistrement dans une base de données. Cette méthode garantit la cohérence et l’exactitude des données saisies. Elle contribue ainsi à prévenir les erreurs et à réduire le risque d’altération des données.

Application des politiques de sécurité

Bean Validation peut également servir à appliquer des politiques de sécurité en validant les entrées utilisateur ou les données extraites de la base de données, afin de vérifier qu’elles répondent à des critères précis, comme les exigences de robustesse des mots de passe. La validation joue un rôle essentiel dans la prévention des attaques par injection et contribue à empêcher des vulnérabilités telles que le cross-site scripting (XSS) stocké.

Validation de la logique métier

Bean Validation peut servir à vérifier la logique métier et à s’assurer qu’elle répond à des exigences ou à des normes précises. En définissant des contraintes de validation, comme la complexité des mots de passe ou la validité des quantités et des prix des articles commandés, Bean Validation peut vérifier automatiquement les données et appliquer les règles requises. Cela évite les vérifications manuelles et garantit que l’application respecte les normes ou exigences définies.

Implémenter Bean Validation dans Spring Boot

Dans ce tutoriel, vous allez implémenter Bean Validation dans une application simple de création, lecture, mise à jour et suppression (CRUD) utilisant une base de données en mémoire. Les utilisateurs fournissent leur nom, leur adresse e-mail et leur mot de passe, qui doivent répondre à certains critères pour être acceptés. L’architecture générale présentée ici comprend un serveur backend avec des API REST et une base de données H2 en mémoire.

Lorsqu’une application cliente appelle le service web (l’application créée dans ce tutoriel), la requête est envoyée à UserController. Le contrôleur valide ensuite les données de la requête. Si elles sont valides, la requête est transmise à UserRepository, qui communique avec la base de données en mémoire et renvoie la réponse correspondante. Sinon, les données ne sont pas valides et un message d’erreur est renvoyé au client :

Prérequis

Avant de commencer l’implémentation, vérifiez que les outils et technologies suivants sont installés :

• Java Development Kit (JDK) version 17 ou ultérieure.

• Un IDE, tel que IntelliJ IDEA ou Eclipse. Ce tutoriel utilise IntelliJ IDEA Community Edition.

• Maven version 3.8.6 ou ultérieure.

Créer un projet Spring Boot

Pour créer un projet Spring Boot, rendez-vous sur Spring Initializr et sélectionnez les options suivantes :

• Type de projet : Maven Project

• Langage : Java

• Packaging : Jar

• Version de Java : 17

• Spring Boot : 3.1.0 (SNAPSHOT)
  

Saisissez les informations suivantes dans la section Project Metadata :

• Group : com.example

• Artifact : simple-crud-bean-validation

• Name : simple-crud-bean-validation

• Description : Une application CRUD simple avec Spring Boot

• Package name : com.example.simplecrud

Ajoutez également les dépendances suivantes :

• Web : Spring Web

• Validation : Bean Validation

• H2 Database : H2 Database

• Spring Data JPA : Spring Data and Hibernate

Cliquez sur Generate pour télécharger le projet au format ZIP. Extrayez ensuite le fichier ZIP et importez le projet dans l’IDE de votre choix.

Implémenter l’application

Nous allons suivre la structure de projet standard des applications Spring Boot. Voici la structure complète du projet :

Modèle User

Pour implémenter l’application, commencez par créer le répertoire model dans src/main/java/com/example/simplecrudbeanvalidation. Dans le répertoire model, créez ensuite un fichier nommé User.java, puis ajoutez les champs et annotations Bean Validation suivants à la classe User :

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}

Ce code définit une classe Java nommée User qui représente une table de base de données appelée users, à l’aide des annotations Jakarta Persistence API (JPA). Elle comporte quatre variables d’instance — id, name, email et password — dotées de leurs getters et setters. Chacun de ces champs est soumis à certaines contraintes de validation, telles que @NotNull, @NotEmpty, @Email, @Size et @Pattern. @Pattern indique que le mot de passe doit compter entre huit et soixante-quatre caractères et contenir au moins un chiffre, une lettre minuscule, une lettre majuscule et un caractère spécial. De plus, @Pattern est également appliqué à la propriété name pour prévenir les injections de scripts. Cette classe peut servir de modèle pour stocker et récupérer des données utilisateur dans une base de données.

Dépôt User

Pour gérer les opérations CRUD avec une base de données en mémoire, créez le répertoire repository dans src/main/java/com/example/simplecrudbeanvalidation. Dans le répertoire directory, créez ensuite un fichier nommé UserRepository.java afin de définir l’interface UserRepository, comme suit :

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}

Ce code définit une interface Java appelée UserRepository qui étend l’interface CrudRepository fournie par Spring Data JPA. L’interface UserRepository spécifie deux paramètres génériques pour CrudRepository : User, le type d’entité géré par ce dépôt, et Long, le type de clé primaire de l’entité.

En étendant CrudRepository, UserRepository hérite de plusieurs méthodes permettant d’effectuer des opérations CRUD sur l’entité User. Ces méthodes permettent d’interagir avec une base de données en mémoire pour gérer des objets User, sans configuration complexe ni serveur de base de données complet.

Contrôleur User

Pour créer la classe UserController, qui définit les points de terminaison de l’API REST et la logique de validation, commencez par créer un répertoire nommé controller dans le répertoire src/main/java/com/example/simplecrudbeanvalidation. Dans le répertoire controller, créez un fichier nommé UserController.java et ajoutez le contenu suivant :

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}

Ce code définit une classe Spring Boot RestController appelée UserController, qui gère les requêtes HTTP relatives aux objets User. La classe comporte cinq méthodes qui traitent différents types de requêtes HTTP : récupérer tous les utilisateurs, récupérer un utilisateur par son ID, créer un utilisateur, mettre à jour un utilisateur existant et supprimer un utilisateur.

L’annotation @Autowired sert à injecter la dépendance UserRepository dans la classe UserController. La classe UserController est associée au point de terminaison /api/users grâce à l’annotation @RequestMapping, qui associe les requêtes HTTP entrantes à ce contrôleur. En outre, l’annotation @Validated active la validation des paramètres de requête. Dans l’ensemble, ce code fournit une API REST pour effectuer des opérations CRUD sur des objets User avec Spring Data et une base de données en mémoire.

Configurer la base de données en mémoire

Pour configurer la base de données en mémoire, ouvrez le fichier application.properties dans src/main/resources/ et ajoutez les paramètres suivants :

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

Cette configuration Spring Boot configure une base de données H2 en mémoire nommée testdb et définit son pilote, son nom d’utilisateur et son mot de passe. Elle indique également le dialecte H2 à utiliser pour les opérations de base de données avec Hibernate.

Tests unitaires de Bean Validation

Une fois la base de données en mémoire configurée, vous pouvez commencer les tests unitaires de Bean Validation. Pour cela, créez le répertoire controller dans src/test/java/com/example/simplecrudbeanvalidation. Dans le répertoire controller, créez ensuite un fichier nommé UserControllerTest.java et rédigez des tests pour vérifier que les contraintes Bean Validation fonctionnent comme prévu.

Dans la classe UserControllerTest, ajoutez le code suivant :

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}

Ce code regroupe des tests JUnit pour la classe UserController. Ils utilisent la classe MockMvc pour simuler des requêtes HTTP vers le point de terminaison /api/users et vérifier que les méthodes correspondantes de la classe UserController les traitent correctement. Les tests couvrent notamment la création d’un utilisateur avec des données valides ou non, la récupération de tous les utilisateurs et la récupération d’un utilisateur par ID, qu’il existe ou non.

L’annotation @SpringBootTest sert à charger le contexte de l’application, tandis que l’annotation @MockBean permet de simuler la dépendance UserRepository de la classe UserController. Dans l’ensemble, ces tests vérifient que la classe UserController fonctionne correctement et répond comme prévu aux différentes requêtes HTTP.

Pour exécuter les tests, ouvrez un terminal ou un shell, accédez au répertoire racine de votre projet et lancez la commande suivante :

mvn test

Vous devriez constater que tous les tests ont réussi :

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

Exécuter et tester vos API

Dans IntelliJ, faites un clic droit sur le fichier SimpleCrudBeanValidationApplication.java, puis sélectionnez Run 'SimpleCrudBeanValidationApplication.main()' :

Vous pouvez également exécuter votre application dans le terminal ou le shell à l’aide des commandes suivantes :

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

Après le démarrage de l’application Spring Boot, vous pouvez tester les opérations CRUD à l’aide de commandes curl dans le terminal ou le shell, comme le ferait une application frontend ou Postman pour appeler ces API.

Pour tester les opérations CRUD, commencez par créer un utilisateur :

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

Le résultat devrait ressembler à ceci :

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

Récupérez ensuite tous vos utilisateurs :

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

Le résultat devrait ressembler à ceci :

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

Récupérez ensuite un utilisateur par son ID. Remplacez <id> par l’ID de l’utilisateur que vous souhaitez récupérer :

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

Voici le résultat :

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

Mettez à jour l’utilisateur en remplaçant <id> par l’ID de l’utilisateur à modifier :

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>

Le résultat devrait ressembler à ceci :

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

Supprimez ensuite un utilisateur en remplaçant <id> par l’ID de l’utilisateur à supprimer :

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

Cette commande ne renvoie aucun résultat.

À l’aide de ces commandes curl, vous pouvez tester les opérations CRUD de votre API RESTful User. Pensez à remplacer <id> par l’ID utilisateur approprié dans chaque commande. En suivant ces étapes, vous pouvez interagir avec votre application Spring Boot et vérifier que les contraintes de Bean Validation fonctionnent comme prévu à l’exécution.

Si vous exécutez à nouveau ces requêtes curl avec des données incorrectes, comme une adresse e-mail invalide, un mot de passe incorrect ou des champs vides, l’API renverra une erreur de requête incorrecte. Ce message indique que la validation effectuée au niveau du contrôleur, également appelée Bean Validation, a échoué.

Voici quelques exemples de requêtes incorrectes. Ici, vous créez un utilisateur avec une adresse e-mail invalide :

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

Voici le résultat obtenu :

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

Ici, vous créez un utilisateur avec un mot de passe invalide :

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

Voici le résultat :

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

Pour conclure sur la validation

Dans cet article, vous avez appris à implémenter Bean Validation de Spring Boot dans une application CRUD simple. Vous avez créé un projet avec Spring Initializr, ajouté les dépendances nécessaires et implémenté un modèle utilisateur avec des annotations Bean Validation. Vous avez également implémenté un UserRepository et un UserController avec des points de terminaison d’API RESTful utilisant Bean Validation, puis écrit des tests pour vérifier que les contraintes Bean Validation fonctionnent comme prévu.

Pour renforcer la sécurité de votre application, utilisez Snyk Code, un outil SAST qui détecte les modèles de code non sécurisés susceptibles de provoquer des attaques par injection. Vous pouvez intégrer cette analyse à votre workflow de développement grâce à l’extension Snyk Security plugin for IntelliJ IDE.

Maintenant que vous comprenez le fonctionnement de Bean Validation dans Spring Boot, vous pouvez l’implémenter dans vos propres projets afin de garantir l’intégrité des données et d’améliorer l’expérience utilisateur. Pour découvrir le code final, consultez le dépôt GitHub suivant.