Principes de base de la validation Java Bean

1. Vue d'ensemble

Dans ce rapide tutoriel, nous couvrons les bases de la validation d'un bean Java avec le framework standard - JSR 380, également connu sous le nom de Bean Validation 2.0 .

La validation des entrées utilisateur est une exigence très courante dans la plupart des applications. Et le framework Java Bean Validation est devenu le standard de facto pour gérer ce type de logique.

2. JSR 380

JSR 380 est une spécification de l'API Java pour la validation de bean, qui fait partie de Jakarta EE et JavaSE. Cela garantit que les propriétés d'un bean répondent à des critères spécifiques, à l'aide d'annotations telles que @NotNull , @Min et @Max .

Cette version nécessite Java 8 ou supérieur et tire parti des nouvelles fonctionnalités ajoutées dans Java 8, telles que les annotations de type et la prise en charge de nouveaux types tels que Optional et LocalDate .

Pour plus d'informations sur les spécifications, allez-y et lisez le JSR 380.

3. Dépendances

Nous allons utiliser un exemple Maven pour montrer les dépendances requises. Mais bien sûr, ces pots peuvent être ajoutés de différentes manières.

3.1. API de validation

Selon la spécification JSR 380, la dépendance validation-api contient les API de validation standard:

 javax.validation validation-api 2.0.1.Final 

3.2. Implémentation de référence de l'API de validation

Hibernate Validator est l'implémentation de référence de l'API de validation.

Pour l'utiliser, nous devons ajouter la dépendance suivante:

 org.hibernate.validator hibernate-validator 6.0.13.Final  

Une note rapide: hibernate-validator est entièrement séparé des aspects de persistance d'Hibernate. Donc, en l'ajoutant en tant que dépendance, nous n'ajoutons pas ces aspects de persistance dans le projet.

3.3. Dépendances du langage d'expression

JSR 380 prend en charge l'interpolation variable, autorisant les expressions à l'intérieur des messages de violation.

Pour analyser ces expressions, nous allons ajouter la dépendance javax.el de GlassFish, qui contient une implémentation de la spécification Expression Language:

 org.glassfish javax.el 3.0.0 

4. Utilisation des annotations de validation

Ici, nous allons prendre un bean User et y ajouter une simple validation:

import javax.validation.constraints.AssertTrue; import javax.validation.constraints.Max; import javax.validation.constraints.Min; import javax.validation.constraints.NotNull; import javax.validation.constraints.Size; import javax.validation.constraints.Email; public class User { @NotNull(message = "Name cannot be null") private String name; @AssertTrue private boolean working; @Size(min = 10, max = 200, message = "About Me must be between 10 and 200 characters") private String aboutMe; @Min(value = 18, message = "Age should not be less than 18") @Max(value = 150, message = "Age should not be greater than 150") private int age; @Email(message = "Email should be valid") private String email; // standard setters and getters } 

Toutes les annotations utilisées dans l'exemple sont des annotations JSR standard:

  • @NotNull valide que la valeur de la propriété annotée n'est pas nulle .
  • @AssertTrue valide que la valeur de la propriété annotée est vraie.
  • @Size valide que la valeur de la propriété annotée a une taille comprise entre les attributs min et max ; peut être appliqué auxpropriétésde chaîne , de collection , de mappage et de tableau.
  • @Min vérifie que la propriété annotée a une valeur non inférieure à l'attribut value .
  • @Max vérifie que la propriété annotée a une valeur non supérieure à l'attribut value .
  • @Email valide que la propriété annotée est une adresse e-mail valide.

Certaines annotations acceptent des attributs supplémentaires, mais l' attribut message est commun à tous. C'est le message qui sera généralement rendu lorsque la valeur de la propriété respective échoue à la validation.

Et quelques annotations supplémentaires qui peuvent être trouvées dans le JSR:

  • @NotEmpty valide que la propriété n'est pas nulle ou vide; peut être appliqué auxvaleurs String , Collection , Map ou Array .
  • @NotBlank ne peut être appliqué qu'aux valeurs de texte et valide que la propriété n'est pas nulle ou d'espaces blancs.
  • @Positive et @PositiveOrZero s'appliquent aux valeurs numériques et valident qu'elles sont strictement positives ou positives avec 0.
  • @Negative et @NegativeOrZero s'appliquent aux valeurs numériques et valident qu'elles sont strictement négatives, ou négatives avec 0.
  • @Past et @PastOrPresent valident qu'une valeur de date est dans le passé ou le passé, y compris le présent; peut être appliqué aux types de date, y compris ceux ajoutés dans Java 8.
  • @Future et @FutureOrPresent valident qu'une valeur de date est dans le futur, ou dans le futur, y compris le présent.

Les annotations de validation peuvent également être appliquées aux éléments d'une collection :

List preferences;

Dans ce cas, toute valeur ajoutée à la liste des préférences sera validée.

En outre, la spécification prend en charge le nouveau type facultatif dans Java 8:

private LocalDate dateOfBirth; public Optional getDateOfBirth() { return Optional.of(dateOfBirth); }

Ici, le cadre de validation déroulera automatiquement la valeur LocalDate et la validera.

5. Validation programmatique

Certains frameworks - tels que Spring - ont des moyens simples de déclencher le processus de validation en utilisant simplement des annotations. C'est principalement pour que nous n'ayons pas à interagir avec l'API de validation programmatique.

Passons maintenant à la voie manuelle et configurons les choses par programme:

ValidatorFactory factory = Validation.buildDefaultValidatorFactory(); Validator validator = factory.getValidator(); 

Pour valider un bean, nous avons d'abord besoin d'un objet Validator , qui est construit à l'aide d'un ValidatorFactory .

5.1. Définition du haricot

Nous allons maintenant configurer cet utilisateur invalide - avec une valeur de nom nulle :

User user = new User(); user.setWorking(true); user.setAboutMe("Its all about me!"); user.setAge(50); 

5.2. Valider le Bean

Maintenant que nous avons un validateur , nous pouvons valider notre bean en le passant à la méthode validate .

Toute violation des contraintes définies dans l' objet User sera renvoyée sous forme de Set :

Set
    
      violations = validator.validate(user); 
    

En itérant sur les violations, nous pouvons obtenir tous les messages de violation à l'aide de la méthode getMessage :

for (ConstraintViolation violation : violations) { log.error(violation.getMessage()); } 

Dans notre exemple ( ifNameIsNull_nameValidationFails ), l'ensemble contiendrait une seule ConstraintViolation avec le message «Le nom ne peut pas être nul».

6. Conclusion

Cet article s'est concentré sur un passage simple via l'API Java Validation standard. Nous avons montré les bases de la validation de bean à l'aide d' annotations et d'API javax.validation .

Comme d'habitude, une implémentation des concepts de cet article et tous les extraits de code peuvent être trouvés sur GitHub.