springboot-参数校验

SpringBoot 中使用 @Valid 注解 + Exception 全局处理器优雅处理参数验证

  • 注解@Valid的主要作用是用于数据效验,可以在定义的实体中的属性上,添加不同的注解来完成不同的校验规则。
  • Controller类中在参数中添加@Valid注解来开启效验功能
  • @Valid配合 Spring 会抛出MethodArgumentNotValidException异常,可结合全局异常处理类处理。

示例

1. 实体类中添加 @Valid 相关注解

@Data
public class User {
    @NotBlank(message = "姓名不为空")
    private String username;
    @NotBlank(message = "密码不为空")
    private String password;

    //嵌套必须加 @Valid,否则嵌套中的验证不生效
    @Valid
    @NotNull(message = "用户信息不能为空")
    private UserInfo userInfo;
}

如果是嵌套的实体对象,则需要在最外层属性上添加@Valid注解。

@Data
public class UserInfo {
    @NotBlank(message = "年龄不为空")
    @Max(value = 18, message = "不能超过18岁")
    private String age;

    @NotBlank(message = "性别不能为空")
    private String gender;
}

2. 接口类中添加 @Valid 注解
Controller类中添加接口,POST方法中接收设置了@Valid相关注解的实体对象,然后在参数中添加@Valid注解来开启效验功能。

@RestController
public class HelloController {
    ...

    @PostMapping(path = "/hello4")
    public String hello4(@Valid @RequestBody User user)  {
        System.out.println(user);
        return "hello spring boot";
    }
}

3. 全局异常处理类中处理 @Valid 抛出的异常

参数控制返回异常信息很多,可以结合一个全局异常处理类,然后对接口中抛出的异常进行处理,而@Valid配合 Spring 会抛出 MethodArgumentNotValidException异常,这里我们需要对该异常进行处理即可。

@RestControllerAdvice("org.example")        //指定异常处理的包名
public class GlobalExceptionHandler {

    @ResponseStatus(HttpStatus.BAD_REQUEST) //设置状态码为 400
    @ExceptionHandler({MethodArgumentNotValidException.class})
    public String paramExceptionHandler(MethodArgumentNotValidException e) {
        // 获取异常信息 BindingResult
        BindingResult exceptions = e.getBindingResult();
        // 判断异常中是否有错误信息,如果存在就使用异常中的消息,否则使用默认消息
        if (exceptions.hasErrors()) {
            List<ObjectError> allErrors = exceptions.getAllErrors();
            if (allErrors.size() > 0) {
                // 这里列出了全部错误参数,按正常逻辑,只需要第一条错误即可
                ObjectError objectError = allErrors.get(0);
                return objectError.getDefaultMessage();
            }
        }
        return "请求参数错误";
    }
}

4. 测试

1、访问 http://192.168.1.166:8080/hello4 ,请求参数:

{“username”:“”,“password”:“222”}
springboot-参数校验_第1张图片

2、访问 http://192.168.1.166:8080/hello4 ,请求参数:

{“username”:“111”,“password”:“222”}

springboot-参数校验_第2张图片

3、访问 http://192.168.1.166:8080/hello4 ,请求参数:

{“username”:“111”,“password”:“222”,“userInfo”:{“age”:“19”}}

springboot-参数校验_第3张图片

4、访问 http://192.168.1.166:8080/hello4 ,请求参数:

{“username”:“111”,“password”:“222”,“userInfo”:{“age”:“18”,“gender”:“M”}}

springboot-参数校验_第4张图片

正常访问,后台打印 User(username=111, password=222, userInfo=UserInfo(age=18, gender=M))

springboot-参数校验_第5张图片

@Valid和@Validated的区分

  • @Validated@Valid的一次封装,是 Spring 提供的校验机制使用。
@Validated @Valid
分组 提供分组功能,可在入参验证时,根据不同的分组采用不同的验证机制。 无分组功能
可注解位置 可以用在类型、方法和方法参数上。但是不能用在成员属性上 可以用在方法、构造函数、方法参数和成员属性上(两者是否能用于成员属性上直接影响能否提供嵌套验证的功能)
嵌套验证 无嵌套验证 用在成员属性上,提示验证框架进行嵌套验证。

为什么验证需要分组?

当一个实体类需要多种验证方式时,例:对于一个实体类的id来说,新增的时候是不需要的,对于更新时是必须的。可以通过groups对验证进行分组。

分组接口类(通过向groups分配不同类的 class 对象,达到分组目的):

public interface IGroupA {
}

示例

1. 定义分组接口

public interface IGroupA {
}

2. 实体类

@Data
public class User {
    //在 IGroupA 分组时,判断不能为空  
    @NotBlank(message = "姓名不为空", groups = {IGroupA.class})
    private String username;
    @NotBlank(message = "密码不为空")
    private String password;

    @Valid
    @NotNull(message = "用户信息不能为空")
    private UserInfo userInfo;
}

3. 接口类中添加 @Validated 注解

@RestController
public class HelloController {
    ...

    @PostMapping(path = "/add")
    //不需验证ID
    public String add(@Validated @RequestBody User user)  {
        System.out.println(user);
        return "hello spring boot";
    }

    @PostMapping(path = "/delete")
    //需要验证ID
    public String delete(@Validated({IGroupA.class}) @RequestBody User user)  {
        System.out.println(user);
        return "hello spring boot";
    }
}

4. 测试

add请求:
1、访问 http://192.168.1.166:8080/add,请求参数:

{“username”:“”,“password”:“222”,“userInfo”:{“age”:“18”,“gender”:“M”}}

springboot-参数校验_第6张图片

正常访问,后台打印,User(username=, password=222, userInfo=UserInfo(age=18, gender=M))

2、访问 http://192.168.1.166:8080/add,请求参数:

{“username”:“111”,“password”:“”,“userInfo”:{“age”:“18”,“gender”:“M”}}

springboot-参数校验_第7张图片

  • 结果可见,字段 username 分配groups=IGroupA,Controller类接口 add 访问参数不指定验证组@Validated @RequestBody User user时,就不会进行该字段的验证。其他没分配 groups 的字段,默认都要进行验证。

注:Controller类接口访问参数不指定验证组时,@Valid @RequestBody User user@Validated @RequestBody User user 效果一样。

delete请求:
1、访问 http://192.168.1.166:8080/delete,请求参数:

{“username”:“”,“password”:“222”,“userInfo”:{“age”:“18”,“gender”:“M”}}

springboot-参数校验_第8张图片

2、访问 http://192.168.1.166:8080/delete,请求参数:

{“username”:“111”,“password”:“”,“userInfo”:{“age”:“18”,“gender”:“M”}}

springboot-参数校验_第9张图片

正常访问,后台打印,User(username=111, password=, userInfo=UserInfo(age=18, gender=M))

  • 结果可见,Controller类接口 delete 访问参数指定验证组@Validated({IGroupA.class}) @RequestBody User user时,只会对字段 username 进行校验,但其他没有分配 IGroupA 组的字段,不会校验。

springboot-参数校验_第10张图片

正常访问,后台打印,User(username=111, password=, userInfo=null)

springboot-参数校验_第11张图片

spring注解之@Valid和@Validated的区分总结

组序列

思考:我们初衷是:新增的时候不需要校验;更新的时候校验,但其他字段也需要校验。

通过组序列 @GroupSequence 解决。

默认情况下,不同组别的约束验证是无序的,然而在某些情况下,约束验证的顺序却很重要。比如,某个组的验证比较耗时,CPU 和内存的使用率相对比较大,最优的选择是将其放在最后进行验证。因此,在进行组验证的时候尚需提供一种有序的验证方式,这就提出了组序列的概念。

在使用组序列验证的时候,如果序列前边的组验证失败,则后面的组将不再给予验证。 对一个参数需要多种验证方式时,也可通过分配不同的组达到目的。

1. 分组接口类 (通过@GroupSequence注解对组进行排序)

@GroupSequence({IGroupA.class, Default.class})
public interface IGroup {
}

Default.class会执行默认验证。

2. 接口类中使用分组 IGroup

@RestController
public class HelloController {
    ...

    @PostMapping(path = "/delete")
    //需要验证ID
    public String delete(@Validated({IGroup.class}) @RequestBody User user)  {
        System.out.println(user);
        return "hello spring boot";
    }
}

3. 测试

1、访问 http://192.168.1.166:8080/delete,请求参数:

{“username”:“”,“password”:“222”,“userInfo”:{“age”:“18”,“gender”:“M”}}

springboot-参数校验_第12张图片

2、访问 http://192.168.1.166:8080/delete,请求参数:

{“username”:“111”,“password”:“”,“userInfo”:{“age”:“18”,“gender”:“M”}}

springboot-参数校验_第13张图片

  • 结果可见,先会对字段 username 进行校验,再对其他没有分配 IGroupA 组的字段校验。

多字段顺序验证

1. 分组接口类

public interface IGroupB {
}
@GroupSequence({IGroupB.class, IGroupA.class, Default.class})
public interface IGroup {
}

新增分组IGroupB,修改分组IGroup的顺序。

2. 实体类

@Data
public class User {
    @NotBlank(message = "姓名不为空", groups = {IGroupA.class})
    private String username;

    @NotBlank(message = "密码不为空")
    @Size(min = 3, max = 8, message = "密码必须在3和8之间", groups = {IGroupB.class})
    private String password;

    @Valid
    @NotNull(message = "用户信息不能为空")
    private UserInfo userInfo;
}

增加对字段 password 的分组校验。

3. 测试

1、访问 http://192.168.1.166:8080/delete,请求参数:

{“username”:“”,“password”:“22”,“userInfo”:{“age”:“20”,“gender”:“M”}}

springboot-参数校验_第14张图片

  • 结果可见,先会对字段 password 进行校验,如果序列前边的组验证失败,则后面的组将不再给予验证。

2、访问 http://192.168.1.166:8080/delete,请求参数:

{“username”:“”,“password”:“222”,“userInfo”:{“age”:“20”,“gender”:“M”}}

springboot-参数校验_第15张图片

3、访问 http://192.168.1.166:8080/delete,请求参数:

{“username”:“11”,“password”:“222”,“userInfo”:{“age”:“20”,“gender”:“M”}}

springboot-参数校验_第16张图片

  • 结果可见,会按照分组 IGroup 设定的顺序IGroupB -> IGroupA -> Default进行验证。

你可能感兴趣的:(SpringBoot,spring,boot)