spring boot之服务端接口数据的验证（spring Validation）

小咪咪 2022-01-26 14:21 279阅读 0赞

### spring boot之服务端接口数据的验证（spring Validation） ###

*  服务端验证
 *   *  创建服务端DEMO工程
     *  工程包目录结构
     *  验证的注解列表
     *  日期验证的扩展实现
     *  实体的验证的实现
     *  接口层实现逻辑的验证
     *  关注点

# 服务端验证 #

传统的我们的服务端的验证模式直接在我们的代码中直接编写相应的验证逻辑，这样编写出来的代码又臭又长，而spring validation则为我们提供了更加优雅的验证方式，使得我们的验证代码变得简洁。

## 创建服务端DEMO工程 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70]

## 工程包目录结构 ##

接着创建如下的包的目录结构  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70 1]

1.  config：用于存放我们的配置文件的包
2.  constant：用于存放我们的常量的包
3.  controller：用于存放我们的controller的实现的包
4.  entity：用于存放我们的实体类的包
5.  validate：用于存放我们自己编写的验证类的包

## 验证的注解列表 ##

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

## 日期验证的扩展实现 ##

当我们的接口中有一个字段是用于接收字符串类型的日期的时候，我们需要验证该日期是否合法，那么我们可以使用如下的形式进行扩展，首先在我们的validate包底下增加一个DateTimeValidator验证日期的逻辑实现和DateTime注解，代码分别如下所示：

package com.validate.demo.validate;
    
    import javax.validation.ConstraintValidator;
    import javax.validation.ConstraintValidatorContext;
    import java.text.SimpleDateFormat;
    
    /**
     * @author linzf
     * @since 2019-05-29
     * 类描述：验证日期是否合法的实现类
     */
    public class DateTimeValidator implements ConstraintValidator<DateTime, String> {
        private DateTime dateTime;
    
        @Override
        public void initialize(DateTime dateTime) {
            this.dateTime = dateTime;
        }
    
        @Override
        public boolean isValid(String value, ConstraintValidatorContext context) {
            // 如果 value 为空则不进行格式验证，为空验证可以使用 @NotBlank @NotNull @NotEmpty 等注解来进行控制，职责分离
            if (value == null) {
                return true;
            }
            String format = dateTime.format();
    
            if (value.length() != format.length()) {
                return false;
            }
    
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
    
            try {
                simpleDateFormat.parse(value);
            } catch (Exception e) {
                return false;
            }
            return true;
        }
    }

DateTime.java 代码如下：

package com.validate.demo.validate;
    
    import javax.validation.Constraint;
    import javax.validation.Payload;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * @author linzf
     * @since 2019-05-29
     * 类描述：验证日期是否合法
     */
    @Target({ElementType.FIELD, ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    @Constraint(validatedBy = DateTimeValidator.class)
    public @interface DateTime {
    
        String message() default "格式错误";
    
        String format() default "yyyyMM";
    
        Class<?>[] groups() default {};
    
        Class<? extends Payload>[] payload() default {};
    }

那么到此处我们就完成了我们的日期的验证了，同理理论上所有的自定义的验证我们都可以使用如上的方式进行扩展验证我们的逻辑。

## 实体的验证的实现 ##

在我们的entity底下创建一个user实体类，同时在entity包底下创建一个user包，在该包底下创建一个userGroup.java文件，该类主要是用于来定义我们的验证的分组类，在该类里面我们定义了AddUser和UpdateUser这两个分组验证，若是还需要其他的分组验证可以自己去扩展。

package com.validate.demo.entity.user;
    
    /**
     * @author linzf
     * @since 2019-05-29
     * 类描述：验证分组
     */
    public class UserGroup {
    
        /**
         * 表示当前的验证为新增数据的时候的验证
         */
        public interface AddUser{}
    
        /**
         * 表示当前的验证为修改数据的时候的验证
         */
        public interface UpdateUser{}
    
    }

接着我们新建一个user实体在此处代码中我们的userName只有在新增的时候才需要进行验证，其他时候不需要验证，而我们的nickName、age、email、phone、birthDate则是需要我们在新增和更新的时候都需要验证的，代码如下：

package com.validate.demo.entity;
    
    import com.validate.demo.constant.ValidatePatternConstants;
    import com.validate.demo.entity.user.UserGroup;
    import com.validate.demo.validate.DateTime;
    
    import javax.validation.constraints.*;
    
    /**
     * @author linzf
     * @since 2019-05-29
     * 类描述：用户的实体类
     */
    public class User {
    
        /**
         * 用户账号
         * groups 进行分组校验
         */
        @NotBlank(message = "用户账号不能为空！", groups = UserGroup.AddUser.class)
        @Size(min = 5, max = 15, message = "用户账号长度必须在5到15之间", groups = UserGroup.AddUser.class)
        private String userName;
    
        /**
         * 用户名称
         */
        @NotBlank(message = "用户名称不能为空", groups = {UserGroup.AddUser.class, UserGroup.UpdateUser.class})
        private String nickName;
    
        /**
         * 用户年龄
         */
        @Max(value = 100, message = "用户年龄最大值不能超过150岁", groups = {UserGroup.AddUser.class, UserGroup.UpdateUser.class})
        @Min(value = 1, message = "用户年龄最小值不能低于1岁", groups = {UserGroup.AddUser.class, UserGroup.UpdateUser.class})
        private int age;
    
        /**
         * 用户邮箱
         */
        @Email(message = "邮箱格式错误",groups = {UserGroup.AddUser.class, UserGroup.UpdateUser.class})
        private String email;
    
        /**
         * 手机号码的验证
         */
        @Pattern(regexp = ValidatePatternConstants.PHONE_VALIDATE, message = "手机号码格式错误",groups = {UserGroup.AddUser.class, UserGroup.UpdateUser.class})
        @NotBlank(message = "手机号码不能为空",groups = {UserGroup.AddUser.class, UserGroup.UpdateUser.class})
        private String phone;
    
        /**
         * 用户出生日期
         */
        @DateTime(format = "yyyy-MM-dd", message = "格式错误，正确格式为：yyyy-MM-dd",groups = {UserGroup.AddUser.class, UserGroup.UpdateUser.class})
        private String birthDate;
    
        public String getPhone() {
            return phone;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public String getNickName() {
            return nickName;
        }
    
        public void setNickName(String nickName) {
            this.nickName = nickName;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getEmail() {
            return email;
        }
    
        public void setEmail(String email) {
            this.email = email;
        }
    
        public String getBirthDate() {
            return birthDate;
        }
    
        public void setBirthDate(String birthDate) {
            this.birthDate = birthDate;
        }
    }

到此处我们只是完成了我们的验证的逻辑规则的编写，但是还没有正式的生效。

## 接口层实现逻辑的验证 ##

那么我们在controller包底下新增UserController的代码，其中addUser接口用于验证我们的新增的接口的验证，updateUser接口用于验证我们的更新的接口的验证，noValidate接口不验证任何入参数据，deleteUser接口用于验证参数级的接口的验证，代码如下：

package com.validate.demo.controller;
    
    import com.validate.demo.entity.User;
    import com.validate.demo.entity.user.UserGroup;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.validation.constraints.Size;
    
    /**
     * @author linzf
     * @since 2019-05-29
     * 类描述：用户的controller类
     */
    @RestController
    @Validated
    public class UserController {
    
        @PostMapping("addUser")
        public String addUser(@Validated({UserGroup.AddUser.class}) @RequestBody User entity) {
            return entity.getUserName();
        }
    
        @PostMapping("updateUser")
        public String updateUser(@Validated({UserGroup.UpdateUser.class}) @RequestBody User entity) {
            return entity.getUserName();
        }
    
    
        @PostMapping("noValidate")
        public String noValidate(@RequestBody User entity){
            return entity.getUserName();
        }
    
        @PostMapping("deleteUser")
        public String deleteUser(@Size(min = 5, max = 15, message = "用户账号长度必须在5到15之间") @RequestParam("userName") String userName) {
            return userName;
        }
    
    }

如果是参数级的接口验证，一定要记得在我们的controller类上加上@Validated注解否则不会去验证。  
接着我们启动我们的工程，然后用swagger去验证我们的接口【如何集成swagger就不再此处累述】，当我们使用新增用户的接口的时候若我们的入参是：

{
      "age": 0,
      "birthDate": "string",
      "email": "string",
      "nickName": "string",
      "phone": "string",
      "userName": "string"
    }

那么我们将会在前端收到以下的返回：

{
      "timestamp": "2019-05-29T06:00:19.643+0000",
      "status": 400,
      "error": "Bad Request",
      "errors": [
        {
          "codes": [
            "DateTime.user.birthDate",
            "DateTime.birthDate",
            "DateTime.java.lang.String",
            "DateTime"
          ],
          "arguments": [
            {
              "codes": [
                "user.birthDate",
                "birthDate"
              ],
              "arguments": null,
              "defaultMessage": "birthDate",
              "code": "birthDate"
            },
            {
              "arguments": null,
              "defaultMessage": "yyyy-MM-dd",
              "codes": [
                "yyyy-MM-dd"
              ]
            }
          ],
          "defaultMessage": "格式错误，正确格式为：yyyy-MM-dd",
          "objectName": "user",
          "field": "birthDate",
          "rejectedValue": "string",
          "bindingFailure": false,
          "code": "DateTime"
        },
        {
          "codes": [
            "Min.user.age",
            "Min.age",
            "Min.int",
            "Min"
          ],
          "arguments": [
            {
              "codes": [
                "user.age",
                "age"
              ],
              "arguments": null,
              "defaultMessage": "age",
              "code": "age"
            },
            1
          ],
          "defaultMessage": "用户年龄最小值不能低于1岁",
          "objectName": "user",
          "field": "age",
          "rejectedValue": 0,
          "bindingFailure": false,
          "code": "Min"
        },
        {
          "codes": [
            "Email.user.email",
            "Email.email",
            "Email.java.lang.String",
            "Email"
          ],
          "arguments": [
            {
              "codes": [
                "user.email",
                "email"
              ],
              "arguments": null,
              "defaultMessage": "email",
              "code": "email"
            },
            [],
            {
              "arguments": null,
              "defaultMessage": ".*",
              "codes": [
                ".*"
              ]
            }
          ],
          "defaultMessage": "邮箱格式错误",
          "objectName": "user",
          "field": "email",
          "rejectedValue": "string",
          "bindingFailure": false,
          "code": "Email"
        },
        {
          "codes": [
            "Pattern.user.phone",
            "Pattern.phone",
            "Pattern.java.lang.String",
            "Pattern"
          ],
          "arguments": [
            {
              "codes": [
                "user.phone",
                "phone"
              ],
              "arguments": null,
              "defaultMessage": "phone",
              "code": "phone"
            },
            [],
            {
              "arguments": null,
              "defaultMessage": "^1(3|4|5|7|8)\\d{9}$",
              "codes": [
                "^1(3|4|5|7|8)\\d{9}$"
              ]
            }
          ],
          "defaultMessage": "手机号码格式错误",
          "objectName": "user",
          "field": "phone",
          "rejectedValue": "string",
          "bindingFailure": false,
          "code": "Pattern"
        }
      ],
      "message": "Validation failed for object='user'. Error count: 4",
      "path": "/addUser"
    }

那么这很明显是我们不希望这样返回给前端，因此我们需要在config配置文件中配置全局异常捕获，这样我们就可以按照固定的格式返回给前端，因此我们在config底下添加GlobalExceptionsHandler全局异常捕获配置文件代码如下：

package com.validate.demo.config;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.HttpStatus;
    import org.springframework.validation.BindException;
    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 org.springframework.web.context.request.WebRequest;
    
    import javax.validation.ConstraintViolationException;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author linzf
     * @since 2019/5/29
     * 类描述：全局异常捕获处理
     */
    @ControllerAdvice
    public class GlobalExceptionsHandler {
    
        private Logger log = LoggerFactory.getLogger(GlobalExceptionsHandler.class);
    
        /**
         * 功能描述：全局异常处理
         *
         * @param e
         * @return 返回处理结果
         * @throws Exception
         */
        @ExceptionHandler(value = Exception.class)
        @ResponseBody
        public Object errorHandler(Exception e) throws Exception {
            Map<String,Object> result = new HashMap<>(2);
            // 此处为属性级的错误日志的处理
            if (e instanceof ConstraintViolationException) {
                log.info("绑定错误日志为：{}", e.getMessage());
                result.put("success",false);
                result.put("msg","数据非法");
                // 此处为方法级别的错误日志处理
            } else if (e instanceof MethodArgumentNotValidException) {
                log.info("方法级的绑定错误日志为：{}", e.getMessage());
                result.put("success",false);
                result.put("msg","数据非法");
                // 此处为全局错误日志的处理
            } else {
                result.put("success",false);
                result.put("msg","系统异常");
                log.info("错误日志为：{}", e.getMessage());
            }
            return result;
        }
    
    
    }

然后我们重启我们的项目，接着调用我们的新增用户的接口，然后就会看到我们所希望的结果。  
![在这里插入图片描述][20190529141008832.png]  
那么到此处我们就完成了我们的接口的验证的例子了，具体代码大家直接查看github：  
[https://github.com/lazyboyl/validate-demo][https_github.com_lazyboyl_validate-demo]

## 关注点 ##

1.  若接口是用实体类接的一定要在接口上加@Validated注解
2.  若接口是用参数接的一定要在controller上加@Validated注解
3.  若希望接口不要验证就不要加@Validated注解

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70]: /images/20220126/2112ce48b8094268b585a15f94c002bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70 1]: /images/20220126/7da9fd57a3bf474fb3babdd535ef5520.png
[20190529141008832.png]: /images/20220126/ab53079610cb422cba3bb1beb26c2981.png
[https_github.com_lazyboyl_validate-demo]: https://github.com/lazyboyl/validate-demo