spring boot 之接口参数校验

本文由简悦 SimpRead 转码，原文地址 blog.csdn.net

引入`pom`依赖

<!--参数校验-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

统一返回结果封装

import lombok.Data;

import java.io.Serializable;

@Data
public class Result<T> implements Serializable {

    private Integer code;

    private String msg;

    private T data;

}

import lombok.Getter;

@Getter
public enum ResultEnum {

    SUCCESS(200, "请求成功"),

    FAIL(500, "请求失败");

    private final Integer code;

    private final String msg;

    ResultEnum(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

}

public class AjaxResult {
    
    public static <T> Result<T> success() {
        return common(ResultEnum.SUCCESS.getCode(), ResultEnum.SUCCESS.getMsg(), null);
    }

    public static <T> Result<T> success(T data) {
        return common(ResultEnum.SUCCESS.getCode(), ResultEnum.SUCCESS.getMsg(), data);
    }

    public static <T> Result<T> fail() {
        return common(ResultEnum.FAIL.getCode(), ResultEnum.FAIL.getMsg(), null);
    }

    public static <T> Result<T> fail(String msg) {
        return common(ResultEnum.FAIL.getCode(), msg, null);
    }

    /**
     * 公共响应方法
     */
    private static <T> Result<T> common(Integer code, String msg, T data) {
        Result<T> result = new Result<>();
        result.setCode(code);
        result.setMsg(msg);
        result.setData(data);
        return result;
    }
}

全局异常处理

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;

@Data
@Setter
@Getter
@EqualsAndHashCode(callSuper = true)
public class SelfException extends RuntimeException {

    private String message;

    public SelfException(String message) {
        this.message = message;
    }

    public SelfException(String message, Throwable e) {
        super(message);
        this.message = message;
    }

    @Override
    public String getMessage() {
        return message;
    }
}

import com.sun.result.AjaxResult;
import com.sun.result.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.validation.ConstraintViolationException;
import java.util.List;

@Slf4j
@ControllerAdvice
public class GlobalExceptionHandler {

    /**
     * 参数校验异常
     */
    @ExceptionHandler(ConstraintViolationException.class)
    @ResponseBody
    public Result<Object> error(Exception e) {
        log.error("参数校验异常:{}", e.getMessage());
        return AjaxResult.fail(e.getMessage());
    }

    /**
     * 参数校验异常
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseBody
    public Result<Object> error(MethodArgumentNotValidException e) {
        // 获取异常体
        BindingResult bindingResult = e.getBindingResult();
        // 从异常体中获取所有异常列表
        List<FieldError> errors = bindingResult.getFieldErrors();
        // 要返回的字符串,拼接的是参数名称以及对应的报错提示
        StringBuilder messageBuilder = new StringBuilder();
        String message = null;
        for (FieldError error : errors) {
            // 报错的参数
            String field = error.getField();
            // 报错的信息
            message = error.getDefaultMessage();
            // 拼接参数名称以及对应的报错提示
            messageBuilder.append(field).append("\t").append(message).append("\n");
        }
        log.error("参数校验异常详情:{}", messageBuilder);
        return AjaxResult.fail(message);
    }

    /**
     * 自定义异常
     */
    @ExceptionHandler(SelfException.class)
    @ResponseBody
    public Result<Object> error(SelfException e) {
        log.error("自定义异常:{}", e.getMessage());
        return AjaxResult.fail(e.getMessage());
    }

    /**
     * 空指针异常
     */
    @ExceptionHandler(NullPointerException.class)
    @ResponseBody
    public Result<Object> error(NullPointerException e) {
        log.error("空指针异常:{}", e.getMessage());
        return AjaxResult.fail("空指针异常");
    }

    /**
     * 拦截运行时异常
     */
    @ExceptionHandler(value = RuntimeException.class)
    @ResponseBody
    public Result<Object> runtimeExceptionHandle(RuntimeException e) {
        log.error("捕捉到运行时异常:{}", e.getMessage());
        return AjaxResult.fail("系统运行中异常");
    }

    /**
     * 兜底异常，捕获系统级异常
     */
    @ExceptionHandler(value = Throwable.class)
    @ResponseBody
    public Result<Object> throwableHandle(Throwable throwable) {
        log.error("捕获系统级异常:{}", throwable.getMessage());
        return AjaxResult.fail("系统程序异常");
    }

}

`@Valid`和`@Validated`的区别

参数验证使用到了两个关键注解，区分如下：

1、来源
@Validated：是Spring框架特有的注解，属于Spring的一部分，也是JSR 303的一个变种。它提供了一些 @Valid 所没有的额外功能，比如分组验证。
@Valid：Java EE提供的标准注解，它是JSR 303规范的一部分，主要用于Hibernate Validation等场景。

2、注解位置
@Validated：用在类、方法和方法参数上，但不能用于成员属性。
@Valid：可以用在方法、构造函数、方法参数和成员属性上。

3、分组
@Validated：支持分组验证，可以更细致地控制验证过程。此外，由于它是Spring专有的，因此可以更好地与Spring的其他功能（如Spring的依赖注入）集成。
@Valid：主要支持标准的Bean验证功能，不支持分组验证。

4、嵌套验证
@Validated：不支持嵌套验证。
@Valid：支持嵌套验证，可以嵌套验证对象内部的属性。

新建实体类与控制层

import lombok.Data;

import javax.validation.constraints.NotBlank;
import java.util.Date;

@Data
public class SysUser {

    private Integer id;

    @NotBlank(message = "姓名不得为空!")
    private String name;

}

// 个人理解 @Validated 和 @Valid 使用方法
// 如果控制层的接口中有test01这样传参是实体类的，在类前加@Valid或者@Validated注解，实体类标记的参数校验注解才会起作用；
// 如果接口参数是test02这样直接传参数的，要在控制层的类上加@Validated注解，参数前标记的参数校验注解才会起作用；
@Validated
@RestController
@RequestMapping(value = "sysUser", produces = "application/json; charset=utf-8")
public class SysUserController {

    @PostMapping("test01")
    public Result<SysUser> test01(@RequestBody @Valid SysUser sysUser) {
        return AjaxResult.success(sysUser);
    }

    @GetMapping("test02")
    public Result<String> test02(@RequestParam("name") @NotBlank(message = "姓名不得为空!") String name) {
        return AjaxResult.success("OK: " + name);
    }

}

接口访问测试

访问test01接口，返回如下：

{
    "code": 500,
    "msg": "姓名不得为空!",
    "data": null
}

访问test02接口，返回如下：

{
    "code": 500,
    "msg": "test2.name: 姓名不得为空!",
    "data": null
}

常用注解

@AssertFalse[必须为false]

@AssertFalse(message = "结果必须为false")
private boolean flag;

AssertTrue[必须为true]

@AssertTrue(message = "参数必须为true")
private boolean flag;

DecimalMax

数字，其值必须小于或等于指定的最大值；

支持的类型有：BigDecimal，BigInteger，CharSequence，byte，short，int，long以及他们的包装类。

@DecimalMax(value = "10", message = "参数age应该小于或等于10.")
private int age;

DecimalMin

数字，其值必须大于或等于指定的值

支持的类型有：BigDecimal，BigInteger，CharSequence，byte，short，int，long以及他们的包装类。

@DecimalMin(value = "10", message = "参数age应该大于或等于10.")
private int age;

Digits

整数位数不能超过 integer 位数，小数位数不能超过 fraction 位数

支持的类型有：BigDecimal，BigInteger，CharSequence，byte，short，int，long以及他们的包装类。

@Digits(integer = 1, fraction = 2, message = "整数位数不能超过1，小数位数不能超过2.")
private BigDecimal num;

Email

参数必须为email格式，如果参数为空，也会通过校验，所以如果参数为非空且必须为email格式时，需要与@NotNull结合使用。

适用于字符串类型的校验

@Email(message = "参数必须为email格式.")
@NotNull(message = "参数不能为null.")
private String email;

Future

参数必须为将来的日期或时间，适用于日期，时间等参数类型：java.util.Date、java.util.Calendar、java.time.LocalDate、java.time.LocalDateTime等等。

@Future(message = "日期参数必须为将来的时间.")
private Date time;

@Future(message = "任务时间参数必须为将来的时间.")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date time;

FutureOrPresent

参数必须为当前或将来的日期或时间

@FutureOrPresent(message = "任务时间参数必须为当前或将来的时间.")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date time;

Max

数值类型，值必面小于或等于一个值。

@Max(value = 99 , message = "年龄参数最大不能超过99.")
private int age;

Min
数值类型，值必面大于或等于一个值。

@Min(value = 18 , message = "年龄参数必须大于或等于18.")
private int age;

Negative
数值，参数校验必须为负数。

@Negative(message = "value必须为负数.")
private int num;

NegativeOrZero
数值，参数校验必须为负数或者 0。

@Negative(message = "value必须为负数.")
private int num;

NotBlank
参数为字符串，且不能为空，至少包含一个非空白字符串

@NotBlank(message = "value参数不能为空.")
private String num;

NotEmpty
参数为字符串，且不能为空，不能为空字符串，空白字符串可以通过校验。

@NotEmpty(message = "value参数不能为空，不能为空字符串.")
private String num;

NotNull
参数为任意类型，且不能为空。

@NotNull(message = "value参数不能为空.")
private String num;

Null
参数必须为Null

@Null(message = "value参数应该为空.")
private String num;

Past
时间参数需要一个过去的时间

@Past(message = "时间参数需要是过去的时间")
private Date num;

PastOrPresent
时间参数需要是过去的时间或当前的时间，而不是将来。

@PastOrPresent(message = "时间参数需要是过去的时间或当前的时间，而不是将来。")
private Date num;

Pattern
正则表达式参数校验，必须满足对应的正则表达式语法
比如电话号码校验

@Pattern(regexp = "^1([358][0-9]|4[579]|66|7[0135678]|9[89])[0-9]{8}$",message = "参数必须为电话号码!")
private String phoneNum;

Positive
数值校验，校验参数必须为正数。

@Positive(message = "参数必须为正数!")
private BigDecimal num;

PositiveOrZero
数值校验，校验参数必须为正数或者 0。

@PositiveOrZero(message = "参数必须为正数或者0!")
private BigDecimal num;

Size
字符数校验，最小min个字符，最大max字符，max可以省去，默认为Integer.MAX_VALUE

@Size(min = 5, max = 10,message = "参数需要最少五个字符，最大10个字符!")
private String num;

@Size(min = 5, message = "参数需要最少五个字符!")
private String num;

Length
org.hibernate.validator.constraints中的注解，有点类似Size注解
校验字符串长度是否在min和max之间

@Length(min = 5, max = 10, message = "参数需要最少五个字符,最大10个字符!")
private String num;

Range
范围校验，数值型适用

@Range(min = 60, max = 100, message = "Value值需要在60至100之间")
private int num;

Regexp正则

@Pattern(regexp = "^(agree|disagreeToModify|disagreeToEnd)$", message = "只能传agree、disagreeToModify、disagreeToEnd")
private String agree;

嵌套校验

嵌套校验（Nested Validation） ：指的是在验证对象时，对对象内部包含的其他对象进行递归验证的过程。当一个对象中包含另一个对象作为属性，并且需要对这个被包含的对象也进行验证时，就需要进行嵌套校验。

嵌套属性：指的是在一个对象中包含另一个对象作为其属性的情况。换句话说，当一个对象的属性本身又是一个对象，那么这些被包含的对象就可以称为嵌套属性。

其实就是在当前实体类中的某个属性，是另一个实体类，两个实体类一起校验。

import lombok.Data;

import javax.validation.constraints.NotBlank;
import java.util.Date;

@Data
public class SysUser {

    private Integer id;

    @NotBlank(message = "姓名不得为空!")
    private String name;
    
    // 嵌套校验
    @NotNull(message = "jobDetail不能为空")
    // 必加注解，否则JobDetail类中的参数校验注解不生效
    @Valid
    private JobDetail jobDetail;

}

分组校验

分组验证是为了在不同的验证场景下能够对对象的属性进行灵活地验证，从而提高验证的精细度和适用性。一般我们在对同一个对象进行保存或修改时，会使用同一个类作为入参。那么在创建时，就不需要校验 id，更新时则需要校验用户 id，这个时候就需要用到分组校验了。

对于定义分组有两点要特别注意：

定义分组必须使用接口。
要校验字段上必须加上分组，分组只对指定分组生效，不加分组不校验。

创建分组

// CreationGroup 用于创建时指定的分组：

public interface CreationGroup {
}

// UpdateGroup 用于更新时指定的分组：

public interface UpdateGroup {
}

用户类

import lombok.Data;

import javax.validation.constraints.NotBlank;
import java.util.Date;

@Data
public class SysUser {

    @Min(value  = 1, message = "id不能小于1", groups = {UpdateGroup.class})
    private Integer id;

    @NotEmpty(message = "姓名不得为空!" , groups = {CreationGroup.class})
    private String name;

}

创建接口

@RestController
@RequestMapping("sysUser")
public class SysUserController {

    @GetMapping("updateUser")
    public UserBean updateUser(@Validated({UpdateGroup.class}) SysUser sysUser){
        return sysUser;
    }

    @GetMapping("createUser")
    public UserBean createUser(@Validated({CreationGroup.class})  SysUser sysUser){
        return sysUser;
    }
}

测试

1、先对 createUser接口进行测试，我们将 id 的值设置为 0，也就是不满足 id 必须大于 0 的条件，同样username不传值，即不满足 username 不能为空的条件。

{
    "code": 500,
    "msg": "姓名不得为空!",
    "data": null
}

2、再对 updateUser接口进行测试，条件和测试 createUser接口的条件一样，再看测试结果，和 createUser接口测试结果完全相反，只提示了 id 最小不能小于 1。

{
    "code": 500,
    "msg": "id不能小于1",
    "data": null
}

引入`pom`依赖

统一返回结果封装

全局异常处理

`@Valid`和`@Validated`的区别

新建实体类与控制层

接口访问测试

常用注解

嵌套校验

分组校验

万字：支付“核心系统”详解 2024-11-02 15:33

资深支付架构师视角：实战从问题定义到代码落地的完整套路 2024-11-02 15:33

Spring 实现 3 种异步接口 2024-10-18 09:07

重学SpringBoot3-集成Redis（五）之布隆过滤器 2024-10-08 11:24

设计模式第16讲——迭代器模式（Iterator） 2024-10-08 11:24

vue2路由和vue3路由区别及原理 2024-10-08 11:24

目录

spring boot 之 接口参数校验

引入pom依赖

统一返回结果封装

全局异常处理

@Valid和@Validated的区别

新建实体类与控制层

接口访问测试

常用注解

嵌套校验

分组校验

万字：支付“核心系统”详解 2024-11-02 15:33

资深支付架构师视角：实战从问题定义到代码落地的完整套路 2024-11-02 15:33

Spring 实现 3 种异步接口 2024-10-18 09:07

重学SpringBoot3-集成Redis（五）之布隆过滤器 2024-10-08 11:24

设计模式第16讲——迭代器模式（Iterator） 2024-10-08 11:24

vue2路由和vue3路由区别及原理 2024-10-08 11:24

目录

spring boot 之接口参数校验

引入`pom`依赖

`@Valid`和`@Validated`的区别