validaciones condicionales en Spring

Question

Tengo un formulario que contiene algunos radio botón y check-boxes. Cada vez que el usuario selecciona/deselecciona un radio button o check-box, se habilitan/deshabilitan algunos otros campos de entrada.
Quiero agregar validación solo para los campos que están habilitados cuando el usuario envía el formulario. Los campos que están deshabilitados en el momento de la presentación no deben considerarse para la validación.

No quiero agregar esto en la validación del lado del cliente. ¿Hay alguna manera mejor/fácil de implementar la validación condicional en Spring 3.0 en lugar de agregar if en el validador?

Gracias!

Answer 1

Cuando los campos son discapacitados que se transfieren al controlador como null. Quería agregar una validación que permita null, es decir, campo deshabilitado o campo not blank, es decir, habilitado pero campo vacío.
Así que creé una anotación personalizada NotBlankOrNull que permitirá null y cadenas no vacías, también se ocupa de los espacios en blanco.
Aquí es mi clase de anotación

@Documented 
@Constraint(validatedBy = { NotBlankOrNullValidator.class }) 
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER }) 
@Retention(RUNTIME) 
public @interface NotBlankOrNull { 
    String message() default "{org.hibernate.validator.constraints.NotBlankOrNull.message}"; 

    Class<?>[] groups() default { }; 

    Class<? extends Payload>[] payload() default { }; 
} 

Validador

public class NotBlankOrNullValidator implements ConstraintValidator<NotBlankOrNull, String> { 

    public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) { 
     if (s == null) { 
      return true; 
     } 
     return s.trim().length() > 0; 
    } 

    @Override 
    public void initialize(NotBlankOrNull constraint) { 

    } 
} 

También he actualizado más detalles en mi site.

Answer 2

Si usa la validación de Bean JSR 303, entonces puede usar validation groups (groups) para esto.

Supongamos que tiene esta entrada de usuario, que contiene dos secciones. Los dos booleanos que indican si las secciones están habilitadas o deshabilitadas. (Por supuesto, puede utilizar las anotaciones más útiles que @NotNull)

public class UserInput { 
    boolean sectionAEnabled; 
    boolean sectionBEnabled; 

    @NotNull(groups=SectionA.class) 
    String someSectionAInput; 

    @NotNull(groups=SectionA.class) 
    String someOtherSectionAInput; 

    @NotNull(groups=SectionB.class) 
    String someSectionBInput; 

    Getter and Setter 
} 

Se necesitan dos interfaces para los grupos. Ellos trabajan solo como marcador.

public interface SectionA{} 

public interface SectionB{} 

Since Spring 3.1 puede utilizar la anotación primavera @Validated (en lugar de @Validate) en su método de control para activar la validación:

@RequestMapping... 
public void controllerMethod(
     @Validated({SectionGroupA.class}) UserInput userInput, 
     BindingResult binding, ...){...} 

antes de la primavera 3,1 no había manera de especificar el grupo de validación que debe usarse para la validación (porque @Validated no existe y @Validate no tiene un atributo de grupo), por lo que debe iniciar la validación por ha nd código escrito: Este es un ejemplo de cómo activar la validación en dependencia de la sección de brujas en Spring 3.0.

@RequestMapping... 
public void controllerMethod(UserInput userInput,...){ 

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

    List<Class<?>> groups = new ArrayList<Class<?>>(); 
    groups.add(javax.validation.groups.Default.class); //Always validate default 
    if (userInput.isSectionAEnabled) { 
    groups.add(SectionA.class); 
    } 
    if (userInput.isSectionBEnabled) { 
    groups.add(SectionB.class); 
    } 
    Set<ConstraintViolation<UserInput>> validationResult = 
    validator.validate(userInput, groups.toArray(new Class[0])); 

    if(validationResult.isEmpty()) { 
    ... 
    } else { 
    ... 
    } 
} 

(Por cierto: Para la solución Spring 3.0, también es posible hacer que la primavera inyectar el validador:

@Inject javax.validation.Validator validator 

<mvc:annotation-driven validator="validator"/> 

<bean id="validator" 
     class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean"> 
     <property name="validationMessageSource" ref="messageSource" /> 
</bean> 

)