Comment effectuer la validation JavaBeans

La validation JavaBeans (Bean Validation) est un modèle de validation disponible depuis l’introduction de la plateforme Java Enterprise Edition 6. Elle fournit une méthode standard permettant à différentes applications Java de valider les données saisies. Dans un article précédent, nous avons expliqué comment les DTO Java sont utilisés dans les applications modernes pour éviter les fuites accidentelles de données.

Dans cet article, nous allons créer une application Java et valider quelques chaînes d’exemple pour montrer comment fonctionne la validation JavaBean. Mais commençons par revoir ce que sont les Beans. 

Les JavaBeans sont des objets Java qui contiennent des propriétés et des méthodes permettant de stocker et de transférer des données entre différentes parties d’une application Java. Les Beans sont des composants réutilisables qui encapsulent les données et le comportement d’une application Java. Ils constituent une méthode standard de représentation des objets et respectent certains modèles et conventions de conception. 

• Les JavaBeans contiennent des propriétés, c’est-à-dire des variables d’instance qui représentent l’état d’un objet. Ces variables doivent être privées. Les méthodes getter et setter permettent d’accéder aux données stockées dans un Bean.

• Les constructeurs sans argument servent à créer une instance d’un Bean. Nous pouvons ajouter des constructeurs pour proposer différentes façons d’initialiser un Bean.

• Les JavaBeans sont sérialisables, ce qui signifie que leur état peut être enregistré dans un fichier ou transmis sur un réseau.

• Les JavaBeans respectent des conventions de nommage, comme l’utilisation des méthodes getXXX et setXXX pour accéder aux propriétés et en définir les valeurs.

• Les JavaBeans contiennent souvent des classes BeanInfo, qui fournissent des informations sur le bean aux outils et aux IDE.

Nous utilisons souvent les JavaBeans comme blocs de construction pour organiser et structurer les données des applications de grande envergure. Ils contiennent généralement des variables d’instance (propriétés) et des méthodes getter et setter (getXXX et setXXX) permettant d’accéder aux données stockées dans un Bean. Nous utilisons également les JavaBeans pour créer des objets personnalisés réutilisables dans différentes parties d’une application, ce qui facilite la maintenance et la mise à jour du code.

Utiliser la validation JavaBeans

L’une des principales utilisations des Beans consiste à valider les données saisies par les utilisateurs en définissant des contraintes sur les propriétés d’un Bean, comme des longueurs minimale et maximale, les caractères autorisés et les champs obligatoires. Nous utilisons ensuite ces contraintes pour valider les données saisies par les utilisateurs et nous assurer qu’elles respectent les exigences définies avant leur traitement par l’application.

L’exemple suivant utilise Hibernate Validator dans un projet Apache Maven. Hibernate Validator est l’implémentation de référence de Bean Validation.

Créer une application Java

Nous devons d’abord ajouter Hibernate Validator comme dépendance dans notre fichier pom.xml Maven. Pour cela, utilisez le code ci-dessous :

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.1.5.Final</version>
</dependency>

Ajoutons ensuite l’API Bean Validation comme dépendance dans pom.xml à l’aide du code suivant :

<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.1.Final</version>
</dependency>

Créons maintenant un projet Java dans un nouveau fichier nommé BeanValidation.java et importons les bibliothèques nécessaires :

import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.validation.constraints.Pattern;
import java.util.Set;
import javax.validation.ConstraintViolation;

Créons ensuite un Bean simple avec une propriété à valider à l’aide du code ci-dessous :

public class ExampleBean {
    @NotNull
    @Size(min=2, max=10)
    private String exampleString;

//Getters
    public String getExampleString() {
        return exampleString;
    }

//Setters
    public void setExampleString(String exampleString) {
        this.exampleString = exampleString;
    }
}

Cet exemple utilise les annotations @NotNull et @Size pour indiquer que la propriété exampleString ne peut pas être nulle et doit comporter entre deux et dix caractères. Nous définissons les méthodes getExampleString et setExampleStrin comme getter et setter de la propriété exampleString dans la classe ExampleBean.

Voir comment fonctionne Bean Validation

Pour utiliser la classe BeanValidation afin de valider le Bean, exécutons le code suivant :

public class BeanValidation {
    public static void main(String[] args) {
        ExampleBean bean = new ExampleBean();
        bean.setExampleString("hello");
// Create a Validator instance using the default validation factory      
  ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();
// Validate an instance of the ExampleBean class and get a set of constraint violations, if any        
Set<ConstraintViolation<ExampleBean>> violations = validator.validate(bean);
        if (!violations.isEmpty()) {
            System.out.println("Errors:");
            for (ConstraintViolation<ExampleBean> violation : violations) {
                System.out.println(violation.getMessage());
            }
        } else {
            System.out.println("Validation successful");
        }
    }
}

Comme nous avons défini la valeur de la chaîne sur hello, elle passe la validation. Si nous attribuons à la propriété exampleString une valeur qui ne respecte pas les contraintes définies dans un Bean, la méthode validate renvoie un ensemble d’objets ConstraintViolation décrivant les erreurs.

Pour gérer les erreurs lorsque des chaînes ne passent pas la validation, nous créons des cas de gestion des erreurs qui vérifient les violations et affichent un message d’erreur le cas échéant.

Voici le code complet du fichier BeanValidation.java :

import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.validation.ConstraintViolation;

public class ExampleBean {
    @NotNull
    @Size(min=2, max=10)
    private String exampleString;

    public String getExampleString() {
        return exampleString;
    }

    public void setExampleString(String exampleString) {
        this.exampleString = exampleString;
    }
}

public class BeanValidation {
    public static void main(String[] args) {
        ExampleBean bean = new ExampleBean();
        bean.setExampleString("hello");

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

        Set<ConstraintViolation<ExampleBean>> violations = validator.validate(bean);

        if (!violations.isEmpty()) {
            System.out.println("Errors:");
            for (ConstraintViolation<ExampleBean> violation : violations) {
                System.out.println(violation.getMessage());
            }
        } else {
            System.out.println("Validation successful");
        }
    }
}

Cet exemple renvoie une erreur si la chaîne saisie comporte moins de deux caractères, plus de dix caractères ou est nulle. Si la chaîne ne respecte pas ces contraintes, un message d’erreur indique l’exigence non satisfaite.

Voici un exemple de contraintes permettant de valider les données de connexion d’un utilisateur, avec des champs pour l’adresse e-mail et le mot de passe :

public class UserBean {
    @NotNull
    @Size(min=5, max=30)
    @Pattern(regexp = "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}")
    private String email;

    @NotNull
    @Size(min=8, max=15)
    @Pattern(regexp = "((?=.*[a-z])(?=.*\\d)(?=.*[A-Z])(?=.*[@#$%!]).{8,15})")
    private String password;

}

La classe UserBean contient deux propriétés : email et password. La propriété email garantit que les données saisies comportent entre cinq et trente caractères et correspondent au format d’une adresse e-mail valide. 

La propriété password garantit que le mot de passe n’est pas nul, comporte entre huit et quinze caractères et contient au moins une lettre minuscule, une lettre majuscule, un chiffre et un caractère spécial. 

Comprendre les contraintes

Les contraintes sont définies à l’aide d’annotations, des types de métadonnées spécifiques ajoutés aux classes, champs et méthodes Java. Nous pouvons appliquer des contraintes aux propriétés d’une classe Bean à différents endroits : directement à la propriété, à une méthode getter de cette propriété ou à un paramètre de constructeur de la classe.

Une fois les contraintes définies pour un Bean, la validation utilise un objet Validator de l’API Bean Validation. L’objet Validator vérifie si une instance de Bean respecte les contraintes de ses propriétés. Si un Bean enfreint une ou plusieurs contraintes, Validator renvoie un ensemble de violations indiquant quelles propriétés n’ont pas passé la validation et pourquoi.

Les JavaBeans proposent par défaut plusieurs contraintes intégrées dans l’API Bean Validation, que nous pouvons utiliser immédiatement. Parmi celles-ci figurent @NotNull, @Size, @Pattern, @Min, @Max, @DecimalMin et@DecimalMax. Pour obtenir la liste complète des contraintes intégrées, consultez la documentation Hibernate Validator.

Les contraintes personnalisées sont des contraintes que nous définissons pour répondre à des exigences de validation spécifiques. Pour les créer, nous définissons une annotation personnalisée et implémentons un ConstraintValidator qui définit la logique de validation. 

Créer des annotations personnalisées

Pour créer une contrainte personnalisée pour Bean Validation, nous devons :

• Créer une classe d’annotation personnalisée et l’annoter avec @Constraint. Cela indique que la classe annotée correspond à une contrainte personnalisée.

• Implémenter la logique de validation dans une classe qui implémente l’interface ConstraintValidator. La classe doit comporter des paramètres correspondant à l’annotation de contrainte personnalisée et au type d’éléments qu’elle peut valider.

• Enregistrer la contrainte personnalisée en ajoutant une entrée dans le fichier de configuration XML de validation ou en annotant la classe de contrainte personnalisée avec @Constraint(validatedBy=<Validator class>).

Voici un exemple de contrainte personnalisée nommée ValidSearchTerm :

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

@Documented
@Constraint(validatedBy = ValidSearchTermValidator.class)
@Target({ FIELD })
@Retention(RUNTIME)
public @interface ValidSearchTerm {

    String message() default "Search term contains invalid characters";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

Nous pouvons ensuite implémenter la logique de validation, qui utilise des expressions régulières pour créer la contrainte. Dans cet exemple, nous voulons une chaîne de recherche alphanumérique classique, sans caractère spécial :

public class ValidSearchTermValidator implements ConstraintValidator<ValidSearchTerm, String> {

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if (value == null) {
            return true;
        }
        return value.matches("[A-Za-z0-9]+");
    }
}

Nous pouvons ensuite utiliser la contrainte personnalisée dans un Bean comme ceci :

public class SearchBean {
    @ValidSearchTerm
    private String searchTerm;

    public String getSearchTerm() {
        return searchTerm;
    }

    public void setSearchTerm(String searchTerm) {
        this.searchTerm = searchTerm;
    }
}

En conclusion : Bean Validation

Bean Validation fournit une méthode unifiée et cohérente pour valider les données des applications Java, ce qui facilite l’écriture et la maintenance d’un code garantissant un traitement sécurisé des données. Le modèle Bean Validation nous permet de gagner le temps et les efforts que nous aurions consacrés à écrire une logique de validation personnalisée.

Avec Bean Validation, nous pouvons définir des contraintes sur les propriétés d’un JavaBean à l’aide d’annotations. Ces annotations, intégrées ou personnalisées, définissent les exigences auxquelles les données saisies par les utilisateurs doivent répondre pour être considérées comme valides. Le modèle utilise ensuite ces contraintes pour valider le Bean et détecter les erreurs éventuelles.

Bean Validation nous permet également de gérer les erreurs lors de la validation. Le framework renvoie une liste de violations de contraintes, que nous pouvons utiliser pour fournir à l’utilisateur des commentaires précis. Cela améliore l’expérience utilisateur et renforce la fiabilité et la sécurité de l’application.

Dans l’ensemble, Bean Validation est un outil essentiel pour garantir la qualité et la sécurité des applications Java. En suivant les bonnes pratiques de ce modèle, nous pouvons créer des applications bien conçues, faciles à maintenir et sécurisées.