核查的时候，其实就是怎么校验数据的正确还是错误，核查函数为静态类 MkValidators 内的所有静态函数

注意：
类MkValidators是版本 v1.4.5及之后改名的，之前为Checks

  1. /**
  2. * 核查对象
  3. */
  4. public boolean check(Object object){}
  5. /**
  6. * 核查对象的某些属性
  7. */
  8. public boolean check(Object object, String... fieldSet){}
  9. /**
  10. * 根据分组核查属性
  11. */
  12. public boolean check(String group, Object object) {}
  13. /**
  14. * 核查分组中的对象的某些属性
  15. */
  16. public boolean check(String group, Object object, String... fieldSet){}
  17. /**
  18. * 返回错误信息链
  19. */
  20. public String getErrMsgChain() {}
  21. /**
  22. * 获取最后设置错误信息
  23. */
  24. public String getErrMsg() {}
  26. /**
  27.  * 核查对象失败抛异常
  28.  */
  29. public void validate(Object object) throws MkException
  31. /**
  32.  * 核查对象指定属性失败抛异常
  33.  */
  34. public void validate(Object object, String ...fieldSet) throws MkException
  36. /**
  37.  * 根据组核查对象失败抛异常
  38.  */
  39. public void validate(String group, Object object) throws MkException
  41. /**
  42.  * 根据组核查对象指定属性失败抛异常
  43.  */
  44. public void validate(String group, Object object, String ...fieldSet) throws MkException

核查整个对象

那么会核查对象中的所有添加@Matcher注解（而且disable=false）的属性

核查某些属性

有些情况下，我们可能不是核查整个对象，而是可能核查某些属性，那么就可以使用核查某些属性的功能

  1. @Data
  2. @Accessors(chain = true)
  3. public class TestEntity {
  5.     @Matcher(value = {"nihao", "ok"}, accept = false)
  6.     private String name;
  7.     @Matcher(range = "[12, 32]")
  8.     private Integer age;
  9.     @Matcher({"beijing", "shanghai"})
  10.     private String address;
  11. }
  1. def "测试指定的属性age"() {
  2.     given:
  3.     TestEntity entity = new TestEntity().setName(name).setAge(age)
  5.     expect:
  6.     def act = MkValidators.check(entity, "age");
  7.     Assert.assertEquals(result, act)
  8.     if (!act) {
  9.         println MkValidators.errMsg
  10.     }
  12.     where:
  13.     name     | age | result
  14.     "nihao"  | 12  | true
  15.     "ok"     | 32  | true
  16.     "hehe"   | 20  | true
  17.     "haohao" | 40  | false
  18. }

核查某个组

对于一个属性，在不同的情况下，对这个属性值的要求可能不同，那么这个时候该怎么办呢，那么group属性就排上用场了

  1. @Data
  2. @Accessors(chain = true)
  3. public class GroupEntity {
  5.     @Matchers({
  6.         @Matcher(range = "[50, 100]", accept = false),
  7.         @Matcher(group = "test1", range = "[12, 23]", accept = false),
  8.         @Matcher(group = "test2", range = "[1, 10]", accept = false)
  9.     })
  10.     private Integer age;
  12.     @Matchers({
  13.         @Matcher(value = {"beijing", "shanghai", "guangzhou"}),
  14.         @Matcher(group = "test1", value = {"beijing", "shanghai"}),
  15.         @Matcher(group = "test2", value = {"shanghai", "hangzhou"})
  16.     })
  17.     private String name;
  18. }
  1. def "测试指定分组指定属性"() {
  2.     given:
  3.     GroupEntity entity = new GroupEntity().setAge(age).setName(name)
  5.     expect:
  6.     def act = MkValidators.check("test1", entity, "age");
  7.     Assert.assertEquals(result, act)
  8.     if (!act) {
  9.         println MkValidators.errMsgChain
  10.     }
  12.     where:
  13.     age | name        | result
  14.     10  | "shanghai"  | true
  15.     12  | "beijing"   | false
  16.     23  | "beijing"   | false
  17.     50  | "beijing"   | true
  18.     100 | "guangzhou" | true
  19. }