1. 简介

我们都知道前台的验证只是为了满足界面的友好性、客户体验性等等。但是如果仅靠前端进行数据合法性校验，是远远不够的。因为非法用户可能会直接从客户端获取到请求地址进行非法请求，所以后台的校验是必须的；特别是应用如果不允许输入空值，对数据的合法行有要求的情况下。

2. 开撸

2.1 项目结构

结构说明：

  1. ├── java
  2. │   └── com
  3. │       └── ldx
  4. │           └── valid
  5. │               ├── ValidApplication.java # 启动类
  6. │               ├── annotation
  7. │               │   └── Phone.java # 自定义验证注解
  8. │               ├── config
  9. │               │   └── ValidatorConfig.java # 表单验证配置类
  10. │               ├── controller
  11. │               │   └── SysUserController.java # 用户管理控制器
  12. │               ├── exception
  13. │               │   ├── BusinessException.java # 业务异常类
  14. │               │   └── GlobalExceptionHandler.java # 统一异常处理类
  15. │               ├── model
  16. │               │   ├── SysUser.java # 用户信息实体
  17. │               │   └── ValidationInterface.java # 表单验证的通用分组接口
  18. │               ├── util
  19. │               │   └── CommonResult.java # 接口返回封装类
  20. │               └── validation
  21. │                   └── PhoneValidator.java #自定义验证实现类
  22. └── resources
  23.     ├── application.yaml # 配置文件
  24.     └── messages
  25.         └── validation
  26.             └── messages.properties # 自定义验证信息源

2.1 quick start

2.1.1 导入依赖

创建springboot项目导入以下依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.5.3</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.ldx</groupId>
  12.     <artifactId>valid</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>valid</name>
  15.     <description>表单验证demo</description>
  16.     <properties>
  17.         <java.version>1.8</java.version>
  18.     </properties>
  19.     <dependencies>
  20.         <!-- web支持 -->
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-web</artifactId>
  24.         </dependency>
  25.         <!-- 表单验证 -->
  26.         <dependency>
  27.             <groupId>org.springframework.boot</groupId>
  28.             <artifactId>spring-boot-starter-validation</artifactId>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>org.projectlombok</groupId>
  32.             <artifactId>lombok</artifactId>
  33.             <optional>true</optional>
  34.         </dependency>
  35.     </dependencies>
  37.     <build>
  38.         <plugins>
  39.             <plugin>
  40.                 <groupId>org.springframework.boot</groupId>
  41.                 <artifactId>spring-boot-maven-plugin</artifactId>
  42.                 <configuration>
  43.                     <excludes>
  44.                         <exclude>
  45.                             <groupId>org.projectlombok</groupId>
  46.                             <artifactId>lombok</artifactId>
  47.                         </exclude>
  48.                     </excludes>
  49.                 </configuration>
  50.             </plugin>
  51.         </plugins>
  52.     </build>
  53. </project>

2.1.2 添加配置类

创建表单验证配置类，配置快速校验，不用等全部的参数校验完，只要有错，马上抛出。

  1. import org.hibernate.validator.HibernateValidator;
  2. import org.springframework.context.annotation.Bean;
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;
  5. import javax.validation.Validation;
  6. import javax.validation.Validator;
  7. import javax.validation.ValidatorFactory;
  9. /**
  10.  * 配置 Hibernate 参数校验
  11.  * @author ludangxin
  12.  * @date 2021/8/5
  13.  */
  14. @Configuration
  15. public class ValidatorConfig {
  16.     @Bean
  17.     public MethodValidationPostProcessor methodValidationPostProcessor() {
  18.         MethodValidationPostProcessor postProcessor = new MethodValidationPostProcessor();
  19.         //快速校验，只要有错马上返回
  20.         postProcessor.setValidator(validator());
  21.         return postProcessor;
  22.     }
  24.     @Bean
  25.     public Validator validator() {
  26.         ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class)
  27.             .configure()
  28.             .addProperty("hibernate.validator.fail_fast", "true")
  29.             .buildValidatorFactory();
  30.         return validatorFactory.getValidator();
  31.     }
  32. }

2.1.3 添加实体类

  1. import lombok.*;
  2. import javax.validation.constraints.*;
  3. import java.io.Serializable;
  5. /**
  6.  * 用户信息管理
  7.  * @author ludangxin
  8.  * @date 2021/8/5
  9.  */
  10. @Data
  11. public class SysUser  implements Serializable {
  12.     private static final long serialVersionUID = 1L;
  13.     /**
  14.      * 主键
  15.      */
  16.     private Long id;
  18.     /**
  19.      * 用户名
  20.      */
  21.     @NotEmpty(message = "用户名称不能为空")
  22.     private String username;
  24.     /**
  25.      * 密码
  26.      */
  27.     @Size(min = 6, max = 16, message = "密码长度必须在{min}-{max}之间")
  28.     private String password = "123456";
  30.     /**
  31.      * 邮箱地址
  32.      */
  33.     @Email(message = "邮箱地址不合法")
  34.     @NotEmpty(message = "邮箱不能为空")
  35.     private String email;
  37.     /**
  38.      * 电话
  39.      */
  40.     @Size(min = 11, max = 11, message = "手机号不合法")
  41.     @NotEmpty(message = "手机号不能为空")
  42.     private String phone;
  43. }

2.1.4 接口返回封装类

  1. import lombok.Data;
  2. import lombok.NoArgsConstructor;
  4. /**
  5.  * 操作消息提醒
  6.  * @author ludangxin
  7.  * @date 2021/8/5
  8.  */
  9. @Data
  10. @NoArgsConstructor
  11. public class CommonResult {
  12.     /** 状态码 */
  13.     private int code;
  15.     /** 返回内容 */
  16.     private String msg;
  18.     /** 数据对象 */
  19.     private Object data;
  21.     /**
  22.      * 初始化一个新创建的 CommonResult 对象
  23.      * @param type 状态类型
  24.      * @param msg 返回内容
  25.      */
  26.     public CommonResult(Type type, String msg) {
  27.         this.code = type.value;
  28.         this.msg = msg;
  29.     }
  31.     /**
  32.      * 初始化一个新创建的 CommonResult 对象
  33.      * @param type 状态类型
  34.      * @param msg 返回内容
  35.      * @param data 数据对象
  36.      */
  37.     public CommonResult(Type type, String msg, Object data) {
  38.         this.code = type.value;
  39.         this.msg = msg;
  40.         if (data != null) {
  41.             this.data = data;
  42.         }
  43.     }
  45.     /**
  46.      * 返回成功消息
  47.      * @return 成功消息
  48.      */
  49.     public static CommonResult success() {
  50.         return CommonResult.success("操作成功");
  51.     }
  53.     /**
  54.      * 返回成功数据
  55.      * @return 成功消息
  56.      */
  57.     public static CommonResult success(Object data) {
  58.         return CommonResult.success("操作成功", data);
  59.     }
  61.     /**
  62.      * 返回成功消息
  63.      * @param msg 返回内容
  64.      * @return 成功消息
  65.      */
  66.     public static CommonResult success(String msg) {
  67.         return CommonResult.success(msg, null);
  68.     }
  70.     /**
  71.      * 返回成功消息
  72.      * @param msg 返回内容
  73.      * @param data 数据对象
  74.      * @return 成功消息
  75.      */
  76.     public static CommonResult success(String msg, Object data) {
  77.         return new CommonResult(Type.SUCCESS, msg, data);
  78.     }
  80.     /**
  81.      * 返回警告消息
  82.      * @param msg 返回内容
  83.      * @return 警告消息
  84.      */
  85.     public static CommonResult warn(String msg) {
  86.         return CommonResult.warn(msg, null);
  87.     }
  89.     /**
  90.      * 返回警告消息
  91.      * @param msg 返回内容
  92.      * @param data 数据对象
  93.      * @return 警告消息
  94.      */
  95.     public static CommonResult warn(String msg, Object data) {
  96.         return new CommonResult(Type.WARN, msg, data);
  97.     }
  99.     /**
  100.      * 返回错误消息
  101.      * @return 错误信息
  102.      */
  103.     public static CommonResult error() {
  104.         return CommonResult.error("操作失败");
  105.     }
  107.     /**
  108.      * 返回错误消息
  109.      * @param msg 返回内容
  110.      * @return 错误消息
  111.      */
  112.     public static CommonResult error(String msg) {
  113.         return CommonResult.error(msg, null);
  114.     }
  116.     /**
  117.      * 返回错误消息
  118.      * @param msg 返回内容
  119.      * @param data 数据对象
  120.      * @return 错误消息
  121.      */
  122.     public static CommonResult error(String msg, Object data) {
  123.         return new CommonResult(Type.ERROR, msg, data);
  124.     }
  126.     /**
  127.      * 状态类型
  128.      */
  129.     public enum Type {
  130.         /** 成功 */
  131.         SUCCESS(200),
  132.         /** 警告 */
  133.         WARN(301),
  134.         /** 错误 */
  135.         ERROR(500);
  136.         private final int value;
  138.         Type(int value){
  139.             this.value = value;
  140.         }
  142.         public int value() {
  143.             return this.value;
  144.         }
  145.     }
  146. }

2.1.5 控制器

使用@Validated注解标识需要验证的类，使用BindingResult类接收错误信息

  1. import com.ldx.valid.exception.BusinessException;
  2. import com.ldx.valid.model.SysUser;
  3. import com.ldx.valid.model.ValidationInterface;
  4. import com.ldx.valid.util.CommonResult;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.validation.BindingResult;
  7. import org.springframework.validation.FieldError;
  8. import org.springframework.validation.annotation.Validated;
  9. import org.springframework.web.bind.annotation.*;
  10. import javax.validation.constraints.NotEmpty;
  11. import java.util.ArrayList;
  12. import java.util.List;
  13. import java.util.Objects;
  14. import java.util.stream.Collectors;
  16. /**
  17.  * 用户管理控制器
  18.  *
  19.  * @author ludangxin
  20.  * @date 2021/8/5
  21.  */
  22. @Slf4j
  23. @RestController
  24. @RequestMapping("sys/user")
  25. public class SysUserController {
  26.    private static final List<SysUser> USERS = new ArrayList<>();
  28.    // 数据初始化
  29.    static {
  30.       SysUser user = new SysUser();
  31.       user.setId(1L);
  32.       user.setUsername("zhangsan");
  33.       user.setPhone("13566666666");
  34.       user.setEmail("example@qq.com");
  35.       USERS.add(user);
  36.       SysUser user1 = new SysUser();
  37.       user1.setId(2L);
  38.       user1.setUsername("lisi");
  39.       user1.setPhone("13588888888");
  40.       user1.setEmail("example1@qq.com");
  41.       USERS.add(user1);
  42.    }
  44.    /**
  45.     * 新增用户信息
  46.     * @param sysUser 用户信息
  47.     * @return 成功标识
  48.     */
  49.    @PostMapping
  50.    public CommonResult add(@Validated @RequestBody SysUser sysUser, BindingResult result) {
  51.       FieldError fieldError = result.getFieldError();
  53.       if(Objects.nonNull(fieldError)) {
  54.          String field = fieldError.getField();
  55.          Object rejectedValue = fieldError.getRejectedValue();
  56.          String msg = "[" + fieldError.getDefaultMessage() + "]";
  57.          log.error("{}：字段=={}\t值=={}", msg, field, rejectedValue);
  58.          return CommonResult.error(msg);
  59.       }
  61.       USERS.add(sysUser);
  62.       return CommonResult.success("新增成功");
  63.    }
  64. }

2.1.5 启动测试

新增时，故意将email信息填错，测试结果符合预期。

log日志：

  1. [nio-8080-exec-9] c.l.valid.controller.SysUserController   : [邮箱地址不合法]：字段==email	值==123

3. 分组校验

groups是用来干什么的?

  1. 因为一个实体不可能只干一种操作,一个实体必然存在增删改查操作,那么问题就来了
  2. 如果我要根据id进行更新操作,那么id肯定不能为空
  3. 这时候我还要进行新增操作,因为id是新增数据库操作才产生的,接受数据的时候我肯定是没有id的
  4. 所以就产生矛盾了
  5. 那么groups这个参数就起作用了,它可以表示我这个注解属于哪个组,这样就解决这个尴尬的问题了。

当在controller中校验表单数据时，如果使用了groups，那么没有在这个分组下的属性是不会校验的

3.1 添加分组接口

  1. /**
  2.  * 用于表单验证的通用分组接口
  3.  * @author ludangxin
  4.  * @date 2021/8/5
  5.  */
  6. public interface ValidationInterface {
  7.     /**
  8.      * 新增分组
  9.      */
  10.     interface add{}
  12.     /**
  13.      * 删除分组
  14.      */
  15.     interface delete{}
  17.     /**
  18.      * 查询分组
  19.      */
  20.     interface select{}
  22.     /**
  23.      * 更新分组
  24.      */
  25.     interface update{}
  26. }

如果还有其它特殊的分组要求 直接在DO中创建interface即可

例:如果还有个需要验证username 和 password(只有这两个参数) 的 select操作

直接在SysUser中创建UsernamePasswordValidView 的接口即可

3.2 修改实体类

将属性进行分组

  1. import lombok.Data;
  2. import javax.validation.constraints.Email;
  3. import javax.validation.constraints.NotEmpty;
  4. import javax.validation.constraints.NotNull;
  5. import javax.validation.constraints.Size;
  6. import java.io.Serializable;
  8. /**
  9.  * 用户信息管理
  10.  * @author ludangxin
  11.  * @date 2021/8/5
  12.  */
  13. @Data
  14. public class SysUser implements Serializable {
  15.     private static final long serialVersionUID = 1L;
  16.     /**
  17.      * 主键
  18.      */
  19.     @NotNull(message = "id不能为空", groups = {ValidationInterface.update.class})
  20.     private Long id;
  22.     /**
  23.      * 用户名
  24.      */
  25.     @NotEmpty(message = "用户名称不能为空", groups = {
  26.               ValidationInterface.update.class,
  27.               ValidationInterface.add.class})
  28.     private String username;
  30.     /**
  31.      * 密码
  32.      */
  33.     @Size(min = 6, max = 16, message = "密码长度必须在{min}-{max}之间", groups = {
  34.           ValidationInterface.update.class,
  35.           ValidationInterface.add.class})
  36.     private String password = "123456";
  38.     /**
  39.      * 邮箱地址
  40.      */
  41.     @Email(message = "邮箱地址不合法", groups = {
  42.            ValidationInterface.update.class,
  43.            ValidationInterface.add.class,
  44.            ValidationInterface.select.class})
  45.     @NotEmpty(message = "邮箱不能为空", groups = ValidationInterface.add.class)
  46.     private String email;
  48.     /**
  49.      * 电话
  50.      */
  51.     @Size(min = 11, max = 11, message = "手机号不合法", groups = {
  52.           ValidationInterface.update.class,
  53.           ValidationInterface.add.class,
  54.           ValidationInterface.select.class})
  55.     @NotEmpty(message = "手机号不能为空",groups = {ValidationInterface.add.class})
  56.     private String phone;
  57. }

3.3 修改控制器

添加操作方法，并且方法形参上指定验证的分组

  1. import com.ldx.valid.exception.BusinessException;
  2. import com.ldx.valid.model.SysUser;
  3. import com.ldx.valid.model.ValidationInterface;
  4. import com.ldx.valid.util.CommonResult;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.validation.BindingResult;
  7. import org.springframework.validation.FieldError;
  8. import org.springframework.validation.annotation.Validated;
  9. import org.springframework.web.bind.annotation.*;
  10. import javax.validation.constraints.NotEmpty;
  11. import java.util.ArrayList;
  12. import java.util.List;
  13. import java.util.Objects;
  14. import java.util.stream.Collectors;
  16. /**
  17.  * 用户管理控制器
  18.  * @author ludangxin
  19.  * @date 2021/8/5
  20.  */
  21. @Slf4j
  22. @RestController
  23. @RequestMapping("sys/user")
  24. public class SysUserController {
  25.    private static final List<SysUser> USERS = new ArrayList<>();
  27.    // 数据初始化
  28.    static {
  29.       SysUser user = new SysUser();
  30.       user.setId(1L);
  31.       user.setUsername("zhangsan");
  32.       user.setPhone("13566666666");
  33.       user.setEmail("example@qq.com");
  34.       USERS.add(user);
  35.       SysUser user1 = new SysUser();
  36.       user1.setId(2L);
  37.       user1.setUsername("lisi");
  38.       user1.setPhone("13588888888");
  39.       user1.setEmail("example1@qq.com");
  40.       USERS.add(user1);
  41.    }
  43.    /**
  44.     * 根据手机号或邮箱查询用户信息
  45.     * @param sysUser 查询条件
  46.     * @return 用户list
  47.     */
  48.    @GetMapping
  49.    public CommonResult queryList(@Validated(value = ValidationInterface.select.class) SysUser sysUser,
  50.                                  BindingResult result)
  51.    {
  52.       FieldError fieldError = result.getFieldError();
  54.       if(Objects.nonNull(fieldError)) {
  55.          return CommonResult.error(getErrorMsg(fieldError));
  56.       }
  58.       String phone = sysUser.getPhone();
  59.       String email = sysUser.getEmail();
  61.       if(phone == null && email == null) {
  62.          return CommonResult.success(USERS);
  63.       }
  65.       List<SysUser> queryResult = USERS.stream()
  66.             .filter(obj -> obj.getPhone().equals(phone) || obj.getEmail().equals(email))
  67.             .collect(Collectors.toList());
  68.       return CommonResult.success(queryResult);
  69.    }
  71.    /**
  72.     * 新增用户信息
  73.     * @param sysUser 用户信息
  74.     * @return 成功标识
  75.     */
  76.    @PostMapping
  77.    public CommonResult add(@Validated(value = ValidationInterface.add.class)
  78.                            @RequestBody SysUser sysUser,
  79.                            BindingResult result)
  80.    {
  81.       FieldError fieldError = result.getFieldError();
  83.       if(Objects.nonNull(fieldError)) {
  84.          return CommonResult.error(getErrorMsg(fieldError));
  85.       }
  87.       Long id = (long) (USERS.size() + 1);
  88.       sysUser.setId(id);
  89.       USERS.add(sysUser);
  90.       return CommonResult.success("新增成功");
  91.    }
  93.    /**
  94.     * 根据Id更新用户信息
  95.     * @param sysUser 用户信息
  96.     * @return 成功标识
  97.     */
  98.    @PutMapping("{id}")
  99.    public CommonResult updateById(@PathVariable("id") Long id,
  100.                                   @Validated(value = ValidationInterface.update.class)
  101.                                   @RequestBody SysUser sysUser,
  102.                                   BindingResult result)
  103.    {
  104.       FieldError fieldError = result.getFieldError();
  106.       if(Objects.nonNull(fieldError)) {
  107.          return CommonResult.error(getErrorMsg(fieldError));
  108.       }
  110.       for(int i = 0; i < USERS.size(); i++) {
  111.          if(USERS.get(i).getId().equals(id)) {
  112.             USERS.set(i,sysUser);
  113.          }
  114.       }
  115.       return CommonResult.success("更新成功");
  116.    }
  118.    /**
  119.     * 根据Id删除用户信息
  120.     * @param id 主键
  121.     * @return 成功标识
  122.     */
  123.    @DeleteMapping("{id}")
  124.    public CommonResult deleteById(@PathVariable Long id) {
  125.       USERS.removeIf(obj -> obj.getId().equals(id));
  126.       return CommonResult.success("删除成功");
  127.    }
  129.    /**
  130.     * 获取表单验证错误msg
  131.     * @param fieldError 报错字段
  132.     * @return msg
  133.     */
  134.    public String getErrorMsg(FieldError fieldError) {
  135.       String field = fieldError.getField();
  136.       Object rejectedValue = fieldError.getRejectedValue();
  137.       String msg = "[" + fieldError.getDefaultMessage() + "]";
  138.       log.error("{}：字段=={}\t值=={}", msg, field, rejectedValue);
  139.       return msg;
  140.    }
  141. }

3.4 启动测试

查询：

​ 输入不合法手机号

新增：

​ 正常情况

​ 去掉邮箱

修改：

​ 去掉id

删除：

4. 自定义验证

很多时候框架提供的功能并不能满足我们的业务场景，这时我们需要自定义一些验证规则来完成验证。

4.1 添加注解

  1. import com.ldx.valid.validation.PhoneValidator;
  2. import javax.validation.Constraint;
  3. import javax.validation.Payload;
  4. import java.lang.annotation.Documented;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.Target;
  7. import static java.lang.annotation.ElementType.*;
  8. import static java.lang.annotation.ElementType.TYPE_USE;
  9. import static java.lang.annotation.RetentionPolicy.RUNTIME;
  11. /**
  12.  * 验证手机号是否合法
  13.  * @author ludangxin
  14.  * @date 2021/8/7
  15.  */
  16. @Documented
  17. @Constraint(validatedBy = {PhoneValidator.class})
  18. @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
  19. @Retention(RUNTIME)
  20. public @interface Phone {
  21.    //默认错误消息
  22.    String message() default "不是一个合法的手机号";
  24.    //分组
  25.    Class<?>[] groups() default {};
  27.    //载荷 将某些元数据信息与给定的注解声明相关联的方法
  28.    Class<? extends Payload>[] payload() default {};
  30.    //指定多个时使用
  31.    @Target({FIELD, METHOD, PARAMETER, ANNOTATION_TYPE})
  32.    @Retention(RUNTIME)
  33.    @Documented
  34.    @interface List {
  35.       Phone[] value();
  36.    }
  37. }

4.2 编写验证逻辑

  1. import javax.validation.ConstraintValidator;
  2. import com.ldx.valid.annotation.Phone;
  3. import javax.validation.ConstraintValidatorContext;
  4. import java.util.Objects;
  5. import java.util.regex.Pattern;
  7. /**
  8.  * 手机号校验器
  9.  * @author ludangxin
  10.  * @date 2021/8/7
  11.  */
  12. public class PhoneValidator implements ConstraintValidator<Phone, String> {
  14.    /**
  15.     * 手机号正则表达式
  16.     */
  17.    private static final String REGEXP_PHONE = "^1[3456789]\\d{9}$";
  19.    @Override
  20.    public boolean isValid(String value, ConstraintValidatorContext context) {
  21.       if(Objects.isNull(value)) {
  22.          return true;
  23.       }
  25.       return Pattern.matches(REGEXP_PHONE, value);
  26.    }
  27. }

4.3 修改实体

给SysUser.phone 属性添加注解@Phone

  1. @Phone(groups = {
  2.                 ValidationInterface.update.class,
  3.                 ValidationInterface.add.class,
  4.                 ValidationInterface.select.class})
  5. @NotEmpty(message = "手机号不能为空", groups = {ValidationInterface.add.class})
  6. private String phone;

4.4 启动测试

输入错误的手机号进行测试

4.5 @Pattern

当然validation也提供了基于正则匹配的注解@Pattern

  1. @Pattern(message = "手机号不合法", regexp = "^1[3456789]\\d{9}$", groups = {ValidationInterface.add.class})
  2. @NotEmpty(message = "手机号不能为空", groups = {ValidationInterface.add.class})
  3. private String phone;

注意是javax.validation.constraints包下的

测试

5. 调用过程验证

有的时候我们在参数传输过程中需要对传入的对象做参数验证，但是上面介绍的都是对参数绑定时的验证，那能不能使用validation进行验证呢？

答案肯定是可以的。

5.1 使用 spring bean

5.1.1 注入validator

bean validator 是我们在config文件中定义的bean，如果使用了springboot默认的配置ValidationAutoConfiguration::defaultValidator()，直接注入bean name defaultValidator即可

  1. @Resource(name = "validator")
  2. javax.validation.Validator validator;

5.1.2 定义验证方法

  1. public void validateParams(SysUser user) {
  2.    validator.validate(user, ValidationInterface.add.class).stream().findFirst().ifPresent(obj -> {
  3.       String objName = obj.getRootBean().getClass().getSimpleName();
  4.       String fieldName = obj.getPropertyPath().toString();
  5.       Object val = obj.getInvalidValue();
  6.       String msg = obj.getMessage();
  7.       String errMsg = MessageFormat.format(msg + "：对象：{0}，字段：{1}，值：{2}", objName, fieldName, val);
  8.       throw new RuntimeException(errMsg);
  9.    });

5.1.2 启动验证

调用新增方法，通过新增方法调用validateParams方法

报错日志如下

  1. java.lang.RuntimeException: 手机号不合法：对象：SysUser，字段：phone，值：135999

5.2 非spring环境验证

5.2.1 定义验证方法

直接获取默认的工厂类，然后获取验证对象进行验证

  1. public static void main(String[] args) {
  2.    ValidatorFactory vf = Validation.buildDefaultValidatorFactory();
  3.    Validator validator = vf.getValidator();
  4.    SysUser user = new SysUser();
  5.    user.setId(1L);
  6.    user.setUsername("zhangsan");
  7.    user.setPhone("1356666");
  8.    user.setEmail("example@qq.com");
  9.    validator.validate(user, ValidationInterface.add.class).stream().findFirst().ifPresent(obj -> {
  10.       String objName = obj.getRootBean().getClass().getSimpleName();
  11.       String fieldName = obj.getPropertyPath().toString();
  12.       Object val = obj.getInvalidValue();
  13.       String msg = obj.getMessage();
  14.       String errMsg = MessageFormat.format(msg + "：对象：{0}，字段：{1}，值：{2}", objName, fieldName, val);
  15.       throw new RuntimeException(errMsg);
  16.    });
  17. }

5.2.2 启动验证

报错信息如下，符合预期

  1. Exception in thread "main" java.lang.RuntimeException: 手机号不合法：对象：SysUser，字段：phone，值：1356666
  2. 	at com.ldx.valid.controller.SysUserController.lambda$main$4(SysUserController.java:215)
  3. 	at java.util.Optional.ifPresent(Optional.java:159)
  4. 	at com.ldx.valid.controller.SysUserController.main(SysUserController.java:209)

6. 方法参数验证

有的时候我们想在方法上直接进行参数验证，步骤如下

6.1 修改控制器

直接在类上添加注解@Validated，并在方法上直接进行验证

  1. @Slf4j
  2. @Validated
  3. @RestController
  4. @RequestMapping("sys/user")
  5. public class SysUserController {
  6.   ... 省略代码
  7.     /**
  8.      * 根据手机号和邮箱查询用户信息
  9.      * @param phone 手机号
  10.      * @return 用户list
  11.      */
  12.     @GetMapping("selectByPhone")
  13.     public CommonResult queryByPhone(@NotEmpty(message = "手机号不能为空") String phone) {
  14.        List<SysUser> queryResult = USERS.stream()
  15.              .filter(obj -> obj.getPhone().equals(phone))
  16.              .collect(Collectors.toList());
  17.        return CommonResult.success(queryResult);
  18.     }
  19. }

6.2 启动验证

不给phone字段赋值，操作结果符合预期

错误日志：

  1. javax.validation.ConstraintViolationException: queryByPhone.phone: 手机号不能为空

7. 统一异常处理

在上面的参数验证中，验证的错误信息是通过BindingResult result参数进行接收的，在每个方法中异常处理如出一辙，特别麻烦。甚至在step 5，6都是直接将异常的堆栈信息返回给前端，这对于用来说是非常不友好的。而且有的情况下需要我们主动抛出业务异常，比方用户不能直接删除已绑定用户的角色。

所以，开撸。

7.1 创建业务异常类

  1. /**
  2.  * 业务异常
  3.  * @author ludangxin
  4.  * @date 2021/8/5
  5.  */
  6. public class BusinessException extends RuntimeException {
  7.     private static final long serialVersionUID = 1L;
  9.     protected final String message;
  11.     public BusinessException(String message) {
  12.         this.message = message;
  13.     }
  15.     public BusinessException(String message, Throwable e) {
  16.         super(message, e);
  17.         this.message = message;
  18.     }
  20.     @Override
  21.     public String getMessage() {
  22.         return message;
  23.     }
  24. }

7.2 创建全局异常处理器

  1. import com.ldx.valid.util.CommonResult;
  2. import lombok.extern.slf4j.Slf4j;
  3. import org.springframework.validation.BindException;
  4. import org.springframework.validation.BindingResult;
  5. import org.springframework.validation.FieldError;
  6. import org.springframework.web.HttpRequestMethodNotSupportedException;
  7. import org.springframework.web.bind.annotation.ExceptionHandler;
  8. import org.springframework.web.bind.annotation.RestControllerAdvice;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.validation.ConstraintViolation;
  11. import javax.validation.ConstraintViolationException;
  12. import javax.validation.ValidationException;
  13. import java.util.Set;
  15. /**
  16.  * 全局异常处理器
  17.  *
  18.  * @author ludangxin
  19.  * @date 2021/8/5
  20.  */
  21. @Slf4j
  22. @RestControllerAdvice
  23. public class GlobalExceptionHandler {
  24.     /**
  25.      * 参数绑定异常类 用于表单验证时抛出的异常处理
  26.      */
  27.     @ExceptionHandler(BindException.class)
  28.     public CommonResult validatedBindException(BindException e){
  29.         log.error(e.getMessage(), e);
  30.         BindingResult bindingResult = e.getBindingResult();
  31.         FieldError fieldError = e.getFieldError();
  32.         String message = "[" + e.getAllErrors().get(0).getDefaultMessage() + "]";
  33.         return CommonResult.error(message);
  34.     }
  36.     /**
  37.      * 用于方法形参中参数校验时抛出的异常处理
  38.      * @param e
  39.      * @return
  40.      */
  41.     @ExceptionHandler(ConstraintViolationException.class)
  42.     public CommonResult handle(ValidationException e) {
  43.         log.error(e.getMessage(), e);
  44.         String errorInfo = "";
  45.         if(e instanceof ConstraintViolationException){
  46.             ConstraintViolationException exs = (ConstraintViolationException) e;
  47.             Set<ConstraintViolation<?>> violations = exs.getConstraintViolations();
  48.             for (ConstraintViolation<?> item : violations) {
  49.                 errorInfo = errorInfo + "[" + item.getMessage() + "]";
  50.             }
  51.         }
  52.         return CommonResult.error(errorInfo);
  53.     }
  55.     /**
  56.      * 请求方式不支持
  57.      */
  58.     @ExceptionHandler({ HttpRequestMethodNotSupportedException.class })
  59.     public CommonResult handleException(HttpRequestMethodNotSupportedException e){
  60.         log.error(e.getMessage(), e);
  61.         return CommonResult.error("不支持' " + e.getMethod() + "'请求");
  62.     }
  64.     /**
  65.      * 拦截未知的运行时异常
  66.      */
  67.     @ExceptionHandler(RuntimeException.class)
  68.     public CommonResult notFount(RuntimeException e) {
  69.         log.error("运行时异常:", e);
  70.         return CommonResult.error("运行时异常:" + e.getMessage());
  71.     }
  73.     /**
  74.      * 系统异常
  75.      */
  76.     @ExceptionHandler(Exception.class)
  77.     public CommonResult handleException(Exception e) {
  78.         log.error(e.getMessage(), e);
  79.         return CommonResult.error("服务器错误，请联系管理员");
  80.     }
  82.     /**
  83.      * 业务异常
  84.      */
  85.     @ExceptionHandler(BusinessException.class)
  86.     public CommonResult businessException(HttpServletRequest request, BusinessException e) {
  87.         log.error(e.getMessage());
  88.         return CommonResult.error(e.getMessage());
  89.     }
  90. }

7.3 修改控制器

删除方法中的BindingResult result参数，将错误直接抛给统一异常处理类去解决即可。

  1. import com.ldx.valid.exception.BusinessException;
  2. import com.ldx.valid.model.SysUser;
  3. import com.ldx.valid.model.ValidationInterface;
  4. import com.ldx.valid.service.UserService;
  5. import com.ldx.valid.util.CommonResult;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.validation.FieldError;
  9. import org.springframework.validation.annotation.Validated;
  10. import org.springframework.web.bind.annotation.*;
  11. import javax.annotation.Resource;
  12. import javax.validation.*;
  13. import javax.validation.constraints.NotEmpty;
  14. import java.text.MessageFormat;
  15. import java.util.ArrayList;
  16. import java.util.List;
  17. import java.util.stream.Collectors;
  19. /**
  20.  * 用户管理控制器
  21.  * @author ludangxin
  22.  * @date 2021/8/5
  23.  */
  24. @Slf4j
  25. @Validated
  26. @RestController
  27. @RequestMapping("sys/user")
  28. public class SysUserController {
  29.    private static final List<SysUser> USERS = new ArrayList<>();
  31.    // 数据初始化
  32.    static {
  33.       SysUser user = new SysUser();
  34.       user.setId(1L);
  35.       user.setUsername("zhangsan");
  36.       user.setPhone("13566666666");
  37.       user.setEmail("example@qq.com");
  38.       USERS.add(user);
  39.       SysUser user1 = new SysUser();
  40.       user1.setId(2L);
  41.       user1.setUsername("lisi");
  42.       user1.setPhone("13588888888");
  43.       user1.setEmail("example1@qq.com");
  44.       USERS.add(user1);
  45.    }
  47.    /**
  48.     * 根据手机号或邮箱查询用户信息
  49.     * @param sysUser 查询条件
  50.     * @return 用户list
  51.     */
  52.    @GetMapping
  53.    public CommonResult queryList(@Validated(value = ValidationInterface.select.class) SysUser sysUser) {
  54.       String phone = sysUser.getPhone();
  55.       String email = sysUser.getEmail();
  57.       if(phone == null && email == null) {
  58.          return CommonResult.success(USERS);
  59.       }
  61.       List<SysUser> queryResult = USERS.stream()
  62.             .filter(obj -> obj.getPhone().equals(phone) || obj.getEmail().equals(email))
  63.             .collect(Collectors.toList());
  64.       return CommonResult.success(queryResult);
  65.    }
  67.    /**
  68.     * 根据手机号和邮箱查询用户信息
  69.     * @param phone 手机号
  70.     * @return 用户list
  71.     */
  72.    @GetMapping("selectByPhone")
  73.    public CommonResult queryByPhone(@NotEmpty(message = "手机号不能为空") String phone) {
  74.       List<SysUser> queryResult = USERS.stream()
  75.             .filter(obj -> obj.getPhone().equals(phone))
  76.             .collect(Collectors.toList());
  77.       return CommonResult.success(queryResult);
  78.    }
  80.    /**
  81.     * 新增用户信息
  82.     * @param sysUser 用户信息
  83.     * @return 成功标识
  84.     */
  85.    @PostMapping
  86.    public CommonResult add(@Validated(value = ValidationInterface.add.class) @RequestBody SysUser sysUser) {
  87.       Long id = (long) (USERS.size() + 1);
  88.       sysUser.setId(id);
  89.       USERS.add(sysUser);
  90.       return CommonResult.success("新增成功");
  91.    }
  93.    /**
  94.     * 根据Id更新用户信息
  95.     * @param sysUser 用户信息
  96.     * @return 成功标识
  97.     */
  98.    @PutMapping("{id}")
  99.    public CommonResult updateById(@PathVariable("id") Long id,
  100.                                   @Validated(value = ValidationInterface.update.class)
  101.                                   @RequestBody SysUser sysUser)
  102.    {
  103.       for(int i = 0; i < USERS.size(); i++) {
  104.          if(USERS.get(i).getId().equals(id)) {
  105.             USERS.set(i,sysUser);
  106.          }
  107.       }
  108.       return CommonResult.success("更新成功");
  109.    }
  111.    /**
  112.     * 根据Id删除用户信息
  113.     * @param id 主键
  114.     * @return 成功标识
  115.     */
  116.    @DeleteMapping("{id}")
  117.    public CommonResult deleteById(@PathVariable Long id) {
  118.       USERS.removeIf(obj -> obj.getId().equals(id));
  119.       return CommonResult.success("删除成功");
  120.    }
  122.    /**
  123.     * 测试业务异常
  124.     */
  125.    @GetMapping("testException")
  126.    public CommonResult testException(String name) {
  127.       if(!"张三".equals(name)){
  128.          throw new BusinessException("只有张三才可以访问");
  129.       }
  130.       return CommonResult.success();
  131.    }
  132. }

7.4 启动测试

查询：

​ 输出错误的邮箱

根据手机号查询：

​ 输入空值手机号

新增：

​ 输入错误的手机号

测试主动抛出业务异常：

8. 自定义验证信息源

8.1 修改配置文件

  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.context.support.ReloadableResourceBundleMessageSource;
  4. import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
  5. import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;
  6. import javax.validation.Validator;
  7. import java.util.Properties;
  9. /**
  10.  * 配置 Hibernate 参数校验
  11.  * @author ludangxin
  12.  * @date 2021/8/5
  13.  */
  14. @Configuration
  15. public class ValidatorConfig {
  16.     @Bean
  17.     public MethodValidationPostProcessor methodValidationPostProcessor(Validator validator) {
  18.         MethodValidationPostProcessor postProcessor = new MethodValidationPostProcessor();
  19.         postProcessor.setValidator(validator);
  20.         return postProcessor;
  21.     }
  23.     /**
  24.      * 实体类字段校验国际化引入
  25.      */
  26.     @Bean
  27.     public Validator validator() {
  28.         LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
  29.         // 设置messages资源信息
  30.         ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();
  31.         // 多个用逗号分割
  32.         messageSource.setBasenames("classpath:/messages/validation/messages");
  33.         // 设置字符集编码
  34.         messageSource.setDefaultEncoding("UTF-8");
  35.         validator.setValidationMessageSource(messageSource);
  36.         // 设置验证相关参数
  37.         Properties properties = new Properties();
  38.         // 快速失败，只要有错马上返回
  39.         properties.setProperty("hibernate.validator.fail_fast", "true");
  40.         validator.setValidationProperties(properties);
  41.         return validator;
  42.     }
  43. }

8.2 添加信息源文件

  1. ├───resources
  2.     └── messages
  3.         └── validation
  4.             └── messages.properties
  1. # messages.properties
  2. name.not.empty=用户名不能为空
  3. email.not.valid=${validatedValue}是邮箱地址？
  4. email.not.empty=邮箱不能为空
  5. phone.not.valid=${validatedValue}是手机号？
  6. phone.not.empty=手机号不能为空
  7. password.size.valid=密码长度必须在{min}-{max}之间
  8. id.not.empty=主键不能为空

8.3 修改实体类

  1. import com.ldx.valid.annotation.Phone;
  2. import lombok.Data;
  3. import org.hibernate.validator.constraints.Range;
  4. import javax.validation.constraints.*;
  5. import java.io.Serializable;
  7. /**
  8.  * 用户信息管理
  9.  * @author ludangxin
  10.  * @date 2021/8/5
  11.  */
  12. @Data
  13. public class SysUser implements Serializable {
  14.     private static final long serialVersionUID = 1L;
  15.     /**
  16.      * 主键
  17.      */
  18.     @NotNull(message = "{id.not.empty}", groups = {ValidationInterface.update.class})
  19.     private Long id;
  21.     /**
  22.      * 用户名
  23.      */
  24.     @NotEmpty(message = "{name.not.empty}", groups = {
  25.               ValidationInterface.update.class,
  26.               ValidationInterface.add.class})
  27.     private String username;
  29.     /**
  30.      * 密码
  31.      */
  32.     @Size(min = 6, max = 16, message = "{password.size.valid}", groups = {
  33.           ValidationInterface.update.class,
  34.           ValidationInterface.add.class})
  35.     private String password = "123456";
  37.     /**
  38.      * 邮箱地址
  39.      */
  40.     @Email(message = "{email.not.valid}",
  41.            groups = {
  42.            ValidationInterface.update.class,
  43.            ValidationInterface.add.class,
  44.            ValidationInterface.select.class})
  45.     @NotEmpty(message = "{email.not.empty}", groups = ValidationInterface.add.class)
  46.     private String email;
  48.     /**
  49.      * 电话
  50.      */
  51.     @Pattern(message = "{phone.not.valid}", regexp = "^1[3456789]\\d{9}$",
  52.              groups = {ValidationInterface.add.class})
  53.     @NotEmpty(message = "{phone.not.empty}", groups = {ValidationInterface.add.class})
  54.     private String phone;
  55. }

8.4 启动测试

​ 输入错误的邮箱地址测试：

9. 预置注解清单

注解 说明
@Null 限制只能为null
@NotNull 限制必须不为null
@AssertFalse 限制必须为false
@AssertTrue 限制必须为true
@DecimalMax(value) 限制必须为一个不大于指定值的数字
@DecimalMin(value) 限制必须为一个不小于指定值的数字
@Digits(integer,fraction) 限制必须为一个小数，且整数部分的位数不能超过integer，小数部分的位数不能超过fraction
@Future 限制必须是一个将来的日期
@Max(value) 限制必须为一个不大于指定值的数字
@Min(value) 限制必须为一个不小于指定值的数字
@Past 限制必须是一个过去的日期
@Pattern(value) 限制必须符合指定的正则表达式
@Size(max,min) 限制字符长度必须在min到max之间
@Past 验证注解的元素值（日期类型）比当前时间早
@NotEmpty 验证注解的元素值不为null且不为空（字符串长度不为0、集合大小不为0）
@NotBlank 验证注解的元素值不为空（不为null、去除首位空格后长度为0），不同于@NotEmpty，@NotBlank
@Email 验证注解的元素值是Email，也可以通过正则表达式和flag指定自定义的email格式

SpringBoot-表单验证-统一异常处理-自定义验证信息源的更多相关文章

  1. jQuery Validate 插件为表单提供了强大的验证功能

    之前项目开发中,表单校验用的jQuery Validate 插件,这个插件为表单提供了强大的验证功能,让客户端表单验证变得更简单,同时提供了大量的定制选项,满足应用程序各种需求.该插件捆绑了一套有用的 ...

  2. SpringBoot小技巧：统一异常处理

    SpringBoot小技巧:统一异常处理 情景描述 对于接口的定义,我们通常会有一个固定的格式,比如: 但是调用方在请求我们的API时把接口地址写错了,就会得到一个404错误,且不同于我们定义的数据格 ...

  3. amazeui的表单开关插件的自定义事件必须添加.bootstrapSwitch 命名空间，给了我们什么启示

    amazeui的表单开关插件的自定义事件必须添加.bootstrapSwitch 命名空间,给了我们什么启示 一.总结 一句话总结:详细看使用文档(说明文档说的真的是非常详细呢,不过循序渐进,不同阶段 ...

  4. easyui 表单验证validatetype——支持自定义验证

    easyui 的validatebox()提供了自定义验证的方法,为此我把一些常用的数据验证汇总了一下,代码如下: 代码 Code highlighting produced by Actipro C ...

  5. angularJS中的表单验证（包括自定义验证）

    表单验证是angularJS一项重要的功能,能保证我们的web应用不会被恶意或错误的输入破坏.Angular表单验证提供了很多表单验证指令,并且能将html5表单验证功能同他自己的验证指令结合起来使用 ...

  6. bootstrapValidator验证表单后清除当次验证的方法

    用bootstrapValidator的resetForm()方法: <!-- // create server begin --> <div class="modal f ...

  7. a标签指定的url，在表单提交前进行js验证的实现

    <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title> ...

  8. JS：JS判断提交表单不能为空等验证

    这段代码在<form>中有οnsubmit="return on_submit()",如果 onsubmit ()返回 fasle,表单的元素就不会提交,即action ...

  9. 使用jquery.validate.js插件进行表单里控件的验证

    jsp中具体实现的代码: <%@ page language="java" contentType="text/html; charset=UTF-8" ...

随机推荐

  1. sql数据库新建作业，新建步骤时报错从 IClassFactory 为 CLSID 为 {AA40D1D6-CAEF-4A56-B9BB-D0D3DC976BA2} 的 COM 组件创建实例失败，原因是出现以下错误: c001f011。 (Microsoft.SqlServer.ManagedDTS)

    简单粗暴的重启sql数据库 其他网上找的方法 32位操作系统: 打开运行(命令提示符), 一.输入 cd c:\windows\system32 进入到c:\windows\system32路径中 二 ...

  2. 乘风破浪，.Net Core遇见MAUI(.NET Multi-platform App UI)，进击现代化跨设备应用框架

    什么是MAUI https://github.com/dotnet/maui .NET Multi-platform App UI (MAUI) 的前身是Xamarin.Forms(适用于Androi ...

  3. 温故知新，DotNet Core SDK和.Net CLI十八般武艺

    简介 .NET命令行接口 (CLI) 工具是用于开发.生成.运行和发布.NET应用程序的跨平台工具链. https://docs.microsoft.com/zh-cn/dotnet/core/too ...

  4. Spring学习日记03_IOC_属性注入_集合类型属性

    Ioc操作Bean管理(xml注入集合属性) 注入数组类型属性 注入List集合类型属性 注入Map集合类型属性 Stu类 public class Stu { //1. 数组类型属性 private ...

  5. 第2章：Kubernetes核心概念

    Kubernetes是Google在2014年开源的一个容器集群管理系统,Kubernetes简称K8S. Kubernetes用于容器化应用程序的部署,扩展和管理,目标是让部署容器化应用简单高效. ...

  6. JS刷新窗口的几种方式

    浮层内嵌iframe及frame集合窗口,刷新父页面的多种方法   <script language=JavaScript>       parent.location.reload(); ...

  7. linux学习之路第四天

    用户和用户组的配置文件

  8. IDA Pro 6.0使用Qt 框架实现了跨平台的UI

    IDA Pro 6.0使用Qt 框架实现了跨平台的UI.它的好处是插件编写者还可以直接使用 Qt 开发跨平台 UI.但是编剧呢? 在这篇博文中,我们将说明如何使用PySide使用IDAPython为 ...

  9. muggle_ocr 下载安装

    pip install -i https://pypi.tuna.tsinghua.edu.cn/simple muggle_ocr

  10. 『心善渊』Selenium3.0基础 — 28、unittest中测试套件的使用

    目录 1.测试套件的作用 2.使用测试套件 (1)入门示例 (2)根据不同的条件加载测试用例(了解) (3)常用方式(推荐) 1.测试套件的作用 在我们实际工作,使用unittest框架会有两个问题: ...