JSR 303 Validation, si un champ est égal à "quelque chose", les autres champs ne doivent pas être nuls.

Question

Je cherche à faire une petite validation personnalisée avec JSR-303 javax.validation .

J'ai un domaine. Si une certaine valeur est saisie dans ce champ, je veux exiger que d'autres champs ne le soient pas. null .

J'essaie de trouver une solution. Je ne sais pas exactement comment j'appellerais cela pour trouver une explication.

Toute aide serait appréciée. Je suis assez novice en la matière.

Pour l'instant, je pense à une contrainte personnalisée. Mais je ne sais pas comment tester la valeur du champ dépendant à partir de l'annotation. En fait, je ne sais pas comment accéder à l'objet panel à partir de l'annotation.

public class StatusValidator implements ConstraintValidator<NotNull, String> {

    @Override
    public void initialize(NotNull constraintAnnotation) {}

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if ("Canceled".equals(panel.status.getValue())) {
            if (value != null) {
                return true;
            }
        } else {
            return false;
        }
    }
}

C'est le panel.status.getValue(); Je ne suis pas sûr de savoir comment procéder.

Answer 1

Définir une méthode qui doit être validée par true et mettre la valeur @AssertTrue en haut de la page :

  @AssertTrue
  private boolean isOk() {
    return someField != something || otherField != null;
  }

La méthode doit commencer par "is".

Answer 2

Dans ce cas, je suggère d'écrire un validateur personnalisé, qui validera au niveau de la classe (pour nous permettre d'accéder aux champs de l'objet) qu'un champ n'est requis que si un autre champ a une valeur particulière. Notez que vous devez écrire un validateur générique qui récupère 2 noms de champs et qui ne travaille qu'avec ces 2 champs. Pour exiger plus d'un champ, il faut ajouter ce validateur pour chaque champ.

Utilisez le code suivant comme idée (je ne l'ai pas testé).

• Interface du validateur

  /**
   * Validates that field {@code dependFieldName} is not null if
   * field {@code fieldName} has value {@code fieldValue}.
   **/
  @Target({TYPE, ANNOTATION_TYPE})
  @Retention(RUNTIME)
  @Repeatable(NotNullIfAnotherFieldHasValue.List.class) // only with hibernate-validator >= 6.x
  @Constraint(validatedBy = NotNullIfAnotherFieldHasValueValidator.class)
  @Documented
  public @interface NotNullIfAnotherFieldHasValue {
  
      String fieldName();
      String fieldValue();
      String dependFieldName();
  
      String message() default "{NotNullIfAnotherFieldHasValue.message}";
      Class<?>[] groups() default {};
      Class<? extends Payload>[] payload() default {};
  
      @Target({TYPE, ANNOTATION_TYPE})
      @Retention(RUNTIME)
      @Documented
      @interface List {
          NotNullIfAnotherFieldHasValue[] value();
      }
  
  }

• Mise en œuvre du validateur

  /**
   * Implementation of {@link NotNullIfAnotherFieldHasValue} validator.
   **/
  public class NotNullIfAnotherFieldHasValueValidator
      implements ConstraintValidator<NotNullIfAnotherFieldHasValue, Object> {
  
      private String fieldName;
      private String expectedFieldValue;
      private String dependFieldName;
  
      @Override
      public void initialize(NotNullIfAnotherFieldHasValue annotation) {
          fieldName          = annotation.fieldName();
          expectedFieldValue = annotation.fieldValue();
          dependFieldName    = annotation.dependFieldName();
      }
  
      @Override
      public boolean isValid(Object value, ConstraintValidatorContext ctx) {
  
          if (value == null) {
              return true;
          }
  
          try {
              String fieldValue       = BeanUtils.getProperty(value, fieldName);
              String dependFieldValue = BeanUtils.getProperty(value, dependFieldName);
  
              if (expectedFieldValue.equals(fieldValue) && dependFieldValue == null) {
                  ctx.disableDefaultConstraintViolation();
                  ctx.buildConstraintViolationWithTemplate(ctx.getDefaultConstraintMessageTemplate())
                      .addNode(dependFieldName)
                      .addConstraintViolation();
                      return false;
              }
  
          } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException ex) {
              throw new RuntimeException(ex);
          }
  
          return true;
      }
  
  }

• Exemple d'utilisation du validateur (hibernate-validator >= 6 avec Java 8+)

  @NotNullIfAnotherFieldHasValue(
      fieldName = "status",
      fieldValue = "Canceled",
      dependFieldName = "fieldOne")
  @NotNullIfAnotherFieldHasValue(
      fieldName = "status",
      fieldValue = "Canceled",
      dependFieldName = "fieldTwo")
  public class SampleBean {
      private String status;
      private String fieldOne;
      private String fieldTwo;
  
      // getters and setters omitted
  }

• Exemple d'utilisation du validateur (hibernate-validator < 6 ; l'ancien exemple)

  @NotNullIfAnotherFieldHasValue.List({
      @NotNullIfAnotherFieldHasValue(
          fieldName = "status",
          fieldValue = "Canceled",
          dependFieldName = "fieldOne"),
      @NotNullIfAnotherFieldHasValue(
          fieldName = "status",
          fieldValue = "Canceled",
          dependFieldName = "fieldTwo")
  })
  public class SampleBean {
      private String status;
      private String fieldOne;
      private String fieldTwo;
  
      // getters and setters omitted
  }

Notez que la mise en œuvre du validateur utilise BeanUtils de la classe commons-beanutils mais vous pouvez également utiliser la bibliothèque BeanWrapperImpl de Spring Framework .

Voir aussi cette excellente réponse : Validation inter-champs avec Hibernate Validator (JSR 303)

Answer 3

Vous devez utiliser des DefaultGroupSequenceProvider<T> :

ConditionalValidation.java

// Marker interface
public interface ConditionalValidation {}

MyCustomFormSequenceProvider.java

public class MyCustomFormSequenceProvider
    implements DefaultGroupSequenceProvider<MyCustomForm> {

    @Override
    public List<Class<?>> getValidationGroups(MyCustomForm myCustomForm) {

        List<Class<?>> sequence = new ArrayList<>();

        // Apply all validation rules from ConditionalValidation group
        // only if someField has given value
        if ("some value".equals(myCustomForm.getSomeField())) {
            sequence.add(ConditionalValidation.class);
        }

        // Apply all validation rules from default group
        sequence.add(MyCustomForm.class);

        return sequence;
    }
}

MonFormCustom.java

@GroupSequenceProvider(MyCustomFormSequenceProvider.class)
public class MyCustomForm {

    private String someField;

    @NotEmpty(groups = ConditionalValidation.class)
    private String fieldTwo;

    @NotEmpty(groups = ConditionalValidation.class)
    private String fieldThree;

    @NotEmpty
    private String fieldAlwaysValidated;

    // getters, setters omitted
}

Voir aussi Question connexe sur ce sujet .

Answer 4

Voici ce que j'en pense, en essayant d'être le plus simple possible.

L'interface :

@Target({TYPE, ANNOTATION_TYPE})
@Retention(RUNTIME)
@Constraint(validatedBy = OneOfValidator.class)
@Documented
public @interface OneOf {

    String message() default "{one.of.message}";

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

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

    String[] value();
}

Mise en œuvre de la validation :

public class OneOfValidator implements ConstraintValidator<OneOf, Object> {

    private String[] fields;

    @Override
    public void initialize(OneOf annotation) {
        this.fields = annotation.value();
    }

    @Override
    public boolean isValid(Object value, ConstraintValidatorContext context) {

        BeanWrapper wrapper = PropertyAccessorFactory.forBeanPropertyAccess(value);

        int matches = countNumberOfMatches(wrapper);

        if (matches > 1) {
            setValidationErrorMessage(context, "one.of.too.many.matches.message");
            return false;
        } else if (matches == 0) {
            setValidationErrorMessage(context, "one.of.no.matches.message");
            return false;
        }

        return true;
    }

    private int countNumberOfMatches(BeanWrapper wrapper) {
        int matches = 0;
        for (String field : fields) {
            Object value = wrapper.getPropertyValue(field);
            boolean isPresent = detectOptionalValue(value);

            if (value != null && isPresent) {
                matches++;
            }
        }
        return matches;
    }

    private boolean detectOptionalValue(Object value) {
        if (value instanceof Optional) {
            return ((Optional) value).isPresent();
        }
        return true;
    }

    private void setValidationErrorMessage(ConstraintValidatorContext context, String template) {
        context.disableDefaultConstraintViolation();
        context
            .buildConstraintViolationWithTemplate("{" + template + "}")
            .addConstraintViolation();
    }

}

Utilisation :

@OneOf({"stateType", "modeType"})
public class OneOfValidatorTestClass {

    private StateType stateType;

    private ModeType modeType;

}

Messages :

one.of.too.many.matches.message=Only one of the following fields can be specified: {value}
one.of.no.matches.message=Exactly one of the following fields must be specified: {value}

Answer 5

Une autre approche consisterait à créer un getter (protégé) qui renvoie un objet contenant tous les champs dépendants. Exemple :

public class MyBean {
  protected String status;
  protected String name;

  @StatusAndSomethingValidator
  protected StatusAndSomething getStatusAndName() {
    return new StatusAndSomething(status,name);
  }
}

StatusAndSomethingValidator peut désormais accéder à StatusAndSomething.status et StatusAndSomething.something et effectuer une vérification dépendante.