Código Fuente: Ejemplo 1

Esta especificación considera una sola clase para realizar todas las validaciones. Esta clase es: “Validator” y la manera más simple de tener una referencia a este objeto es hacer lo siguiente:

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

Ahora bien, teniendo en cuenta la siguiente declaración:

public class ComprobanteDePago {
    private Date fechaDeEntrega;
    @Future
    public Date getFechaDeEntrega() {
        return fechaDeEntrega;
    }
}

y teniendo la referencia al objeto Validator podemos llevar a cabo las siguientes validaciones:

Validar el valor de un atributo

Si sólo deseamos ejecutar la validación @Future que está marcando el “getter” del atributo “fechaDeEntrega” tendríamos que hacer lo siguiente:

Set<ConstraintViolation<ComprobanteDePago>> errorsProperty =  validator.validateProperty(comprobante,"fechaDeEntrega");
System.out.println("Errores del atributo <fechaDeEntrega>:"+ errorsProperty);

Acá estamos llamando al método “validateProperty” del validator, enviándole como parámetros la instancia del objeto y el nombre del atributo que se desea validar.

Validar si un valor cumple con las restricciones de un atributo

Si sólo deseamos validar que cierto valor cumple con las restricciones de un atributo, sin tener que setear el valor a la instancia del objeto debemos hacer lo siguiente:

Set<ConstraintViolation<ComprobanteDePago>> errorsPropertyValue =  validator.validateValue(ComprobanteDePago.class,"fechaDeEntrega",new Date());
System.out.println("Errores del valor que se quiere setear al atributo <fechaDeEntrega>:"+ errorsPropertyValue);

Acá estamos llamando al método “validateValue” del validator, enviándole como parámetro la clase, el nombre del atributo y el valor que se desea validar.

Validar todo el objeto

Para validar todas las restricciones asociadas a un objeto debemos hacer lo siguiente:

ComprobanteDePago comprobante = new ComprobanteDePago();
Set<ConstraintViolation<ComprobanteDePago>> errors =  validator.validate(comprobante);
System.out.println("Errores:"+ errors);

Acá estamos llamando al método “validate” del validator y le estamos enviando la instancia del objeto. De esta manera obtendremos todos los errores luego de que todas las restricciones hayan sido revisadas.

A tener en cuenta

La anotación “@Valid” no es tomada en cuenta cuando se usa cualquiera de los métodos: “validateProperty” o “validateValue”.

Código Fuente: Ejemplo 1

Esta especificación define el API para poder validar JavaBeans tanto en Java EE como en Java SE.

El objetivo de esta especificación es proveer los mecanismos necesarios para poder declarar y validar Beans, así como también proveer de un repositorio de los constraints y un API para hacer las consultas acerca de los constraints existentes.

Implementaciones

Actualmente existe 2 implementaciones:

- Hibernate Validator, que es la primera implementación y

- Apache Bean Validation tiene soporte para la validación de métodos, lo cual no es parte de la especificación 303 pero es algo que está incluido en los anexos de la misma, lo de malo es que recién esta en su versión: 0.1-incubating.

Para ver los detalles usaremos la implementación: Hibernate Validator.

Declaración de constraints

Los constraints se pueden declarar usando xml o anotaciones, nosotros nos limitaremos a mostrar el uso utilizando anotaciones.

Se pueden dar los siguientes casos:

A nivel de atributo

Sirve para validar que el valor del atributo cumpla ciertos requisitos. Se debe tener en cuenta que el atributo puede tener cualquier nivel de visibilidad (public, prívate, etc), pero no debe ser estático (static).

public class ComprobanteDePago {
    @OnlyLetters
    private String codigoInterno;
    @NotNull
    private ComprobanteTipo tipo;

A nivel de getters

Sirve para validar que la propiedad relacionada al “getter” cumpla ciertos requisitos. Al validar se toma en cuenta el valor que retorna el método “getter”.

@Future
public Date getFechaDeEntrega() {
    return fechaDeEntrega;
}

A nivel de clase o interface

Sirve para hacer validaciones que incluyan más de un campo, en este caso se tiene la referencia a todos los datos de la instancia. Y se puede validar todas las posibles combinaciones del estado actual de la instancia.

@RucInfoChecker
public class ComprobanteDePago {

Validación de “graphs of object”.

Esto nos permite validar objetos de manera recursiva. Para esto se debe usar la anotación @Valid. Veamos el siguiente ejemplo para clarificar la idea:

public class Cliente {
    @NotNull
    private String nombre;
}

public class ComprobanteDePago {
    @Valid
    @NotNull
    private Cliente cliente;
}

Acá podemos ver que la clase “ComprobanteDePago” tiene como atributo la clase “Cliente”, además podemos ver que este atributo tiene 2 anotaciones @Valid, @NotNull, teniendo en cuenta esta configuración al momento de validar la clase: “ComprobanteDePago” también se ejecutará la validación de la clase “Cliente”, por tanto se verificará que el atributo “nombre” sea distinto de null.

Este comportamiento también funciona cuando usamos colecciones, arreglos y en general cualquier campo que implemente “Iterable”. En estos casos se ejecuta la validación de cada uno de los elementos de las colecciones.

Veamos el siguiente ejemplo:

public class ComprobanteDePago {
    @Valid
    @Size(min=1, max=20)
    private List items = new ArrayList();

A tener en cuenta:

a) Los constraints puedes ser usados tanto en clases como en interfaces.

b) Los constraints se heredan, tanto si se usa extend o implement.

c) En caso de que se sobreescriba un método que ya tenía constraints al final se juntan los constraints del método sobreescrito y el método actual.