Hibernator-Validator

1.maven
SpringBoot starter-web自动引入其依赖,因为web模块默认使用了hibernate-validator

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

2.model校验
对邮箱进行检测，message用作校验失败时的提示信息。

public class User {
    private Long id;
    private String name;
    private Integer age;
    @Email(message = "邮箱格式错误")
    private String email;
    ..
    ..
}

3.在controller（Rest层）添加校验
参数前需要加上@Validated注解，表明需要spring对其进行校验，而校验的信息会存放到其后的BindingResult中。

@RequestMapping(value = "/addUser", method = RequestMethod.PUT)
    @ResponseBody
    public String addUser(@RequestBody @Validated User user) {
        User u = new User();
        u.setName(user.getName());
        u.setAge(user.getAge());
        userMapper.insert(u);
        return "success";
    }

4.异常捕捉
你可以直接在方法里捕捉反馈验证错误信息

而我是用了全局统一异常的处理

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
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;

@ControllerAdvice
public class MyExceptionHandle {
    private static final Logger logger = LoggerFactory.getLogger(MyExceptionHandle.class);

    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public String handle(Exception e) {

        if (e instanceof MethodArgumentNotValidException) {
            MethodArgumentNotValidException ex=(MethodArgumentNotValidException)e;
            BindingResult bindingResult = ex.getBindingResult();
            StringBuffer stringBuffer = new StringBuffer();
            if(bindingResult.hasErrors()){
                for (FieldError fieldError : bindingResult.getFieldErrors()) {
                    //该格式仅仅作为response展示和log作用，前端应自己做校验
                    stringBuffer.append(fieldError.getObjectName() + "--" +fieldError.getDefaultMessage() + " ");
                }
            }
            logger.error(stringBuffer.toString());
            return HttpStatus.BAD_REQUEST.value()+stringBuffer.toString();
        }
        e.printStackTrace(); // 打印异常栈
        return e.getMessage();
    }

}

测试
因为我用了swagger-ui，所以直接在这里面测试，你们可以访问URL测试

HttpStatus.BAD_REQUEST.value()是检测变量名，getFieldErrors()是一个List。

注意：参数前需要加上@Validated注解，表明需要spring对其进行校验，而校验的信息会存放到其后的BindingResult中。注意，必须相邻，如果有多个参数需要校验，形式可以如下。foo(@Validated Foo foo, BindingResult fooBindingResult ，@Validated Bar bar, BindingResult barBindingResult);即一个校验类对应一个校验结果。

6.分组校验
当我们遇到不同场景需要有不同的校验规则时候，我们可以使用分组校验。如：一个请求只校验id,一个请求只校验email：
新建两个分组（Name,Email）接口

public interface Name{
}

public interface Email{
}

修改实体类

public class User {
    private Long id;
    @Length(min = 2,message = "名字至少2位",groups = {Name.class})
    private String name;
    private Integer age;
    @Email(message = "邮箱格式错误",,groups = {Email.class})
    private String email;
    ..
    ..
}

@Validated属性中指定需要校验的分组名，可以指定1到多个,@Validated({a.class,b.class,...}) 。指定到的分组名会全部进行校验，不指定的不校验,这里我们就只对Name组的验证，而忽略其他的（Email）

    @ResponseBody
    public String addUser(@RequestBody @Validated({Name.class})  User user) {
        User u = new User();
        u.setName(user.getName());
        u.setAge(user.getAge());
        userMapper.insert(u);
        return "success";
    }

测试

7.对象级联校验
对象内部包含另一个对象作为属性，属性上加@Valid（不可以用@Validated，参考10），可以验证作为属性的对象内部的验证，来实现嵌套验证。
现在有个实体叫做Item：

public class Item {

    @NotNull(message = "id不能为空")
    @Min(value = 1, message = "id必须为正整数")
    private Long id;

    @NotNull(message = "props不能为空")
    @Size(min = 1, message = "至少要有一个属性")
    private List<Prop> props;
}

属性这个实体也有自己的验证机制，比如属性和属性值id不能为空，属性名和属性值不能为空等。

public class Prop {

    @NotNull(message = "pid不能为空")
    @Min(value = 1, message = "pid必须为正整数")
    private Long pid;

    @NotNull(message = "vid不能为空")
    @Min(value = 1, message = "vid必须为正整数")
    private Long vid;

    @NotBlank(message = "pidName不能为空")
    private String pidName;

    @NotBlank(message = "vidName不能为空")
    private String vidName;
}

现在我们有个 ItemController 接受一个Item的入参，想要对Item进行验证，如下所示：

@RestController
public class ItemController {

    @RequestMapping("/item/add")
    public void addItem(@Validated Item item, BindingResult bindingResult) {
        doSomething();
    }
}

如果Item实体的props属性不额外加注释，只有@NotNull和@Size，无论入参采用@Validated还是@Valid验证，Spring Validation框架只会对Item的id和vid等属性做非空和数量验证，不会对props字段里的Prop实体进行字段验证，也就是@Validated和@Valid加在方法参数前，都不会自动对参数进行嵌套验证。也就是说如果传的List中有Prop的pid为空或者是负数，入参验证不会检测出来。

为了能够进行嵌套验证，必须手动在Item实体的props字段上明确指出这个字段里面的实体也要进行验证。由于@Validated不能用在成员属性（字段）上，但是@Valid能加在成员属性（字段）上，而且@Valid类注解上也说明了它支持嵌套验证功能，那么我们能够推断出：@Valid加在方法参数时并不能够自动进行嵌套验证，而是用在需要嵌套验证类的相应字段上，来配合方法参数上@Validated或@Valid来进行嵌套验证。
我们修改Item类如下所示：

public class Item {

    @NotNull(message = "id不能为空")
    @Min(value = 1, message = "id必须为正整数")
    private Long id;

    @Valid // 嵌套验证必须用@Valid
    @NotNull(message = "props不能为空")
    @Size(min = 1, message = "props至少要有一个自定义属性")
    private List<Prop> props;
}

然后我们在ItemController的addItem函数上再使用@Validated或者@Valid，就能对Item的入参进行嵌套验证。此时Item里面的props如果含有Prop的相应字段为空的情况，Spring Validation框架就会检测出来，bindingResult就会记录相应的错误。

8.GET参数校验(@RequestParam参数校验)
a.此时需要使用MethodValidationPostProcessor 的Bean
暂时不深究

b.方法所在的Controller上加注解@Validated

@RequestMapping("/validation")
@RestController
@Validated
public class ValidationController {
    /**如果只有少数对象，直接把参数写到Controller层，然后在Controller层进行验证就可以了。*/
    @RequestMapping(value = "/demo3", method = RequestMethod.GET)
    public void demo3(@Range(min = 1, max = 9, message = "年级只能从1-9")
                      @RequestParam(name = "grade", required = true)
                      int grade,
                      @Min(value = 1, message = "班级最小只能1")
                      @Max(value = 99, message = "班级最大只能99")
                      @RequestParam(name = "classroom", required = true)
                      int classroom) {
        System.out.println(grade + "," + classroom);
    }
}

9.hibernate的校验模式
1、普通模式（默认是这个模式）
　　普通模式(会校验完所有的属性，然后返回所有的验证失败信息)。但是在使用组序列验证的时候，如果序列前边的组验证失败，则后面的组将不再给予验证。

2、快速失败返回模式
　　快速失败返回模式(只要有一个验证失败，则返回)

3.如果需要配置为快速失败返回，则编写配置文件
（hibernate.validator.fail_fast：true 快速失败返回模式 false 普通模式）

@Configuration
public class ValidatorConfiguration {
    @Bean
    public Validator validator(){
        ValidatorFactory validatorFactory = Validation.byProvider( HibernateValidator.class )
                .configure()
                .addProperty( "hibernate.validator.fail_fast", "true" )
                .buildValidatorFactory();
        Validator validator = validatorFactory.getValidator();

        return validator;
    }
}

10.@Valid和@Validated的总结区分
Spring Validation验证框架对参数的验证机制提供了@Validated（Spring's JSR-303 规范，是标准 JSR-303 的一个变种），javax提供了@Valid（标准JSR-303规范），配合 BindingResult 可以直接提供参数验证结果。@Validated是@Valid 的一次封装，是Spring提供的校验机制使用。在检验 Controller 的入参是否符合规范时，使用 @Validated 或者 @Valid 在基本验证功能上没有太多区别。但是在分组、注解地方、嵌套验证等功能上两个有所不同：

1. 分组
   @Validated：提供了一个分组功能，可以在入参验证时，根据不同的分组采用不同的验证机制，这个网上也有资料，不详述。@Valid：作为标准JSR-303规范，还没有吸收分组的功能。

2. 注解地方

@Validated：可以用在类型、方法和方法参数上。但是不能用在成员属性（字段）上
@Valid：可以用在方法、构造函数、方法参数和成员属性（字段）上
两者是否能用于成员属性（字段）上直接影响能否提供嵌套验证的功能。

所以可以搭配着用，我习惯是除嵌套验证的属性字段上用@Valid，其他都用@Validated。

---

---

API

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=)  被注释的元素必须在合适的范围内

参考文档：
https://www.cnblogs.com/itrena/p/8833054.html（繁琐但是详细）
https://blog.csdn.net/qq_35703608/article/details/81304608（快速入手）

<--完-->