收藏夹吃灰系列(七):解锁@Validated 神秘玩法，CTO对你直接另眼相看 | 文末附源码，强烈建议收藏!

灰太狼 2022-10-07 04:58 131阅读 0赞

**大家好，我是bug菌~~**

Hi ，小伙伴们，我们又见面啦，今天，我们来聊点什么咧？对了，前几天有个小学妹找我私聊了个关于校验后端参数的问题，大概意思就是“逻辑校验请求参数是否符合基本预期值时，每次都要自己做参数拦截校验(if...else一堆)，很繁琐很，笨重，问我在这一块优有没有更优雅的玩法可以借鉴学习？”，答案肯定是有的。

于是我今天就来给大家聊聊它，怎么在项目中使用Spring 自带的 @Validated、@Valid 等校验注解来替代手动对参数进行校验，文中还涉及这类校验注解的基本用法、高阶玩法及衍生用法，也包括知识拓展等。

可能很多小伙伴们都不太了解，为了让大家更加了解，bug菌今个儿给大家总结了以下内容，具有很好的教学价值，希望小伙伴们根据这篇文章可以有所收获，建议小伙伴们先收藏后阅读哦。

**小伙伴们如果觉得文章不错，点赞、收藏、评论，分享走一起呀，记得给bug菌来个一键三连~~**

好了，我们开始这期的正文吧。

![20210616142119761.gif][]

在开始教学之前，先照顾下还没接触过 Spring 提供的后台参数校验框架 及@Valid @Validated 等注解使用 的小伙伴们，至于学过的朋友们就请再温故一遍吧！所谓"*温故而知新，可以为师矣。   --《[论语][Link 1]》*"

>        验证用户输入是否正确是我们应用程序中的常见功能。Spring提供了`@Valid`和@`Validated`两个注解来实现验证功能，下面我们先来详细介绍一下它两。

### **@Valid：** ###

1、概念：

>         @Valid是JSR303声明的，其中JSR303是JAVA EE 6 中的一项子规范，叫做 Bean Validation，为 JavaBean 验证定义了相应的元数据模型和 AP，Hibernate validation对其进行实现；

2、项目引入方式：所属包为：javax.validation.Valid

相关pom依赖：

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

3、作用范围：

@Validated作用在类、方法和参数上；

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Validated {
        Class<?>[] value() default {};
    }

### 二者区别： ###

>        在检验Controller的入参是否符合规范时，使用@Validated或者@Valid在基本验证功能上没有太多区别。但是在分组、注解地方、嵌套验证等功能上两个有所不同：如下

1、注解位置：

*  @Validated：用在类型、方法和方法参数上。但不能用于成员属性（field）。
 *  @Valid：可以用在方法、构造函数、方法参数和成员属性（field）上。

2、分组：

*  @Validated：提供分组功能，可以在入参验证时，根据不同的分组采用不同的验证机制。
 *  @Valid：作为标准JSR-303规范，没有分组功能。

3. 嵌套验证：

>        一个待验证的pojo类，其中还包含了待验证的对象，需要在待验证对象上注解@valid，才能验证待验证对象中的成员属性。

*  @Validated： 用在方法入参上无法单独提供嵌套验证功能，不能用在成员属性（字段）上，也无法提示框架进行嵌套验证。能配合嵌套验证注解@Valid进行嵌套验证。
 *  @Valid： 用在方法入参上无法单独提供嵌套验证功能。能够用在成员属性（字段）上，提示验证框架进行嵌套验证。能配合嵌套验证注解@Valid进行嵌套验证。

--------------------

顺便给大家科普下 @Target 设定注解的不同使用范围；

@Target 共以下八种使用范围：

@Target:注解的作用目标
    　　　　　　　　@Target(ElementType.TYPE)   //接口、类、枚举
    　　　　　　　　@Target(ElementType.FIELD) //字段、枚举的常量
    　　　　　　　　@Target(ElementType.METHOD) //方法
    　　　　　　　　@Target(ElementType.PARAMETER) //方法参数
    　　　　　　　　@Target(ElementType.CONSTRUCTOR)  //构造函数
    　　　　　　　　@Target(ElementType.LOCAL_VARIABLE)//局部变量
    　　　　　　　　@Target(ElementType.ANNOTATION_TYPE)//注解
    　　　　　　　　@Target(ElementType.PACKAGE) ///包

--------------------

>        以上纯属就给大家伙儿温习了一遍概念，想必大家已经对Spring提供的验证框架也有了一定的了解了吧，如果还不清楚，建议反复看几遍...那么接下来，bug菌就要开始今天的核心内容了，先从使用认识注解开始学起，好好看好好学~可千万别走神啊。
> 
>        保证句句是重点！！！

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70][]

>         首先Spring中bean validation由自身的校验和部分hibernate的校验组成；javax.validation.constraints包下校验注解有如下几大种类，比如空和非空校验、Boolean值校验等，具体看下表，梳理的很详细，文字就不做过多描述了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 1][]

>         想必大家肯定对有些注解并不陌生，甚至会经常出现在实体类中，比如@NotNull、@NotBlank、@NotEmpty等，对吧；但是也只是大家用来做参数校验，其实还隐藏更高阶玩法，有待大家解锁，今天bug菌就要不余余力的给大家爆料，带着大家玩透它！
> 
>         核心文依次分四场景带着大家由浅入深式的体验，相信你们在通读完此文后，保证大家一定会有所收获！不信咱接着往下学~
> 
> ![20210616163216625.jpg][]

### 场景一： ###

>         试问：前端传过来的字段如何通过某些注解在后台做校验？最笨的方法就是通过if else判断校验，你若看了我今天教的，你就会觉得以前写的是多么的low，而且非常笨重、不灵活。如果前端传来100个字段你还用if else 做判断吗？不得累死。
> 
>        接下来的 第一个场景 演示的就是在后台创建的实体和前端传来的字段做对应映射，加上JSR303注解来做灵活校验，减轻代码量。

第一步：先给Bean实体添加校验注解:javax.validation.constraints(大部分注解都在这个包下)，并定义自己的message提示，如下：

具体示列 entity类：

@ApiModelProperty(value = "id自增列")
    	@TableId(value = "id", type = IdType.AUTO)
    	private Integer id;
      
        @NotBlank(message = "用户名称不能为空")
    	@ApiModelProperty(value = "用户名称")
    	private String userName;
    
    	@Min(value = 1,message = "输入年龄不能小于1")
    	@Max(value = 150,message = "输入年龄不能超过150")
    	@NotNull(message = "输入年龄不能为空")
    	@ApiModelProperty(value = "密码")
    	private Integer userAge;
    
    	@NotBlank(message = "密码不能为空")
    	@Length(min = 6, max = 10,message = "密码⻓度⾄少6位但不超过10位!", groups = {UpdateGroup.class, AddGroup.class})
    	@ApiModelProperty(value = "密码")
    	private String userPwd;
    
        @Email(message = "邮箱格式不正确")
    	@ApiModelProperty(value = "邮箱")
    	private String email;

第二步：开启校验功能使用@Validated，可能这时候你就会问了为何不选用@Valid呢，其实@Valid也可以，但是不利于后面做扩展功能，所以就选用了@Validated 来做校验功能。

其实@Validated是在@Valid上又封装了一层，比如加上了分组功能，这个分组详细说，目前就先不透露啦；

使用效果：校验错误以后会有默认的响应，在给校验的bean后紧跟一个BindingResult，就可以获取到校验的结果；

示例 Controller：

@PostMapping(value = "/saveUser")
    	@ApiOperation(value = "用户添加", notes = "用户添加")
    	public ResultResponse saveUser(@Validated(AddGroup.class) UserEntity userEntity, BindingResult bindingResult) {
    		/**
    		 * result.hasErrors()如果前端传来的值和在实体类标注的注解不对应就返回false。
    		 * 比如在实体在name字段标注了@NotBlank(message = "用户名称不能为空")而前端没传name就返回了false;
    		 */
    		if (bindingResult.hasErrors()) {
    			Map<String, String> map = new HashMap<>();
    			//1、result.getFieldErrors()获取校验的错误结果对象然后遍历
    			for (FieldError fieldError : bindingResult.getFieldErrors()) {
    				//FieldError 获取到错误提示
    				String message = fieldError.getDefaultMessage();
    				//获取错误的属性的名字
    				String field = fieldError.getField();
    				map.put(field, message);
    			}
    			return new ResultResponse<>(map);
    		}
    		return new ResultResponse<>(testService.save(userEntity));
    	}

效果演示1:请求用户新增接口，什么参数都不传，检验是否能有返回参数校验错误信息：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 2][]效果演示2:请求用户新增接口，传密码参数，且传的值故意令长度不符合验证要求，别的参数就不一 一测试校验了，都是一样的用法，只要是不符合参数校验都会返回你所设定的message内容：

> @Length(min = 6, max = 10,message = "密码⻓度⾄少6位但不超过10位!")
> 
> 解读：表示该userPwd 密码长度设定在6-10之间，密码长度低于6位或者高于10位都会有message提示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 3][]

效果演示3:请求用户新增接口，测试@Email 注解使用，检验是否能有返回参数校验错误信息。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 4][]

效果演示4:请求用户新增接口，全部参数都按要求传，检验是否能新增成功。

结果如下，自己看：

### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 5][] ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 6][]

### 场景二： ###

>         结合一场景，我们已经知道了如何校验参数并捕获错误信息，然后返回给前端，但接下来我想反问大家一个问题， 如果按照这样的写法就得在每个方法都写判断和捕获参数消息遍历的代码，对吧，难道一百个接口就写一百次捕获错误参数代码段？母庸质疑这肯定是不行，冗余代码太多，难以维护，那怎么办？接下来我就来说说bug菌是怎么想的；
> 
>         可能很多小伙伴顺着我的思路就已经想到了全局异常捕获，全局异常捕获完全可以做。但是今天我不这么玩，我教大家一个别致的玩法，比如aop，什么意思呢，就是**自定义一个异常切面**去捕获每次  BindingResult 所抛出的异常信息，由于aop是先于全局异常执行顺序，只需在切片中返回具体参数检验结果即可，其实跟定义全局异常捕获一个道理；
> 
>        你们看我下面写的代码！很直观一眼就懂。

@Order(10)
       @Around("execution(public * com.system.xiaoma.controller.*.*(..))")
       public ResultResponse validAspect1(ProceedingJoinPoint pjp) throws Throwable {
          BindingResult bindingResult = getBindingResult(pjp);
          //表示正常返回
          if (bindingResult == null || !bindingResult.hasErrors()) {
             ResultResponse resultResponse = new ResultResponse();
             ResultResponse o = (ResultResponse) pjp.proceed(pjp.getArgs());
             resultResponse.setData(o.getData());
             return resultResponse;
          } else {
            //捕捉异常，将异常封装到map返回
             Map<String, String> map = new HashMap<>();
             List<FieldError> errors = bindingResult.getFieldErrors();
             errors.forEach(e -> map.put(e.getField(),e.getDefaultMessage()));
             return new ResultResponse(map);
          }
       }
    
       /**
        * 获取接口中的BindingResult对象
        *
        * @param pjp 切入点
        */
       private BindingResult getBindingResult(ProceedingJoinPoint pjp) {
          Object[] args = pjp.getArgs();
          for (Object arg : args) {
             if (arg instanceof BindingResult) {
                return (BindingResult) arg;
             }
          }
          return null;
       }

如下是返回体实际效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 8][]

### 场景三: ###

>         以上两个场景我们已经解决了如何统一处理前端传来的字段校验和如何统一处理返回校验错误消息提示。
> 
>         接下再来假设一个场景： 比如我们添加一个用户存在userName，userAge，userPwd等些字段且必填，然后在实体类都加上了校验注解。
> 
>         马上，我们又有一个 只修改用户名称的接口。只根据用户id修改userName。前端只传你用户id和新改的用户名userName，可我们在实体先前就标注了很多校验注解，除了id userName之外，别的参数不传肯定会验空返回，那单独给开个接口来做重命名？或者单独封装个只接id跟userName的实体类？
> 
> 不不不，肯定是能复用就复用！要是像上面这么玩，cto不得被你气吐血咯~
> 
>         接下来我就来聊聊这个怎么解决这个问题吧，其实还是用@Validated，它有做分组功能。怎么理解呢？
> 
>         意思是在新增接口我们给新增标识的校验注解， 在修改接口使用修改标识的校验注解，这样就不会新增修改接口冲突(分组校验（多场景的复杂校验)）。如下：

第一步：先*为不同接口加上 *分组标志；

@NotNull(message = "用户id不能为空", groups = UpdateGroup.class)
    private Integer id;

这个UpdateGroup.class是干什么用的，其实就是我们自定义的一个标识用来告诉程序不同的接口校验不同的属性罢了；然后在新增接口上也同样加上 AddGroup.class 的分组标志，即可；

@PostMapping(value = "/update")
    	@ApiOperation(value = "用户修改", notes = "根据userId对用户信息修改")
    	public ResultResponse updateUser(@Validated(UpdateGroup.class) UserEntity userEntity, BindingResult bindingResult) {
    //		if (bindingResult.hasErrors()) {
    //			Map<String, String> map = new HashMap<>();
    //			//1、result.getFieldErrors()获取校验的错误结果对象然后遍历
    //			for (FieldError fieldError : bindingResult.getFieldErrors()) {
    //				//FieldError 获取到错误提示
    //				String message = fieldError.getDefaultMessage();
    //				//获取错误的属性的名字
    //				String field = fieldError.getField();
    //				map.put(field, message);
    //			}
    //			return new ResultResponse<>(map);
    //		}
    		return new ResultResponse<>(testService.updateById(userEntity));
    	}

如下定义分组标识:

//新增标识

public @interface AddGroup {
    }

//修改标识

public @interface UpdateGroup {
    }

//查询标识

public @interface QueryGroup {
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 9][]

效果演示1:请求用户新增接口，先不传id，验证是否会提示要求传id

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 10][]

效果演示2:请求用户修改接口，也不传id，验证是否会提示要求传id

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 11][]

效果演示3：请求用户修改接口:传id，看结果，验证是否会有必传参数提示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 12][]

> 有朋友可能就会问了，要是既UpdateGroup标识，也AddGroup 分组标识的，怎么理解？
> 
> 像这种情景，就表示无论是新增操作还是修改操作都会校验该属性，如下：email就新增还是修改操作都会对其进行参数校验，校验是否满足邮箱格式。

@Email(message = "邮箱格式不正确", groups = {UpdateGroup.class, AddGroup.class})
    @ApiModelProperty(value = "邮箱")
    private String email;

> 如果只加上修改标识不加新增标识的话，这个就只会在修改操作时会触发校验该属性。

@NotNull(message = "用户id不能为空", groups = UpdateGroup.class)
    @ApiModelProperty(value = "id自增列")
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 13][]

### 场景四： ###

>        终于讲到第四大场景了，给大家假设这么一个场景，就一个实体中，存在嵌套类，举个栗子，如下，可以看到Company对象中含有User对象做为自己的属性，那么在进行Company校验时，user内的属性会被校验吗？如果不会又该怎么做才会进行嵌套类校验呢？大家想过没有？ 
> 
> 科普一下：嵌套类就是一个类中包含另一个类！

@NotNull(message = "用户对象不能为空", groups = {UpdateGroup.class})
        //注解加载bean属性上，表示当前属性不是数据库的字段，但在项目中必须使用，这样在新增等使用bean的时候，mybatis-plus就会忽略这个，不会报错;
    	@TableField(exist = false)
    	private UserEntity userEntity;

> 就不给大家卖关子了，很简单，只需要用到@Validated 的嵌套验证即可；
> 
> 如下图Company类中只能校验UserEntity是否为空，却不能校验UserEntity类中的userName、userPwd等属性是否为空；
> 
> 如果想要嵌套验证，必须在Company对象的UserEntity字段上面标明这个字段的实体也要进行验证！

> 由于@Validated不能用在成员属性（字段）上，但是@Valid能加在成员属性（字段）上，而且@Valid类注解上也说明了它支持嵌套验证功能；
> 
> 那么我们能够推断出：@Valid 加在方法参数时并不能够自动进行嵌套验证，而是用在需要嵌套验证类的相应字段上，来配合方法参数上@Validated或@Valid来进行嵌套验证；

在该需要做嵌套校验的属性上加@Valid 注解即可； 如下：

@Valid
    @NotNull(message = "用户对象不能为空", groups = {UpdateGroup.class})
    @TableField(exist = false)
    private UserEntity userEntity;

@PostMapping(value = "/updateCompanyInfo")
    @ApiOperation(value = "公司修改", notes = "公司信息修改")
    public ResultResponse updateCompanyInfo(@Validated(UpdateGroup.class) Company company, BindingResult bindingResult) {
       return new ResultResponse<>(iCompanyService.updateById(company));
    }

效果演示1:请求公司信息修改接口，不传参数userEntity，验证是否会提示嵌套类里头的属性为空。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 14][]

效果演示2:还是请求公司信息修改接口，但传参数userEntity对象，验证是否会提示嵌套类里头的属性为空。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 15][]

如上截图结果，显然校验出了userEntity对象中的必传属性，表示 @Valid 确实可以实现嵌套类的验证！是不是就很nice~

--------------------

> **OK，以上就是本期的所有干货内容啦！听完我的课，是不是该有所表示呢，要是我，果断就给它pia的一下点亮！**
> 
> **再不行，就当支持bug菌熬夜爆肝码了两万多字的份上，给个鼓励啦。**
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 16][]
> 
> 原创不易
> 
> 请鼓励支持一下咯
> 
> 点赞三连
> 
> 走起
> 
> 各位兄弟姐妹萌
> 
> bug菌不胜感激
> 
> ~
> 
> ~~~
> 
> ![20210618144631110.png][]

*** 若是还不够吃，bug菌还有！要不再投点？***

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 17][]

--------------------

###  往期热文推荐： ###

*  [在Ubuntu上使用IDEA搞开发是种什么体验？没想到竟是...最后有惊喜! ][Ubuntu_IDEA_...]
 *  [520夜我花了288大洋就得到了小师妹青睐，原因竟是...一定要看到最后！][520_288_...]  
 *  [你一定没用过的代码生成工具，好不好用你们说了算][Link 2]
 *  [如何实现Springboot项目保存本地系统日志文件，超详细，你值得拥有！ ][Springboot]
 *  [使用MultipartFile实现图片指定路径上传下载并使用postman测试教程 | 附完整源码，强烈建议收藏！][MultipartFile_postman_ _]
 *  [一篇文带你零基础玩转mysql触发器 | 超级干货，建议收藏][mysql_ _]
 *  **...**

若想解锁更多高阶隐藏玩法，请关注bug菌的专栏《[收藏夹吃灰系列][Link 3]》。bug菌会持续更新哒，只因你的特别关注，我定不负所望~

--------------------

###  附上述所例源码： ###

Company

package com.system.xiaoma.entity;
    
    import com.baomidou.mybatisplus.annotation.IdType;
    import com.baomidou.mybatisplus.annotation.TableField;
    import com.baomidou.mybatisplus.annotation.TableId;
    import com.system.xiaoma.model.groups.AddGroup;
    import com.system.xiaoma.model.groups.UpdateGroup;
    import io.swagger.annotations.ApiModel;
    import io.swagger.annotations.ApiModelProperty;
    
    import javax.validation.Valid;
    import javax.validation.constraints.NotBlank;
    import javax.validation.constraints.NotNull;
    
    /**
     * 公司信息
     */
    @ApiModel(value = "公司信息", description = "公司信息")
    @Data
    public class Company extends BaseEntity {
    
    	private static final long serialVersionUID = 1L;
    
    	@NotNull(message = "公司id不能为空", groups = UpdateGroup.class)
    	@ApiModelProperty(value = "公司id 自增列")
    	@TableId(value = "company_id", type = IdType.AUTO)
    	private Integer companyId;
    
    	@NotBlank(message = "公司名称不能为空", groups = {UpdateGroup.class, AddGroup.class})
    	@ApiModelProperty(value = "公司名称")
    	private String companyName;
    
    	@Valid
    	@NotNull(message = "用户对象不能为空", groups = {UpdateGroup.class})
        //注解加载bean属性上，表示当前属性不是数据库的字段，但在项目中必须使用，这样在新增等使用bean的时候，mybatis-plus就会忽略这个，不会报错;
    	@TableField(exist = false)
    	private UserEntity userEntity;
    }

UserEntity

package com.system.xiaoma.entity;
    
    import com.baomidou.mybatisplus.annotation.IdType;
    import com.baomidou.mybatisplus.annotation.TableId;
    import com.baomidou.mybatisplus.annotation.TableName;
    import com.system.xiaoma.model.groups.AddGroup;
    import com.system.xiaoma.model.groups.UpdateGroup;
    import io.swagger.annotations.ApiModel;
    import io.swagger.annotations.ApiModelProperty;
    import org.hibernate.validator.constraints.Length;
    
    import javax.validation.constraints.*;
    
    /**
     * @Author luoYong
     * @Date 2021-06-13 11:13
     */
    @TableName(value = "user")
    @ApiModel(value = "用户对象", description = "用户对象")
    @Data
    public class UserEntity extends BaseEntity {
    	private static final long serialVersionUID = 1L;
    
    	@NotNull(message = "用户id不能为空", groups = UpdateGroup.class)
    	@ApiModelProperty(value = "id自增列")
    	@TableId(value = "id", type = IdType.AUTO)
    	private Integer id;
    
    	@NotBlank(message = "用户名称不能为空", groups = {UpdateGroup.class, AddGroup.class})
    	@ApiModelProperty(value = "用户名称")
    	private String userName;
    
    	@Min(value = 1,message = "输入年龄不能小于1", groups = {UpdateGroup.class, AddGroup.class})
    	@Max(value = 150,message = "输入年龄不能超过150", groups = {UpdateGroup.class, AddGroup.class})
    	@NotNull(message = "输入年龄不能为空", groups = {UpdateGroup.class, AddGroup.class})
    	@ApiModelProperty(value = "密码")
    	private Integer userAge;
    
    	@NotBlank(message = "密码不能为空", groups = {UpdateGroup.class, AddGroup.class})
    	@Length(min = 6, max = 10,message = "密码⻓度⾄少6位但不超过10位!", groups = {UpdateGroup.class, AddGroup.class})
    	@ApiModelProperty(value = "密码")
    	private String userPwd;
    
    	@Email(message = "邮箱格式不正确", groups = {UpdateGroup.class, AddGroup.class})
    	@ApiModelProperty(value = "邮箱")
    	private String email;
    }

TestController

package com.system.xiaoma.controller;
    
    import com.system.xiaoma.entity.Company;
    import com.system.xiaoma.entity.UserEntity;
    import com.system.xiaoma.model.groups.AddGroup;
    import com.system.xiaoma.model.groups.UpdateGroup;
    import com.system.xiaoma.service.ICompanyService;
    import com.system.xiaoma.service.TestService;
    import com.system.xiaoma.vo.ResultResponse;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.validation.BindingResult;
    import org.springframework.validation.FieldError;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @Author luoYong
     * @Date 2021-06-13 11:12
     */
    @RestController
    @Api(tags = "测试")
    @RequestMapping("/test")
    public class TestController {
    	@Autowired
    	private TestService testService;
    	@Autowired
    	private ICompanyService iCompanyService;
    
    	@PostMapping(value = "/saveUser")
    	@ApiOperation(value = "用户添加", notes = "用户添加")
    	public ResultResponse saveUser(@Validated(AddGroup.class) UserEntity userEntity, BindingResult bindingResult) {
    		/**
    		 * result.hasErrors()如果前端传来的值和在实体类标注的注解不对应就返回false。
    		 * 比如在实体在name字段标注了@NotBlank(message = "用户名称不能为空")而前端没传name就返回了false;
    		 */
    		if (bindingResult.hasErrors()) {
    			Map<String, String> map = new HashMap<>();
    			//1、result.getFieldErrors()获取校验的错误结果对象然后遍历
    			for (FieldError fieldError : bindingResult.getFieldErrors()) {
    				//FieldError 获取到错误提示
    				String message = fieldError.getDefaultMessage();
    				//获取错误的属性的名字
    				String field = fieldError.getField();
    				map.put(field, message);
    			}
    			return new ResultResponse<>(map);
    		}
    		return new ResultResponse<>(testService.save(userEntity));
    	}
    
    	@PostMapping(value = "/update")
    	@ApiOperation(value = "用户修改", notes = "根据userId对用户信息修改")
    	public ResultResponse updateUser(@Validated(UpdateGroup.class) UserEntity userEntity, BindingResult bindingResult) {
    //		if (bindingResult.hasErrors()) {
    //			Map<String, String> map = new HashMap<>();
    //			//1、result.getFieldErrors()获取校验的错误结果对象然后遍历
    //			for (FieldError fieldError : bindingResult.getFieldErrors()) {
    //				//FieldError 获取到错误提示
    //				String message = fieldError.getDefaultMessage();
    //				//获取错误的属性的名字
    //				String field = fieldError.getField();
    //				map.put(field, message);
    //			}
    //			return new ResultResponse<>(map);
    //		}
    		return new ResultResponse<>(testService.updateById(userEntity));
    	}
    
    	@PostMapping(value = "/updateCompanyInfo")
    	@ApiOperation(value = "公司修改", notes = "公司信息修改")
    	public ResultResponse updateCompanyInfo(@Validated(UpdateGroup.class) Company company, BindingResult bindingResult) {
    //		if (bindingResult.hasErrors()) {
    //			Map<String, String> map = new HashMap<>();
    //			for (FieldError fieldError : bindingResult.getFieldErrors()) {
    //				//FieldError 获取到错误提示
    //				String message = fieldError.getDefaultMessage();
    //				//获取错误的属性的名字
    //				String field = fieldError.getField();
    //				map.put(field, message);
    //			}
    //			return new ResultResponse<>(map);
    //		}
    		return new ResultResponse<>(iCompanyService.updateById(company));
    	}
    
    }

ValidAspect

package com.system.xiaoma.aspect.valid;
    
    import com.fasterxml.jackson.core.JsonParser;
    import com.fasterxml.jackson.databind.DeserializationFeature;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;
    import com.system.xiaoma.exception.ParamsException;
    import com.system.xiaoma.vo.ResultResponse;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    import org.springframework.validation.BindException;
    import org.springframework.validation.BindingResult;
    import org.springframework.validation.FieldError;
    
    import javax.annotation.PostConstruct;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    
    /**
     * 校验切片
     */
    @Aspect
    @Component
    public class ValidAspect {
    
    	private ObjectMapper objectMapper = new ObjectMapper();
    
    	/**
    	 * 初始化json处理工具
    	 */
    	@PostConstruct
    	public void init() {
    		objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
    		objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
    		objectMapper.configure(JsonParser.Feature.IGNORE_UNDEFINED, true);
    		objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    		objectMapper.enable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    		objectMapper.enable(SerializationFeature.WRITE_ENUMS_USING_INDEX);
    	}
    
    	@Order(10)
    	@Around("execution(public * com.system.xiaoma.controller.*.*(..))")
    	public ResultResponse validAspect1(ProceedingJoinPoint pjp) throws Throwable {
    		BindingResult bindingResult = getBindingResult(pjp);
    		if (bindingResult == null || !bindingResult.hasErrors()) {
    			ResultResponse resultResponse = new ResultResponse();
    			ResultResponse o = (ResultResponse) pjp.proceed(pjp.getArgs());
    			resultResponse.setData(o.getData());
    			return resultResponse;
    		} else {
    			Map<String, String> map = new HashMap<>();
    			List<FieldError> errors = bindingResult.getFieldErrors();
    			errors.forEach(e -> map.put(e.getField(),e.getDefaultMessage()));
    			return new ResultResponse(map);
    		}
    	}
    
    	/**
    	 * 获取接口中的BindingResult对象
    	 *
    	 * @param pjp 切入点
    	 */
    	private BindingResult getBindingResult(ProceedingJoinPoint pjp) {
    		Object[] args = pjp.getArgs();
    		for (Object arg : args) {
    			if (arg instanceof BindingResult) {
    				return (BindingResult) arg;
    			}
    		}
    		return null;
    	}
    
    }

AddGroup

package com.system.xiaoma.model.groups;
    
    public @interface AddGroup {
    }

UpdateGroup

package com.system.xiaoma.model.groups;
    
    public @interface UpdateGroup {
    }

--------------------

![20210616160640975.gif][]

> ❤如果文章对您有所帮助，就请在文章末尾的左下角把大拇指点亮吧！(\#^.^\#)；
> 
> ❤如果喜欢bug菌分享的文章，就请给bug菌点个关注吧！(๑′ᴗ‵๑)づ╭❤～；
> 
> ❤对文章有任何问题欢迎小伙伴们下方留言或者入群探讨【群号：708072830】；
> 
> ❤鉴于个人经验有限，所有观点及技术研点，如有异议，请直接回复参与讨论(请勿发表攻击言论，谢谢）；
> 
> ❤版权声明：本文为博主原创文章，转载请附上原文出处链接和本文声明，版权所有，盗版必究！(\*^▽^\*).

[20210616142119761.gif]: /images/20221005/11c6154aba4749e8bec1eb7efe2e444f.png
[Link 1]: https://baike.baidu.com/item/%E8%AE%BA%E8%AF%AD/372830
[20210616163143605.jpg]: /images/20221005/3ddf62232c064a74bf482751f09c9a27.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70]: /images/20221005/608ad261bd814a0e9000fcc65d98e774.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 1]: /images/20221005/b9e306ff8c204586a1a5154985cf81a9.png
[20210616163216625.jpg]: /images/20221005/1a0162fff281409abd9db22a0b56711f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 2]: /images/20221005/466fbf0988b0400aaa6685c7f8ba20bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 3]: /images/20221005/dd8bdc6f0c61477fbb77a508f8cbd29a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 4]: /images/20221005/4cd5deeabad94b1585ef531fb77cc4c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 5]: /images/20221005/68cba9a31c214170b8d7348879bd6aba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 6]: /images/20221005/bf5954c3f28d4ee5ab437d679f8f96a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 7]: /images/20221005/0f3709b9adbc4913a56558369350b283.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 8]: /images/20221005/1e94373ecffe4d17aa97840d04e9e57c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 9]: /images/20221005/48d00f7b9c284819a97530977a406a82.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 10]: /images/20221005/8458019711e24c94a8a8d2e588e49c65.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 11]: /images/20221005/6a78289bd9a1468f999e6268352a04af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 12]: /images/20221005/030e57e3144c443fb3f6d2b54b114bfc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 13]: /images/20221005/686f3f4eb18b4e1a9d383b42eba36406.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 14]: /images/20221005/23752c3ed7464b889771c3e1e0ce0b0e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 15]: /images/20221005/ae1203c2cb8b4861a2f0388349be6da0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 16]: /images/20221005/e8de0d1c5bb549168c86705a5f71899c.png
[20210618144631110.png]: /images/20221005/4652698646aa4737917d1f46bf8eff5c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3MDc0Mw_size_16_color_FFFFFF_t_70 17]: /images/20221005/e4df04b194bd418e8eb83e6fdc0c85ab.png
[Ubuntu_IDEA_...]: https://luoyong.blog.csdn.net/article/details/117391693
[520_288_...]: https://luoyong.blog.csdn.net/article/details/117154803
[Link 2]: https://luoyong.blog.csdn.net/article/details/115917110
[Springboot]: https://luoyong.blog.csdn.net/article/details/115767763
[MultipartFile_postman_ _]: https://luoyong.blog.csdn.net/article/details/117932676
[mysql_ _]: https://luoyong.blog.csdn.net/article/details/117924855
[Link 3]: https://blog.csdn.net/weixin_43970743/category_11008709.html
[20210616160640975.gif]: /images/20221005/d26856dbff33411fb5ceaa27ea575438.png