Validación de Java Bean

Validación de Bean en breve

Spring Framework proporciona soporte para la Validación de Java Bean

Bean Validation proporciona una forma común de comprobar la validez declarando restricciones y metadatos para aplicaciones Java. Para usarlo, debe anotar las propiedades del modelo de dominio con restricciones de validación declarativa, que luego el tiempo de ejecución aplica. Hay restricciones integradas, pero también puede definir sus propias restricciones.

Considere el siguiente ejemplo, que muestra un modelo PersonForm simple con dos propiedades:

public class PersonForm {
    private String name;
    private int age;
}

class PersonForm(
        private val name: String,
        private val age: Int
)

La validación de Bean le permite declarar restricciones, como se muestra en el siguiente ejemplo:

public class PersonForm {
    @NotNull
    @Size(max=64)
    private String name;
    @Min(0)
    private int age;
}

class PersonForm(
    @get:NotNull @get:Size(max=64)
    private val name: String,
    @get:Min(0)
    private val age: Int
)

El validador de validación de Bean luego valida instancias de esta clase según lo declarado restricciones. Para obtener información general sobre esta API, consulte "Bean Validation". Consulte la documentación del Hibernate Validator para conocer restricciones específicas. Para aprender cómo configurar un proveedor de validación de bean como Spring Bean, continúe leyendo.

Configuración de un proveedor de validación de Bean

Spring proporciona soporte completo para la API de validación de Bean, incluido el arranque del Bean. Validación del proveedor como Spring Bean. Esto le permite implementar javax.validation.ValidatorFactory o javax.validation.Validator siempre que se requiera validación en su aplicación.

Puede usar LocalValidatorFactoryBean para configurar el validador predeterminado como un Spring Bean, como se muestra en el siguiente ejemplo:

import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
@Configuration
public class AppConfig {
    @Bean
    public LocalValidatorFactoryBean validator() {
        return new LocalValidatorFactoryBean();
    }
}

<bean id="validator"
    class="org.springframework.validation. beanvalidation.LocalValidatorFactoryBean"/>

La configuración básica del ejemplo anterior hace que la validación del bean se inicialice utilizando el mecanismo de carga predeterminado. Un proveedor de validación de Bean, como Hibernate Validator, debe estar en el classpath y ser detectado automáticamente.

Inyección de validador

LocalValidatorFactoryBean se implementa como javax.validation.ValidatorFactory y javax.validation.Validator, así como org.springframework.validation.Validator de Spring. Puede incrustar una referencia a cualquiera de estas interfaces en beans que deberían llamar a la lógica de validación.

Puede incrustar una referencia a javax.validation.Validator si prefiere trabajar directamente con la interfaz API -Bean Validation, como se muestra en el siguiente ejemplo:

import javax.validation.Validator;
@Service
public class MyService {
    @Autowired
    private Validator validator;
}

import javax.validation.Validator;
@Service
class MyService(@Autowired private val validator: Validator)

Puedes incrustar una referencia a org.springframework.validation.Validator, si el bean requiere la API de validación de Spring, como se muestra en el siguiente ejemplo:

import org.springframework.validation.Validator;
@Service
public class MyService {
    @Autowired
    private Validator validator;
}

import org.springframework.validation.Validator
@Service
class MyService(@Autowired private val validator : Validator)

Configuración de restricciones personalizadas

Cada restricción de validación de bean consta de dos partes:

• La anotación @Constraint, que declara la restricción y sus propiedades personalizadas.

• Implementaciones de Interfaz javax.validation.ConstraintValidator, que implementa la lógica detrás de la restricción.

Para asociar la declaración con la implementación, cada anotación @Constraint hace referencia la correspondiente clase de implementación ConstraintValidator. En tiempo de ejecución, ConstraintValidatorFactory crea una instancia de una implementación a la que se hace referencia si la anotación de restricción ocurre en su modelo de dominio.

De forma predeterminada, LocalValidatorFactoryBean configura SpringConstraintValidatorFactory, que utiliza Spring para crear instancias de ConstraintValidator. Esto permite que los ConstraintValidators personalizados aprovechen la inyección de dependencia como cualquier otro Spring Bean.

El siguiente ejemplo muestra una declaración @Constraint personalizada seguida de la implementación asociada ConstraintValidator, que utiliza Spring para la inyección de dependencia:

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention( RetentionPolicy.RUNTIME)
@Constraint(validatedBy=MyConstraintValidator.class)
public @interface MyConstraint {
}

 
@Target(AnnotationTarget.FUNCTION, AnnotationTarget.FIELD)
@Retention(AnnotationRetention.RUNTIME)
@Constraint(validatedBy = MyConstraintValidator::class)
annotation class MyConstraint

        
import javax.validation.ConstraintValidator;
public class MyConstraintValidator implements ConstraintValidator {
    @Autowired;
    private Foo aDependency;
    // ...
}

import javax.validation.ConstraintValidator
class MyConstraintValidator(private val aDependency: Foo) : ConstraintValidator {
    // ...
}

Como se desprende del ejemplo anterior, la implementación ConstraintValidator puede tener su dependencias propias, marcadas con la anotación @Autowired, como cualquier otro Spring Bean.

Validación de métodos administrados por Spring

Puedes implementar la funcionalidad de validación de métodos compatible con Bean Validation 1.1 (y, como extensión especial, también Hibernate Validator 4.3), en el contexto Spring a través de la definición de MethodValidationPostProcessor:

import org .springframework.validation.beanvalidation.MethodValidationPostProcessor;
@Configuration
public class AppConfig {
    @Bean
    public MethodValidationPostProcessor validationPostProcessor() {
        return new MethodValidationPostProcessor();
   }
}

<bean class="org.springframework.validation.beanvalidation.MethodValidationPostProcessor"/ >

Para implementar la validación de métodos administrados por Spring, todas las clases de destino deben estar anotadas con la anotación @Validated de Spring. en el que opcionalmente también se pueden declarar grupos de validación para su uso. Consulte el código MethodValidationPostProcessor para obtener más detalles sobre la configuración utilizando los proveedores Hibernate Validator y Bean Validation 1.1.

Opciones de configuración adicionales

La configuración predeterminada de LocalValidatorFactoryBean es suficiente para la mayoría de los casos. Hay varias opciones de configuración para varias construcciones de validación de beans, desde la interpolación de mensajes hasta la habilitación del recorrido. Consulte javadoc en LocalValidatorFactoryBean para obtener más información sobre estas opciones.

Configuración de DataBinder

A partir de Spring 3, puede configure una instancia de DataBinder utilizando el Validator. Una vez configurado, puede llamar a Validator llamando a binder.validate(). Cualquier comprobación de validez de Errors se agrega automáticamente al enlace BindingResult.

El siguiente ejemplo muestra cómo utilizar mediante programación DataBinder. para llamar a las comprobaciones de validación lógica después de vincularse al objetivo:

Foo target = new Foo();
DataBinder binder = new DataBinder(target);
binder.setValidator(new FooValidator());
// bind to the target object
binder.bind(propertyValues);
// validate the target
object binder.validate();
// get the BindingResult, including all validation errors
BindingResult results = binder.getBindingResult();

val target = Foo()
val binder = DataBinder(target)
binder.validator = FooValidator()
// bind to the target object
binder.bind(propertyValues)
// validate the target object
binder.validate()
// get the BindingResult, which includes everything validation errors
val results = binder.bindingResult

También puede configurar DataBinder usando múltiples instancias de Validator a través de dataBinder.addValidators y dataBinder.replaceValidators. Esto tiene sentido cuando se combina la validación de beans configurada globalmente con un Validator de Spring configurado localmente para una instancia de DataBinder.