Principes de base de la validation de beans Java

Notions de base sur la validation de bean Java

1. Vue d'ensemble

Dans cet article rapide, nous allons passer en revuethe basics of validating a Java bean avec le framework standard - JSR 380, également connu sous le nom deBean Validation 2.0.

La validation des entrées utilisateur est bien entendu une exigence super courante dans la plupart des applications, et le cadre de validation Java Bean est devenu le standard de facto pour gérer ce type de logique.

Lectures complémentaires:

Validation dans Spring Boot

Apprenez à valider des objets de domaine dans Spring Boot en utilisant Hibernate Validator, l'implémentation de référence du framework de validation de bean.

Contraintes de méthodes avec validation de bean 2.0

Une introduction aux contraintes de méthodes utilisant Bean Validation 2.0.

2. JSR 380

JSR 380 est une spécification de l'API Java pour la validation de bean, partie de JavaEE et JavaSE, qui 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 à Java 8, telles que les annotations de type, et prend en charge de nouveaux types tels queOptional etLocalDate.

Pour des informations complètes sur les spécifications, allez-y et lisez lesJSR 380.

3. Les dépendances

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

3.1. API de validation

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


    javax.validation
    validation-api
    2.0.0.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 les dépendances suivantes:


    org.hibernate.validator
    hibernate-validator
    6.0.2.Final


    org.hibernate.validator
    hibernate-validator-annotation-processor
    6.0.2.Final

Une note rapide ici est quehibernate-validator is entirely separate from the persistence aspects of Hibernate et 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 des variables, en permettant des expressions à l’intérieur des messages de violation.

Pour analyser ces expressions, nous devons ajouter une dépendance à la fois à l'API du langage d'expression et à une implémentation de cette API. GlassFish fournit l'implémentation de référence:


    javax.el
    javax.el-api
    3.0.0



    org.glassfish.web
    javax.el
    2.2.6

Si ces fichiers JAR ne sont pas ajoutés, vous recevrez un message d'erreur au moment de l'exécution, comme indiqué ci-dessous:

HV000183: Impossible de charger «javax.el.ExpressionFactory». Vérifiez que vous avez les dépendances EL sur le chemin de classe ou utilisez plutôt ParameterMessageInterpolator

4. Utilisation des annotations de validation

Nous allons utiliser un beanUser comme exemple principal ici 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 pasnull
@AssertTrue - valide que la valeur de la propriété annotée esttrue
@Size - valide que la valeur de la propriété annotée a une taille comprise entre les attributsmin etmax; peut être appliqué aux propriétésString,Collection,Map et de tableau
@Min -vValide que la propriété annotée a une valeur non inférieure à l'attributvalue
@Max - valide que la propriété annotée a une valeur non supérieure à l'attributvalue
@Email - valide que la propriété annotée est une adresse e-mail valide

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

Voici quelques annotations supplémentaires dans la JSR:

@NotEmpty - valide que la propriété n'est pas nulle ou vide; peut être appliqué aux valeursString,Collection,Map ouArray
@NotBlank - peut être appliqué uniquement aux valeurs de texte et validé 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* and *@FutureOrPresent* - valide qu'une valeur de date est dans le futur, ou dans le futur, y compris le présent

The validation annotations can also be applied to elements of a collection:

List<@NotBlank String> preferences;

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

La spécificationalso supports the new Optional type dans Java 8:

private LocalDate dateOfBirth;

public Optional<@Past LocalDate> getDateOfBirth() {
    return Optional.of(dateOfBirth);
}

Ici, le framework de validation dépliera automatiquement la valeurLocalDate et la validera.

5. Validation programmatique

Certains frameworks, tels que Spring, disposent de moyens simples pour 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 programmation:

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

Pour valider un bean, il faut d'abord avoir un objetValidator, qui est construit à l'aide d'unValidatorFactory.

5.1. Définir le haricot

Nous allons maintenant configurer cet utilisateur non valide - avec une valeur nulle dename:

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 unValidator, nous pouvons valider notre bean en le passant à la méthodevalidate. Toute violation des contraintes définies dans l'objetUser sera renvoyée sous forme deSet.

Set> violations = validator.validate(user);

En itérant sur les violations, nous pouvons obtenir tous les messages de violation en utilisant la méthodegetMessage.

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

Dans notre exemple (ifNameIsNull_nameValidationFails), l'ensemble contiendrait un seulConstraintViolation, avec le message «Name cannot be null».

6. Conclusion

Ce didacticiel s'est concentré sur un passage simple à travers l'API de validation Java standard et a illustré les bases de la validation de bean à l'aide d'annotations et d'APIjavax.validation.

Une implémentation de ce concepts de cet article peut être trouvée dans le projet GitHub. Nous présenterons plus de fonctionnalités de JSR 380 et Hibernate Validator dans les prochains articles.

Tous les extraits de code peuvent être trouvésover on GitHub.

TOC