springboot中hibernate validator校验之简单使用

妖狐艹你老母 2022-10-14 14:55 149阅读 0赞

在开发中经常需要写一些字段校验的代码，比如字段非空，字段长度限制，邮箱格式验证等等，如果在业务逻辑到处都有这种代码会显得：

*  验证代码繁琐，重复劳动
 *  方法内代码显得冗长
 *  每次要看哪些参数验证是否完整，需要去翻阅验证逻辑代码

hibernate validator提供了一套比较完善、便捷的验证实现方式。

先来看一个简单的demo：

# pom.xml #

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.morris</groupId>
        <artifactId>validator-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <properties>
            <maven.compiler.source>8</maven.compiler.source>
            <maven.compiler.target>8</maven.compiler.target>
            <spring-boot.version>2.3.4.RELEASE</spring-boot.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-validation</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>
    
        <dependencyManagement>
            <dependencies>
                
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>${spring-boot.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
    </project>

# application.properties #

server.port=8080
    server.servlet.context-path=/

# Application.java #

package com.morris.validator;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class Application { 
    
        public static void main(String[] args) { 
            SpringApplication.run(Application.class, args);
        }
    }

# R.java #

package com.morris.validator.vo;
    
    import lombok.Data;
    import org.springframework.http.HttpStatus;
    
    import java.io.Serializable;
    
    @Data
    public final class R<T> implements Serializable { 
    
        private static final long serialVersionUID = 1L;
    
        private int code;
    
        private String message;
        private T result;
    
        private R() { 
        }
    
        private R(int code, String message, T result) { 
            this.code = code;
            this.message = message;
            this.result = result;
        }
    
        public static R ok() { 
            return new R(HttpStatus.OK.value(), HttpStatus.OK.getReasonPhrase(), null);
        }
    
        public static R ok(String msg) { 
            return new R(HttpStatus.OK.value(), HttpStatus.OK.getReasonPhrase(), null);
        }
    
        public static R ok(Object data) { 
            return new R(HttpStatus.OK.value(), HttpStatus.OK.getReasonPhrase(), data);
        }
    
        public static R fail() { 
            return new R(HttpStatus.INTERNAL_SERVER_ERROR.value(), HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(), null);
        }
    
        public static R fail(String msg) { 
            return new R(HttpStatus.INTERNAL_SERVER_ERROR.value(), msg, null);
        }
    
        public static R fail(int code, String msg) { 
            return new R(code, msg, null);
    
        }
    
        public static R fail(int code, String msg, Object data) { 
            return new R(code, msg, data);
    
        }
    
        public static R fail(Object data) { 
            return new R(HttpStatus.INTERNAL_SERVER_ERROR.value(), HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(), data);
        }
    
    }

# GlobalExceptionHandler.java #

package com.morris.validator.advice;
    
    import com.morris.validator.vo.R;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.http.HttpStatus;
    import org.springframework.validation.BindException;
    import org.springframework.validation.BindingResult;
    import org.springframework.validation.ObjectError;
    import org.springframework.web.bind.MethodArgumentNotValidException;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    
    @RestControllerAdvice
    @Slf4j
    public class GlobalExceptionHandler { 
    
        @ExceptionHandler(value = { BindException.class, MethodArgumentNotValidException.class})
        public R handleBindException(Exception e) { 
            BindingResult bindingResult = null;
            if(e instanceof BindException) { 
                bindingResult = ((BindException) e).getBindingResult();
            }
            if(e instanceof MethodArgumentNotValidException) { 
                bindingResult = ((MethodArgumentNotValidException) e).getBindingResult();
            }
            log.error("参数绑定校验异常", e);
            return wrapperBindingResult(bindingResult);
        }
    
        private R wrapperBindingResult(BindingResult bindingResult) { 
            StringBuilder msg = new StringBuilder();
            for (ObjectError error : bindingResult.getAllErrors()) { 
                msg.append(", ");
                msg.append(error.getDefaultMessage() == null ? "" : error.getDefaultMessage());
            }
            return R.fail(HttpStatus.BAD_REQUEST.value(), msg.substring(2));
        }
    }

# UserController.java #

package com.morris.validator.controller;
    
    import com.morris.validator.vo.R;
    import com.morris.validator.vo.User;
    import org.springframework.web.bind.annotation.*;
    
    import javax.validation.Valid;
    
    @RestController
    @RequestMapping("user")
    public class UserController { 
    
        @PostMapping("add")
        public R add(@Valid @RequestBody User user) { 
            return R.ok();
        }
    
    }

# User.java #

package com.morris.validator.vo;
    
    
    import lombok.Data;
    import org.hibernate.validator.constraints.Range;
    
    import javax.validation.constraints.AssertFalse;
    import javax.validation.constraints.NotBlank;
    import javax.validation.constraints.NotNull;
    import javax.validation.constraints.Pattern;
    
    @Data
    public class User { 
        @NotBlank(message = "用户名[userName]不能为空")
        private String userName;
    
        @NotNull(message = "年龄[age]不能为空")
        @Range(min= 1, max= 150, message = "年龄[age]的范围为[{min}, {max}]")
        private Integer age;
    
        @AssertFalse(message = "isFalse必须为false")
        private Boolean isFalse;
    
        @Pattern(regexp = "^[0-9]{4}-[0-9]{2}-[0-9]{2}$", message = "出生日期格式不正确")
        private String birthday;
    }

# 测试 #

# curl -X POST http://localhost:8080/user/add -H "content-type:application/json" -d '{"userName":"xx", "age": 10}'
    { "code":200,"message":"OK","result":null}
    
    # curl -X POST http://localhost:8080/user/add -H "content-type:application/json" -d '{"userName":"xx", "age": 200}'
    { "code":400,"message":"年龄[age]的范围为[1, 150]","result":null}

# 常见的注解约束 #

Hibernate Validation中内置的constraint如下表：

<table> 
 <thead> 
  <tr> 
   <th>注解</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@Null</td> 
   <td>被注释的元素必须为null</td> 
  </tr> 
  <tr> 
   <td>@NotNull</td> 
   <td>被注释的元素必须不为null</td> 
  </tr> 
  <tr> 
   <td>@AssertTrue</td> 
   <td>被注释的元素必须为true</td> 
  </tr> 
  <tr> 
   <td>@AssertFalse</td> 
   <td>被注释的元素必须为false</td> 
  </tr> 
  <tr> 
   <td>@Min(value)</td> 
   <td>被注释的元素必须是一个数字，其值必须大于等于指定的最小值</td> 
  </tr> 
  <tr> 
   <td>@Max(value)</td> 
   <td>被注释的元素必须是一个数字，其值必须小于等于指定的最大值</td> 
  </tr> 
  <tr> 
   <td>@DecimalMin(value)</td> 
   <td>被注释的元素必须是一个数字，其值必须大于等于指定的最小值</td> 
  </tr> 
  <tr> 
   <td>@DecimalMax(value)</td> 
   <td>被注释的元素必须是一个数字，其值必须小于等于指定的最大值</td> 
  </tr> 
  <tr> 
   <td>@Size(max=, min=)</td> 
   <td>被注释的元素的大小必须在指定的范围内</td> 
  </tr> 
  <tr> 
   <td>@Digits (integer, fraction)</td> 
   <td>被注释的元素必须是一个数字，其值必须在可接受的范围内</td> 
  </tr> 
  <tr> 
   <td>@Past</td> 
   <td>被注释的元素必须是一个过去的日期</td> 
  </tr> 
  <tr> 
   <td>@Future</td> 
   <td>被注释的元素必须是一个将来的日期</td> 
  </tr> 
  <tr> 
   <td>@Pattern(regex=,flag=)</td> 
   <td>被注释的元素必须符合指定的正则表达式</td> 
  </tr> 
  <tr> 
   <td>@NotBlank(message =)</td> 
   <td>验证字符串非null，且长度必须大于0</td> 
  </tr> 
  <tr> 
   <td>@Email</td> 
   <td>被注释的元素必须是电子邮箱地址</td> 
  </tr> 
  <tr> 
   <td>@Length(min=,max=)</td> 
   <td>被注释的字符串的大小必须在指定的范围内</td> 
  </tr> 
  <tr> 
   <td>@NotEmpty</td> 
   <td>被注释的字符串的必须非空</td> 
  </tr> 
  <tr> 
   <td>@Range(min=,max=,message=)</td> 
   <td>被注释的元素必须在合适的范围内</td> 
  </tr> 
 </tbody> 
</table>