spring-boot-starter-validation的灵活使用

通常我们在使用spring的validation时，一般都是在controller层使用，这种使用方式也是我们在开发过程中最为普通的使用方式，这里就不做过多的介绍
但在我们开发的过程中，有可能也会把validation用在非controller层，参数的校验在各个方法中都有可能存在，但是我们又不想在方法内写很多的if ... else ...去做专门的参数检验，这个时候就可以把validation用起来
接下来只说一下我个人对validation在非controller层的基于注解的使用方式，非常实用也很省时，算是做个笔记

首先在pom中要引入spring的validation

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

分两种情况，一种是普通的Spring Bean（非接口实现类），别一种是接口实现类的Spring Bean，这两种情况下的使用方式有一种是完全相同的，先说完全相同的使用方式：

基于非接口类的SpringValidation的使用

需要注意的有几点：

该必须为Spring的Bean
在类上加上@Validated注解
在方法入参中，需要做参数检验的对象前加上@Valid注解（自定义的POJO类）
示例：

@Component
@Validated
public class ValidationDemo {
    
    public void methodA(@Valid UserBean userBean){
        System.out.println("methodA");
    }
}

// 其中UserBean:
public class UserBean {

    @NotNull(message = "主键不能为空")  // 没有申明groups的统统为Default这个分组
    @Range(min = 100, max = 999, message = "只允许{min}-{max}", groups = {MyGroup.class})
    private Integer id;

    @NotEmpty(message = "名称不能为空") // 没有申明groups的统统为Default这个分组
    @Length(max = 10, message = "名称不能超过10个长度", groups = {MyGroup.class})
    private String name;

    @NotNull(message = "类型不能为空", groups = {MyGroup.class})
    private TypeEnums typeEnums;
    
    getter and setter ...
}

这时候，如果UserBean.id或者UserBean.name为空都会触发ConstraintViolationException异常，说明在调用ValidationDemo.methodA时validation发挥了它的作用

    @Resource
    private ValidationDemo validationDemo;

    @GetMapping("/demo")
    public void demo(UserBean userBean){
        System.out.println("--------controller-------------");
        validationDemo.methodA(userBean);
    }

接下来说一下参数检验分组的使用，首先MyGroup类如下：

public interface MyGroup {
}

就是一个简单的接口类

如果我们想要ValidationDemo.methodA方法只校验MyGroup这个分组参数，那么就有两种方式(任选其一)：

在类上面的@Validated注解中指定校验的分组参数：

@Component
@Validated(value = {MyGroup.class})
public class ValidationDemo {

    public void methodA(@Valid UserBean userBean){
        System.out.println("methodA");
    }
}

在方法上添加@Validated注解，并指定校验的分组参数:

@Component
@Validated
public class ValidationDemo {

    @Validated(MyGroup.class)
    public void methodA(@Valid UserBean userBean){
        System.out.println("methodA");
    }
}

以上的两种方式都可以只校验UserBean中groups为MyGroup.class的规则，例如UserBean中里的：

@Range(min = 100, max = 999, message = "只允许{min}-{max}", groups = {MyGroup.class})
private Integer id;

@Length(max = 10, message = "名称不能超过10个长度", groups = {MyGroup.class})
private String name;

@NotNull(message = "类型不能为空", groups = {MyGroup.class})
private TypeEnums typeEnums;

在类的Validated注解中指定校验分组的话，那么该类的所有方法的入参只要有@Valid注解，那么都会去验证groups为MyGroup的校验规则
在方法上面添加Validated注解并指定校验规则，这种检验规则的配制更加灵活，控制颗粒更加小。这就得在大家实际的开发过程中去根据实际的情况选择使用
如果@Validated没有指定校验分组，它默认是使用groups为Default的校验规则，这个规则为我们在的POJO指定groups为Default或者没有申明groups的规则，默认是javax.validation.groups.Default.class

这里需要注意的就三点：类上必须添加@Validated注解，在方法需要做检验的参数前加@Valid注解，类必须为Spring Bean

基于接口类的SpringValidation的使用

这种使用方式和上面非接口类的使用只有一点不同，非接口类的注解都在方法上和入参中，而在接口类中，注解就在接口类的方法上和入参数中:

public interface ValidationService {

    @Validated(MyGroup.class)
    void validUserByImplement(@Valid UserBean userBean);

    @Validated({MyGroup.class,OtherGroup.class})
    void validUserByPrivate(@Valid  UserBean userBean, @Valid OtherBean otherBean);
}

然后其实现类:

@Service
@Validated
public class ValidationServiceImpl implements ValidationService {

    @Resource
    private ApplicationContext context;

    @Override
    public void validUserByImplement(UserBean userBean) {
        System.out.println("implements public ====> " + new Gson().toJson(userBean));
        UserBean a = new UserBean();
        a.setId(110);
        a.setName("er");
        
        ValidationService service = context.getBean(ValidationServiceImpl.class);

        OtherBean b = new OtherBean();
        b.setAge(20);
        b.setName("qwer");
        
        // 使用bean的方式调用，参数检验生效
        service.validUserByPrivate(a, b);
        
        // 以下这种方式调用，参数检验不会起作用
        this.validUserByPrivate(a, b);
    }

    @Override
    public void validUserByPrivate(UserBean userBean, OtherBean otherBean) {
        System.out.println("implements private ====> userBean: " + new Gson().toJson(userBean) + " otherBean: " + new Gson().toJson(otherBean));
    }
}

// otherBean
public class OtherBean {
    @NotEmpty(message = "名称不能为空")
    @Length(max = 10, message = "名称长度不能大于{max}", groups = OtherGroup.class)
    private String name;

    @NotNull(message = "年龄不能为空")
    @Range(min = 10, max = 200, message = "年龄范围为{min}到{max}", groups = OtherGroup.class)
    private Integer age;
    
    getter  and setter ...
}

// OtherGroup
public interface OtherGroup {
}

在实现类或者普通类中需要特别注意的一点是：如果方法内部调用，必须使用bean方式的调用，否则加的参数检验不会起作用
在方法上或者类上添加@Validated({MyGroup.class,OtherGroup.class})是可以使用多分组检验的，在我的示例中，userBean中只有MyGroup分组，在otherBean中，只有otherGroup分组，POJO可以混用分组

总结一下：

如果是接口实现类，必须要在实现类上加上@Validated，如果是普通类，也必须在类加上@Validated
需要检验的参数前必须加上@Valid，如果参数只是基本数据类型，可以使用诸如@NotNull、@NotEmpty、@Length等，可以指定groups，然后使用分组检验功能，例如: @NotNull(groups=MyGroup.class)、@NotEmpty（groups=OtherGroup.class) 、@Length(groups={MyGroup.class, OtherGroup.class}) ...
不管是接口实现类还是普通类，必须为Spring的Bean
方法内部调用，检验不会生效，那怕你在方法上加上@Validated且在需要校验的参数前加上@Valid也不行