4

在我们的应用程序中，我们有这样一个案例：

  • 应按特定顺序评估约束。（便宜到贵）
  • 在每个字段违规后不应评估约束。
  • 应验证所有字段。

对于前两个，groupsequence 非常适合。但是，对于我的第三个要求，我找不到解决方法。

public class AccountBean {

   @CheepValidation
   @ExpensiveValidation
   @VeryExpensiveValidation
   private String name;

   @CheepValidation
   @ExpensiveValidation
   @VeryExpensiveValidation
   private String surname
}

例如，

假设，对于名称字段 VeryExpensiveValidationconstraint 被违反，而对于姓氏字段 ExpensiveValidation 约束被违反。

对于这种情况，我应该显示：

对于字段名称：仅非常昂贵的验证错误消息对于字段姓氏：仅是昂贵的验证错误消息

请注意，对于字段 surname，我们没有评估 VeryExpensiveValidation 约束。

有没有办法用 JSR 303 来实现它？

谢谢

4

2 回答 2

3

您可以使用组和@GroupSequence，但它有点笨拙。

public class AccountBean {

   @CheapValidation(groups=Name1.class)
   @ExpensiveValidation(groups=Name2.class)
   @VeryExpensiveValidation(groups=Name3.class)
   String name;

   @CheapValidation(groups=Surname1.class)
   @ExpensiveValidation(groups=Surname2.class)
   @VeryExpensiveValidation(groups=Surname3.class)
   String surname;

   public interface Name1 {}
   public interface Name2 {}
   public interface Name3 {}
   @GroupSequence({Name1.class, Name2.class, Name3.class})
   public interface Name {}

   public interface Surname1 {}
   public interface Surname2 {}
   public interface Surname3 {}
   @GroupSequence({Surname1.class, Surname2.class, Surname3.class})
   public interface Surname {}
}

然后验证：

validator.validate(myAccountBean,
    AccountBean.Name.class, AccountBean.Surname.class)

关键是要有两个完全独立的组序列。

不幸的是，您似乎必须明确列出要验证的所有字段的组。我无法让它使用“默认”@GroupSequence。有人可以改进吗？

于 2011-04-20T14:46:29.960 回答
0

我已经使用 GroupSequence 实现了有序验证，但一般来说，GroupSequence bean 验证实现是不透明的。

意思是，在第一组完全验证之前，您不能触发第二组的验证。

例如

我有 3 个带有自定义验证器的验证字段。这个想法非常简单：每个字段都应该使用一组验证器从上到下独立验证（降序基数）。

        @StringPropertyNotNullOrEmptyConstraint(message = "Group name is required", groups = {ValidationStep1.class})        
        private final StringProperty groupName;    

        @StringPropertyNotNullOrEmptyConstraint(message = "Group password is required", groups = {ValidationStep1.class})
        @StringPropertyMatchConstraint(message = "The given password phrases do not match", dependentProperties = {"groupPasswordMatch"}, groups = {ValidationStep2.class})
        private final StringProperty groupPassword;      

        @StringPropertyNotNullOrEmptyConstraint(message = "Group password match is required", groups = {ValidationStep1.class})
        @StringPropertyMatchConstraint(message = "The given passwords phrases do not match", dependentProperties = {"groupPassword"}, groups = {ValidationStep2.class})    
        private final StringProperty groupPasswordMatch;


        public interface ValidationStep1 {    
        }

        public interface ValidationStep2 {    
        }

        @GroupSequence({GroupDialogModel.class, ValidationStep1.class, ValidationStep2.class})
        public interface GroupDialogModelValidationSequence {    
        }

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

        Set<ConstraintViolation<GroupDialogModel>> constraintViolations = validator.validate(this, GroupDialogModelValidationSequence.class);

这种方法的注意事项是每个字段都应该首先通过 ValidationStep1，只有在第 1 步的每次验证成功后才会进入第 2 步。例如，即使密码字段不是空的，而是包含不同的值，如果它们的验证成功，如果组名字段不包含任何值。只有在我为组名输入一些值后，ValidationStep1 组才成功，然后它显示 ValidationStep2 的验证结果（密码不匹配）。

恕我直言，为每个序列中的每个字段制作每个组是不好的做法，但似乎别无选择。

非常感谢任何其他解决方案。

于 2015-04-07T09:18:22.120 回答