# Jakarta Bean Validation en Quarkus: Validación de Datos Simplificada

## **Introducción**

Jakarta Bean Validation (JSR 380) proporciona un mecanismo declarativo para validar datos en aplicaciones Java. En Quarkus, Bean Validation está completamente integrado y funciona automáticamente en endpoints REST.

## **¿Qué es Bean Validation?**

Bean Validation permite definir reglas de validación usando anotaciones en clases Java. Estas validaciones se ejecutan automáticamente cuando se reciben datos en endpoints REST o cuando se persisten entidades.

## **Validaciones Estándar**

### **Anotaciones Básicas**

```go
public class HeroCreateDTO {
    @NotBlank(message = "El nombre es requerido")
    @Size(min = 2, max = 100)
    private String name;
    
    @NotNull
    @Min(1)
    @Max(100)
    private Integer powerLevel;
    
    @Email
    private String email;
    
    @Past
    private LocalDate birthDate;
}
```

### **Validaciones Comunes**

* `@NotNull`: El campo no puede ser null
    
* `@NotBlank`: String no puede estar vacío
    
* `@NotEmpty`: Colección/array no puede estar vacío
    
* `@Size`: Tamaño de string/colección
    
* `@Min` / `@Max`: Valores numéricos
    
* `@Email`: Formato de email
    
* `@Past` / `@Future`: Fechas
    
* `@Pattern`: Expresión regular
    

## **Validaciones Personalizadas**

### **Crear un Validator Personalizado**

```go
@Target({FIELD, PARAMETER})
@Retention(RUNTIME)
@Constraint(validatedBy = PowerLevelValidator.class)
public @interface ValidPowerLevel {
    String message() default "Nivel de poder inválido";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

public class PowerLevelValidator implements ConstraintValidator<ValidPowerLevel, Integer> {
    @Override
    public boolean isValid(Integer value, ConstraintValidatorContext context) {
        return value != null && value >= 1 && value <= 100;
    }
}
```

## **Validation Groups**

Los grupos permiten validar diferentes campos según el contexto:

```go
public interface CreateGroup {}
public interface UpdateGroup {}

public class HeroDTO {
    @NotNull(groups = {CreateGroup.class, UpdateGroup.class})
    private Long id;
    
    @NotBlank(groups = CreateGroup.class)
    private String name;
    
    @NotNull(groups = UpdateGroup.class)
    private Integer powerLevel;
}
```

## **Validación en REST Endpoints**

Quarkus valida automáticamente los parámetros de los endpoints:

```go
@POST
public Response createHero(@Valid @NotNull HeroCreateDTO heroDTO) {
    // Si la validación falla, se retorna 400 automáticamente
    Hero hero = heroService.create(heroDTO);
    return Response.ok(hero).build();
}
```

## **Exception Mapper Personalizado**

Puedes personalizar las respuestas de error:

```go
@Provider
public class ValidationExceptionMapper implements ExceptionMapper<ConstraintViolationException> {
    @Override
    public Response toResponse(ConstraintViolationException exception) {
        Map<String, Object> errors = new HashMap<>();
        exception.getConstraintViolations().forEach(violation -> {
            String field = violation.getPropertyPath().toString();
            String message = violation.getMessage();
            errors.put(field, message);
        });
        return Response.status(400).entity(errors).build();
    }
}
```

## **Validación Programática**

También puedes validar manualmente:

```go
@Inject
Validator validator;

public void validateHero(Hero hero) {
    Set<ConstraintViolation<Hero>> violations = validator.validate(hero);
    if (!violations.isEmpty()) {
        throw new ConstraintViolationException(violations);
    }
}
```

## **Ejemplo Completo**

Nuestro demo muestra:

* Validaciones estándar en DTOs
    
* Validadores personalizados
    
* Validation groups
    
* Exception mappers
    
* Validación en parámetros de endpoints
    

## **Ventajas en Quarkus**

1. **Automático**: Las validaciones se ejecutan automáticamente
    
2. **Integrado**: Funciona sin configuración adicional
    
3. **Mensajes Personalizados**: Fácil de personalizar mensajes de error
    
4. **Performance**: Validación eficiente en tiempo de compilación
    

## **Conclusión**

Bean Validation en Quarkus hace que la validación de datos sea simple y declarativa. La integración automática con REST endpoints elimina mucho código boilerplate.

## **Recursos**

* [Demo completo](file:///Users/josediaz/Projects/JoeDayz/jakartaee-2026/quarkus-demos/bean-validation/)
    
* [Quarkus Validation Guide](https://quarkus.io/guides/validation)
    
* [Jakarta Bean Validation Specification](https://jakarta.ee/specifications/bean-validation/)