JSR303校验详解(基础校验,分组校验,自定义校验)结合全局异常处理捕获校验异常

文章目录

前言
0 学习准备工作
- 1 新建一个springboot项目
- 2 导入所用依赖
- 3 创建我们测试用的数据库(sql语句给出)
- 4 application.yml的配置文件
- 5 Mybatis-plus教程
1 基础JSR303校验
- 0 思路:
- 1 我们这里给TestEntity 实体类来加上注解
- 2 错误解决注解不生效问题
- 3 controller层开启校验功能
2 统一异常处理
3 JSR303分组校验
- 1 在 common包下创建一个vaild包
- 2 在实体类上定义组分类
- 3 在controller层上使用@vaildated(接口.class)开启分组校验(这时候如果实体类上没有指定组的校验将会失效)
4 JSR303 自定义校验注解
- 1 在自己对应实体类上编写自定义注解
- 2 编写注解接口
- 3 编写注解校验器ListValueConstraintValidator
- 4 controller层开启
总结

前言

这篇文章学习自尚硅谷
首先让我们来看看基本思路

 * 3、JSR303
 *   1）、给Bean添加校验注解:javax.validation.constraints，并定义自己的message提示
 *   2)、开启校验功能@Valid
 *      效果：校验错误以后会有默认的响应；
 *   3）、给校验的bean后紧跟一个BindingResult，就可以获取到校验的结果
 *   4）、分组校验（多场景的复杂校验）
 *         1)、	@NotBlank(message = "品牌名必须提交",groups = {AddGroup.class,UpdateGroup.class})
 *          给校验注解标注什么情况需要进行校验
 *         2）、@Validated({AddGroup.class})
 *         3)、默认没有指定分组的校验注解@NotBlank，在分组校验情况@Validated({AddGroup.class})下不生效，只会在@Validated生效；
 *
 *   5）、自定义校验
 *      1）、编写一个自定义的校验注解
 *      2）、编写一个自定义的校验器 ConstraintValidator
 *      3）、关联自定义的校验器和自定义的校验注解
         *      @Documented
         * @Constraint(validatedBy = { ListValueConstraintValidator.class【可以指定多个不同的校验器，适配不同类型的校验】 })
         * @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
         * @Retention(RUNTIME)
         * public @interface ListValue {
 *
 * 4、统一的异常处理
 * @ControllerAdvice
 *  1）、编写异常处理类，使用@ControllerAdvice。
 *  2）、使用@ExceptionHandler标注方法可以处理的异常。
 */

0 学习准备工作 1 新建一个springboot项目

直接从新建一个项目开始学习
这个你肯定会的

2 导入所用依赖

所用依赖给出

    

        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            mysql
            mysql-connector-java
            runtime
        

        
            org.projectlombok
            lombok
            true
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
        

        
        
            com.baomidou
            mybatis-plus-boot-starter
            3.2.0

3 创建我们测试用的数据库(sql语句给出)


SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for test
-- ----------------------------
DROP TABLE IF EXISTS `test`;
CREATE TABLE `test` (
  `id` int(10) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT '姓名',
  `email` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT '邮箱',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

-- ----------------------------
-- Records of test
-- ----------------------------
INSERT INTO `test` VALUES ('1', '孙悟空', '1');
INSERT INTO `test` VALUES ('2', '八戒', '2');
INSERT INTO `test` VALUES ('3', '唐僧', '3');

4 application.yml的配置文件

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/jsr303?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2B8
server:
  port: 8082
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

5 Mybatis-plus教程

可以简单看看我的这篇博客
Mybatis-plus快速上手

1 基础JSR303校验

我们先给后端加上简单的JSR303校验

0 思路:

JSR303基础校验
1）、给Bean添加校验注解:javax.validation.constraints，并定义自己的message提示
2)、开启校验功能@Valid

 效果：校验错误以后会有默认的响应；

3）、给校验的bean后紧跟一个BindingResult，就可以获取到校验的结果

首先导入依赖

        
        
            org.springframework.boot
            spring-boot-starter-validation
            2.6.7

1 我们这里给TestEntity 实体类来加上注解

@Data
@TableName("test")
public class TestEntity implements Serializable {

    //忽略掉 设置序列化和反序列化的serialVersionUID
    //想了解一下可以去这篇博客 https://blog.csdn.net/qq_45503106/article/details/107950914
    private static final long serialVersionUID = 1L;

    
    @TableId(type = IdType.AUTO)
    private Integer id;
    
    @NotEmpty(message = "姓名不能为空")
    private String name;

    
    private String email;

}

2 错误解决注解不生效问题

首先看看你导的是不是java.javax.validation.constraints.*;

如果不是引入一下依赖

        
        
            org.springframework.boot
            spring-boot-starter-validation
            2.6.7

更新依赖引入后如果重启还不生效
maven
先clean 再 compile试试

3 controller层开启校验功能

代码如下

@PostMapping("/save")
    public String save(@Valid @RequestBody TestEntity testEntity, BindingResult result){
        if(result.hasErrors()){
            Map map = new HashMap<>();
            //1、获取校验的错误结果
            result.getFieldErrors().forEach((item)->{
                //FieldError 获取到错误提示
                String message = item.getDefaultMessage();
                //获取错误的属性的名字
                String field = item.getField();
                map.put(field,message);
            });

            return map.toString();
        }else {
            testService.save(testEntity);
            return "ok";
        }

    }

2 统一异常处理

统一的异常处理
@ControllerAdvice
1）、编写异常处理类，使用@ControllerAdvice。
2）、使用@ExceptionHandler标注方法可以处理的异常。

统一返回类编写
这里使用人人开源的模板

package com.example.jsr303.common.utils;

import org.apache.http.HttpStatus;

import java.util.HashMap;
import java.util.Map;


public class R extends HashMap {
	private static final long serialVersionUID = 1L;

	public R() {
		put("code", 0);
		put("msg", "success");
	}

	public static R error() {
		return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, "未知异常，请联系管理员");
	}

	public static R error(String msg) {
		return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, msg);
	}

	public static R error(int code, String msg) {
		R r = new R();
		r.put("code", code);
		r.put("msg", msg);
		return r;
	}

	public static R ok(String msg) {
		R r = new R();
		r.put("msg", msg);
		return r;
	}

	public static R ok(Map map) {
		R r = new R();
		r.putAll(map);
		return r;
	}

	public static R ok() {
		return new R();
	}

	public R put(String key, Object value) {
		super.put(key, value);
		return this;
	}
}

全局枚举编写

package com.example.jsr303.common.exception;


public enum BizCodeEnume {
    UNKNOW_EXCEPTION(10000,"系统未知异常"),
    VAILD_EXCEPTION(10001,"参数格式校验失败");

    private int code;
    private String msg;
    BizCodeEnume(int code, String msg){
        this.code = code;
        this.msg = msg;
    }

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

参考结构

建一个全局异常捕获类

这样我们在com.example.jsr303.controller下的异常都能被这个类捕获到进行统一处理

package com.atguigu.gulimall.product.exception;

import com.atguigu.common.exception.BizCodeEnume;
import com.atguigu.common.utils.R;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;
import java.util.Map;


@Slf4j
//@ResponseBody
//@ControllerAdvice(basePackages = "com.atguigu.gulimall.product.controller")
@RestControllerAdvice(basePackages = "com.atguigu.gulimall.product.controller")
public class GulimallExceptionControllerAdvice {


   @ExceptionHandler(value= MethodArgumentNotValidException.class)
   public R handleVaildException(MethodArgumentNotValidException e){
       log.error("数据校验出现问题{}，异常类型：{}",e.getMessage(),e.getClass());
       BindingResult bindingResult = e.getBindingResult();

       Map errorMap = new HashMap<>();
       bindingResult.getFieldErrors().forEach((fieldError)->{
           errorMap.put(fieldError.getField(),fieldError.getDefaultMessage());
       });
       return R.error(BizCodeEnume.VAILD_EXCEPTION.getCode(),BizCodeEnume.VAILD_EXCEPTION.getMsg()).put("data",errorMap);
   }

   @ExceptionHandler(value = Throwable.class)
   public R handleException(Throwable throwable){

       log.error("错误：",throwable);
       return R.error(BizCodeEnume.UNKNOW_EXCEPTION.getCode(),BizCodeEnume.UNKNOW_EXCEPTION.getMsg());
   }
}

controller层这么编写就可以
因为因为验证失败抛出的MethodArgumentNotValidException会被我们的异常捕获器捕获处理

   @PostMapping("/save")
   public String save(@Valid @RequestBody TestEntity testEntity){
           testService.save(testEntity);
           return "ok";
   }

3 JSR303分组校验

思路:
分组校验（多场景的复杂校验）
1)、 @NotBlank(message = “品牌名必须提交”,groups = {AddGroup.class,UpdateGroup.class})
给校验注解标注什么情况需要进行校验
2）、@Validated({AddGroup.class})
3)、默认没有指定分组的校验注解在分组校验情况@Validated({AddGroup.class})下不生效，只会在@Validated生效；

1 在 common包下创建一个vaild包

里面定义AddGroup接口和UpdateGroup接口

2 在实体类上定义组分类

形式(groups = {组接口.class})

@Data
@TableName("test")
public class TestEntity implements Serializable {

    //忽略掉 设置序列化和反序列化的serialVersionUID
    //想了解一下可以去这篇博客 https://blog.csdn.net/qq_45503106/article/details/107950914
    private static final long serialVersionUID = 1L;

    
    @TableId(type = IdType.AUTO)
    private Integer id;
    
    @NotEmpty(message = "姓名不能为空",groups = {AddGroup.class})
    private String name;

    
    @NotEmpty(message = "邮箱不能为空",groups = {UpdateGroup.class})
    private String email;

}

3 在controller层上使用@vaildated(接口.class)开启分组校验(这时候如果实体类上没有指定组的校验将会失效)

    @PostMapping("/save")
    public String save(@Validated(AddGroup.class) @RequestBody TestEntity testEntity){
            testService.save(testEntity);
            return "ok";
    }

4 JSR303 自定义校验注解

思路：

5）、自定义校验

 1）、编写一个自定义的校验注解

 2）、编写一个自定义的校验器 ConstraintValidator

 3）、关联自定义的校验器和自定义的校验注解
  *      @Documented
  * @Constraint(validatedBy = { ListValueConstraintValidator.class【可以指定多个不同的校验器，适配不同类型的校验】 })
  * @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
  * @Retention(RUNTIME)
  * public @interface ListValue {

1 在自己对应实体类上编写自定义注解

    

    @ListValue(vals={"1","2"},groups = {AddGroup.class})
    private String email;

2 编写注解接口

参考结构

自定义注解编写ListValue

@Documented
//指定校验器 这里指定我们自定义的ListValueConstraintValidator
@Constraint(validatedBy = { ListValueConstraintValidator.class })
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Retention(RUNTIME)
public @interface ListValue {
    //使用我们自己定义的错误信息 在common模块下的resources中
//    String message() default "{com.atguigu.common.valid.ListValue.message}";
    String message() default "值必须是0或者1";

    Class[] groups() default { };

    Class[] payload() default { };

    //预先准备的值 vals={0,1}
    String[] vals() default {};
}

//对应实体类的注解
//@ListValue(vals={0,1},groups = {AddGroup.class, UpdateStatusGroup.class})

3 编写注解校验器ListValueConstraintValidator

//对应实体类的注解
//@ListValue(vals={0,1},groups = {AddGroup.class, UpdateStatusGroup.class})
public class ListValueConstraintValidator implements ConstraintValidator {

    private Set set = new HashSet<>();
    //初始化方法
    @Override
    public void initialize(ListValue constraintAnnotation) {

        //从注解上获取值 遍历将其存入一个set
        String[] vals = constraintAnnotation.vals();
        for (String val : vals) {
            set.add(val);
        }

    }
    //判断是否校验成功
    
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {

        //拿到传入的值 判断set中是否包含这个值
        //不包含返回false
        return set.contains(value);
    }
}

4 controller层开启

    @PostMapping("/save")
    public String save(@Validated({AddGroup.class, UpdateGroup.class}) @RequestBody TestEntity testEntity){
            testService.save(testEntity);
            return "ok";
    }

总结

controller开启Vailid或者Validated进行校验 -> 到实体类的校验注解查看校验策略(分组和注解内容，如notnull等) ->分支1 非定义注解验证后通过或是返回错误信息——>分支2 自定义注解去自定义注解中找到校验器
然后进行校验判断

JSR303校验详解(基础校验,分组校验,自定义校验)结合 全局异常处理捕获校验异常

Java相关栏目本月热门文章

JSR303校验详解(基础校验,分组校验,自定义校验)结合全局异常处理捕获校验异常