Spring Boot 4 Microservices & REST APIs · Lección

Validadores personalizados

Escriba sus propias restricciones de validación

Validadores personalizados es una lección gratuita de Spring Boot 4 Microservices & REST APIs en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Spring Boot 4 Microservices & REST APIs, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Spring Boot 4 Microservices & REST APIs incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

When Built-ins Are Not Enough

Standard constraints cannot express every rule — a valid coupon code format, a phone number for a region, or a value that must exist in the database. For these you write a custom constraint backed by a validator.

Two Parts of a Custom Constraint

A custom constraint has two pieces:

An annotation that you place on fields or parameters
A ConstraintValidator that contains the actual checking logic

Defining the Annotation

Create the annotation and link it to its validator with @Constraint. Declare the standard message, groups, and payload members required by the spec.

@Target({ FIELD, PARAMETER })
@Retention(RUNTIME)
@Constraint(validatedBy = StrongPasswordValidator.class)
public @interface StrongPassword {
    String message() default "Password is not strong enough";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

Implementing ConstraintValidator

The validator implements ConstraintValidator<Annotation, Type> and overrides isValid. Return true when the value satisfies the rule.

public class StrongPasswordValidator
        implements ConstraintValidator<StrongPassword, String> {
    @Override
    public boolean isValid(String value, ConstraintValidatorContext ctx) {
        if (value == null) return true; // let @NotNull handle null
        return value.length() >= 8
            && value.chars().anyMatch(Character::isDigit)
            && value.chars().anyMatch(Character::isUpperCase);
    }
}

Null-Handling Convention

By convention a custom validator treats null as valid, delegating null-checking to @NotNull. This keeps constraints composable — each rule does one job.

Using the Custom Constraint

Apply your annotation just like a built-in one. Combined with @Valid on the controller, it participates in the normal validation flow.

public class CreateUserRequest {
    @NotBlank
    @StrongPassword
    private String password;
}

Custom Violation Messages

Inside isValid you can disable the default message and add a contextual one, useful when a single annotation enforces several sub-rules.

ctx.disableDefaultConstraintViolation();
ctx.buildConstraintViolationWithTemplate(
        "Password must include a digit and an uppercase letter")
   .addConstraintViolation();
return false;

Injecting Beans into a Validator

A ConstraintValidator is a Spring bean, so it can use constructor injection — enabling rules that consult a repository or service, such as uniqueness checks.

public class UniqueEmailValidator
        implements ConstraintValidator<UniqueEmail, String> {
    private final UserRepository repo;
    public UniqueEmailValidator(UserRepository repo) { this.repo = repo; }
    @Override
    public boolean isValid(String email, ConstraintValidatorContext ctx) {
        return email == null || !repo.existsByEmail(email);
    }
}

Class-Level Constraints

Some rules span multiple fields — "password must equal confirmPassword." Target the annotation at TYPE and validate the whole object, accessing several fields together.

@Target(TYPE)
@Retention(RUNTIME)
@Constraint(validatedBy = PasswordsMatchValidator.class)
public @interface PasswordsMatch {
    String message() default "Passwords do not match";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

Initialization Hook

Override initialize to capture attributes from the annotation instance, such as a configurable minimum length, before validation runs.

@Override
public void initialize(StrongPassword ann) {
    this.minLength = ann.minLength();
}

Keep Validators Pure and Fast

Validators run on every request, so keep them quick and side-effect-free where possible. Database-backed checks are fine but should be indexed and lightweight to avoid slowing request handling.

Quick Check

Test your understanding of custom validators.

Recap

Custom validators extend Bean Validation.

A constraint is an @Constraint annotation plus a ConstraintValidator
Override isValid; treat null as valid by convention
Validators are beans, so they support constructor injection
Use class-level constraints for cross-field rules
Customize messages via the validation context

Preguntas frecuentes

¿La lección «Validadores personalizados» es gratis?

Sí — el texto completo de «Validadores personalizados» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Spring Boot 4 Microservices & REST APIs, actualiza a CoddyKit PRO. El curso de Spring Boot 4 Microservices & REST APIs incluye 4 lecciones en total.

¿Qué aprenderé en «Validadores personalizados»?

Escriba sus propias restricciones de validación Practicas Spring Boot 4 Microservices & REST APIs con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Spring Boot 4 Microservices & REST APIs?

No se requiere experiencia previa. Spring Boot 4 Microservices & REST APIs en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Validadores personalizados»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Spring Boot 4 Microservices & REST APIs?

Sí. Cada lección de Spring Boot 4 Microservices & REST APIs incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Spring Boot 4 Microservices & REST APIs