back java spring-boot

Validation Spring Boot - du standard au sur-mesure

Publié le 17/03/2026 Source : sfeir.dev

Dans l’univers Java — et plus particulièrement avec Spring Boot — la **validation déclarative** par annotations est une pratique ancrée dans les traditions des projets robustes et maintenables.
Elle permet d’exprimer, proche du modèle de données, des règles simples et lisibles : « ce champ ne doit pas être vide », « cet e-mail doit être valide », « ce nombre doit être ≥ 18 », etc.

Dans cet article, nous explorons en profondeur les annotations de validation avec Spring Boot (Jakarta Bean Validation / Hibernate Validator).
Vous découvrirez les annotations les plus courantes, leurs forces et limites, un exemple concret pas à pas, ainsi que la création d’annotations personnalisées, comme @Password.

Présentation des annotations

Contexte technique

Catégories d’annotations courantes

Pour en savoir plus, n’hésitez pas à lire notre article sur les annotations :

Comprendre les annotations dans Spring Boot - guide et exemples

⚖️ Avantages et inconvénients

➕ Avantages

➖ Inconvénients

Exemple pratique

Prenons une classe UserDTO :

@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserDto {

    @NotBlank(message = "Username cannot be blank")
    @Size(min = 3, max = 20, message = "Username must be between 3 and 20 characters")
    private String username;

    @Password(message = "Password must contain at least one digit, one lowercase, one uppercase, one special character, and be between 8 and 20 characters long")
    private String password;

    @Email(message = "Email should be valid")
    @NotBlank(message = "Email cannot be blank")
    private String email;

    @Min(value = 18, message = "Age should not be less than 18")
    @Max(value = 100, message = "Age should not be greater than 100")
    private int age;

    @Pattern(regexp = "^[0-9]{10}$", message = "Phone number must be 10 digits")
    private String phoneNumber;

    @URL(message = "Website URL should be valid")
    private String website;

    @PastOrPresent(message = "Registration date cannot be in the future")
    private LocalDate registrationDate;

    @CreditCardNumber(message = "Credit card number should be valid")
    private String creditCardNumber;

    @NotEmpty(message = "Hobbies cannot be empty")
    @Size(min = 1, max = 5, message = "User must have between 1 and 5 hobbies")
    private List<String> hobbies;

    @NotNull(message = "Preferences cannot be null")
    private List<String> preferences;

}

ça en fait des annotations

Explication détaillée

Créer ses propres annotations — pourquoi et comment ?

Pourquoi créer une annotation personnalisée ?

Créons notre annotation

@Documented
@Constraint(validatedBy = PasswordValidator.class)
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Password {
    String message() default "Invalid password";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

**Explication des annotations :**

Les méthodes message, groups et payload sont imposées par la spécification Bean Validation. Elles permettent de personnaliser le message d’erreur et d’intégrer la contrainte dans des scénarios avancés (groupes de validations, charges associées).

public class PasswordValidator implements ConstraintValidator<Password, String> {

    private static final String PASSWORD_PATTERN =
            "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,20}$";

    private static final Pattern pattern = Pattern.compile(PASSWORD_PATTERN);

    @Override
    public void initialize(Password constraintAnnotation) {
    }

    @Override
    public boolean isValid(String password, ConstraintValidatorContext context) {
        if (password == null || password.isBlank()) {
            return false;
        }
        return pattern.matcher(password).matches();
    }
}

Conclusion

Les annotations de validation forment une brique essentielle et traditionnelle du développement d’applications robustes en Java et Spring Boot. Elles permettent d’exprimer de manière concise et lisible, directement sur le modèle de données, des règles simples et répétables, telles que la non-nullité d’un champ, le format d’un e-mail ou la complexité d’un mot de passe.

Grâce à leur intégration étroite avec Spring, ces annotations peuvent être appliquées aux DTO, aux entités, et même aux paramètres de méthode, et elles s’insèrent naturellement dans le cycle de vie des requêtes HTTP et des services métiers. L’utilisation d’annotations standards comme @NotBlank, @Size, @Email ou @PastOrPresent assure un niveau de validation immédiat et lisible, tandis que la création d’annotations personnalisées, comme @Password, permet d’étendre ces règles aux besoins spécifiques de l’application.

En combinant annotations standard et personnalisées, il devient possible de centraliser la logique de validation, d’améliorer la maintenabilité du code et de garantir la cohérence des données à travers toutes les couches de l’application. Ainsi, maîtriser ces annotations et leur fonctionnement est non seulement un gage de qualité technique, mais aussi une manière de respecter les conventions éprouvées et la robustesse attendue dans le développement Java moderne.