Maison  >  Article  >  Java  >  Utilisation de Bean Validation pour la vérification des paramètres dans le développement d'API Java

Utilisation de Bean Validation pour la vérification des paramètres dans le développement d'API Java

WBOY
WBOYoriginal
2023-06-18 23:58:011515parcourir

Dans le développement de l'API Java, la vérification des paramètres est un maillon très important. Grâce au framework Bean Validation, vous pouvez facilement vérifier les paramètres pour garantir la légitimité des transferts de paramètres d'API. Cet article explique comment utiliser Bean Validation.

1. Qu'est-ce que la validation des haricots ?

Bean Validation fait partie de la spécification Java EE 6. Il s'agit d'un cadre de validation de paramètres basé sur des annotations qui peut être utilisé pour ajouter des règles de validation aux annotations telles que des méthodes, des constructeurs, des champs et des propriétés. Ces annotations peuvent aider les développeurs à mieux prévenir les erreurs de saisie pendant la phase d'écriture du code, ainsi qu'à détecter et à signaler les erreurs de saisie utilisateur au moment de l'exécution.

Le framework Bean Validation résout principalement les problèmes suivants :

  1. Vérifier la logique métier et les restrictions (par exemple : s'il est vide, s'il s'agit d'une boîte aux lettres, s'il s'agit d'un numéro, etc.).
  2. Vérifiez le format et la syntaxe (ex : date, numéro de téléphone, code postal, etc.).
  3. Vérifiez l'interdépendance de deux ou plusieurs champs (ex : la date de début doit être antérieure à la date de fin).

2. Comment fonctionne la validation Bean ?

Le framework Bean Validation utilise des annotations pour marquer les paramètres qui doivent être vérifiés. Ces annotations incluent @NotNull, @Min, @Max, @Size, @Pattern, etc. Lorsque les paramètres sont transmis à la méthode, le framework Bean Validation exécute automatiquement les règles de vérification correspondantes. Lorsque la vérification échoue, le framework Bean Validation envoie un message d'erreur. Les développeurs peuvent écrire des règles de validation personnalisées pour répondre aux besoins de l'entreprise.

Le framework Bean Validation fournit un ensemble de règles de validation prédéfinies qui peuvent être appliquées aux propriétés et aux paramètres de méthode dans les Java Beans. Les règles prédéfinies incluent :

@NotNull : Vérifiez s'il s'agit d'une valeur nulle

@Size : Vérifiez la longueur de la chaîne, de la collection, de la carte et du tableau

@Min, @Max : vérifiez la taille de la valeur

@Email : Vérifiez si Pour les adresses e-mail

@Pattern : Vérifiez les chaînes basées sur des expressions régulières

Lorsque vous utilisez le framework Bean Validation, vous devez inclure javax.validation-api et l'implémentation Bean Validation correspondante dans le chemin de classe, comme Hibernate Validator, via Maven, vous pouvez ajouter les dépendances suivantes :

<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.1.Final</version>
</dependency>
<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.0.10.Final</version>
</dependency>

3. Exemple de validation de bean

Supposons que nous ayons une classe User, qui contient les informations de base de l'utilisateur. Nous devons maintenant vérifier les attributs de la classe User :

public class User {
    private String name;
    private Integer age;
    private String email;
    private String address;
  
    // getters and setters
}
.

Vérification requise par le projet Les règles sont les suivantes :

  1. le nom n'est pas vide et la longueur est supérieure à 5 et inférieure à 10
  2. l'âge n'est pas vide et supérieur à 0 et inférieur à 200 ; n'est pas vide et est une adresse e-mail valide ;
  3. l'adresse peut être vide .
  4. Nous pouvons utiliser Bean Validation pour définir ces règles de validation. L'implémentation spécifique est la suivante :
public class UserValidator {

    private Validator validator;

    public UserValidator() {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        validator = factory.getValidator();
    }

    /**
     * 对 User 对象进行校验
     * 
     * @param user
     * @return
     */
    public String validate(User user) {

        Set<ConstraintViolation<User>> violations = validator.validate(user);

        StringBuilder result = new StringBuilder();
        if (!violations.isEmpty()) {
            for (ConstraintViolation<User> violation : violations) {
                result.append(violation.getMessage()).append(";");
            }
        }

        return result.toString();
    }
}

Dans la classe UserValidator, nous utilisons la classe d'outils Validator pour créer un objet ValidatorFactory via la méthode buildDefaultValidatorFactory() pour créer un objet instancié. Objet validateur. Les objets utilisateur peuvent être vérifiés en appelant la méthode validator.validate(user). Pour les résultats de la vérification, nous enregistrons toutes les informations d'erreur dans l'objet StringBuilder et les renvoyons à l'appelant.

Enfin, nous pouvons utiliser l'objet UserValidator dans la classe test et effectuer le test :

public class UserValidatorTest {
  
    @Test
    void testValidateUser() {
        User user = new User();
        user.setName("abcd");
        user.setAge(300);
        user.setEmail("abc");
        user.setAddress(null);

        UserValidator validator = new UserValidator();
        String result = validator.validate(user);

        assertThat(result, containsString("Name length must be between 5 and 10."));
        assertThat(result, containsString("Size must be between 1 and 200."));
        assertThat(result, containsString("must be a well-formed email address"));
    }
}

Dans la méthode de test ci-dessus, nous avons créé un objet User dont les attributs ne respectaient pas les règles de validation, donc la validate() de UserValidator a été appelé La méthode renverra le message d'erreur correspondant.

4. Résumé

Cet article présente le concept et l'utilisation du framework Bean Validation. Le framework vérifie les paramètres via des annotations, ce qui peut aider les développeurs à éviter les erreurs de saisie lors de l'écriture du code et à détecter et inviter les erreurs de saisie de l'utilisateur au moment de l'exécution. Dans le même temps, les développeurs peuvent rédiger des règles de vérification personnalisées en fonction des besoins de l'entreprise, afin de répondre à des scénarios de vérification plus complexes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn