Spring validation 后端校验【转】

时间 2019-11-17

原文原文链接

本文来自下一秒升华的CSDN 博客，全文地址请点击：https://blog.csdn.net/u013815546/article/details/77248003?utm_source=copy

前言

数据的校验是交互式网站一个不可或缺的功能，前端的js校验能够涵盖大部分的校验职责，如用户名惟一性，生日格式，邮箱格式校验等等经常使用的校验。可是为了不用户绕过浏览器，使用http工具直接向后端请求一些违法数据，服务端的数据校验也是必要的，能够防止脏数据落到数据库中，若是数据库中出现一个非法的邮箱格式，也会让运维人员头疼不已。我在以前保险产品研发过程当中，系统对数据校验要求比较严格且追求可变性及效率，曾使用drools做为规则引擎，兼任了校验的功能。而在通常的应用，可使用本文将要介绍的validation来对数据进行校验。前端

简述JSR303/JSR-349，hibernate validation，spring validation之间的关系。JSR303是一项标准,JSR-349是其的升级版本，添加了一些新特性，他们规定一些校验规范即校验注解，如@Null，@NotNull，@Pattern，他们位于javax.validation.constraints包下，只提供规范不提供实现。而hibernate validation是对这个规范的实践（不要将hibernate和数据库orm框架联系在一块儿），他提供了相应的实现，并增长了一些其余校验注解，如@Email，@Length，@Range等等，他们位于org.hibernate.validator.constraints包下。而万能的spring为了给开发者提供便捷，对hibernate validation进行了二次封装，显示校验validated bean时，你可使用spring validation或者hibernate validation，而spring validation另外一个特性，即是其在springmvc模块中添加了自动校验，并将校验信息封装进了特定的类中。这无疑便捷了咱们的web开发。本文主要介绍在springmvc中自动校验的机制。java

引入依赖

咱们使用maven构建springboot应用来进行demo演示。git

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

咱们只须要引入spring-boot-starter-web依赖便可，若是查看其子依赖，能够发现以下的依赖：web

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

验证了我以前的描述，web模块使用了hibernate-validation，而且databind模块也提供了相应的数据绑定功能。正则表达式

构建启动类

无需添加其余注解，一个典型的启动类spring

@SpringBootApplication
public class ValidateApp {

    public static void main(String[] args) {
        SpringApplication.run(ValidateApp.class, args);
    }
}

建立须要被校验的实体类

public class Foo {

    @NotBlank
    private String name;

    @Min(18)
    private Integer age;

    @Pattern(regexp = "^1(3|4|5|7|8)\\d{9}$",message = "手机号码格式错误")
    @NotBlank(message = "手机号码不能为空")
    private String phone;

    @Email(message = "邮箱格式错误")
    private String email;

    //... getter setter

}

使用一些比较经常使用的校验注解，仍是比较浅显易懂的，字段上的注解名称便可推断出校验内容，每个注解都包含了message字段，用于校验失败时做为提示信息，特殊的校验注解，如Pattern（正则校验），还能够本身添加正则表达式。数据库

在@Controller中校验数据

springmvc为咱们提供了自动封装表单参数的功能，一个添加了参数校验的典型controller以下所示。bootstrap

@Controller
public class FooController {

    @RequestMapping("/foo")
    public String foo(@Validated Foo foo <1>, BindingResult bindingResult <2>) {
        if(bindingResult.hasErrors()){
            for (FieldError fieldError : bindingResult.getFieldErrors()) {
                //...
            }
            return "fail";
        }
        return "success";
    }

}

值得注意的地方：后端

<1> 参数Foo前须要加上@Validated注解，代表须要spring对其进行校验，而校验的信息会存放到其后的BindingResult中。注意，必须相邻，若是有多个参数须要校验，形式能够以下。foo(@Validated Foo foo, BindingResult fooBindingResult ，@Validated Bar bar, BindingResult barBindingResult);即一个校验类对应一个校验结果。浏览器

<2> 校验结果会被自动填充，在controller中能够根据业务逻辑来决定具体的操做，如跳转到错误页面。

一个最基本的校验就完成了，总结下框架已经提供了哪些校验：

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

校验实验

咱们对上面实现的校验入口进行一次测试请求：
访问 http://localhost:8080/foo?name=xujingfeng&email=000&age=19 能够获得以下的debug信息：

实验告诉咱们，校验结果起了做用。而且，能够发现当发生多个错误，spring validation不会在第一个错误发生后当即中止，而是继续试错，告诉咱们全部的错误。debug能够查看到更多丰富的错误信息，这些都是spring validation为咱们提供的便捷特性，基本适用于大多数场景。

你可能不知足于简单的校验特性，下面进行一些补充。

分组校验

若是同一个类，在不一样的使用场景下有不一样的校验规则，那么可使用分组校验。未成年人是不能喝酒的，而在其余场景下咱们不作特殊的限制，这个需求如何体现同一个实体，不一样的校验规则呢？

改写注解，添加分组：

Class Foo{

    @Min(value = 18,groups = {Adult.class})
    private Integer age;

    public interface Adult{}

    public interface Minor{}
}

这样代表，只有在Adult分组下，18岁的限制才会起做用。

Controller层改写：

@RequestMapping("/drink")
public String drink(@Validated({Foo.Adult.class}) Foo foo, BindingResult bindingResult) {
    if(bindingResult.hasErrors()){
        for (FieldError fieldError : bindingResult.getFieldErrors()) {
            //...
        }
        return "fail";
    }
    return "success";
}

@RequestMapping("/live")
public String live(@Validated Foo foo, BindingResult bindingResult) {
    if(bindingResult.hasErrors()){
        for (FieldError fieldError : bindingResult.getFieldErrors()) {
            //...
        }
        return "fail";
    }
    return "success";
}

drink方法限定须要进行Adult校验，而live方法则不作限制。

自定义校验

业务需求老是比框架提供的这些简单校验要复杂的多，咱们能够自定义校验来知足咱们的需求。自定义spring validation很是简单，主要分为两步。

1 自定义校验注解
咱们尝试添加一个“字符串不能包含空格”的限制。

@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = {CannotHaveBlankValidator.class})<1>
public @interface CannotHaveBlank {

    //默认错误消息
    String message() default "不能包含空格";

    //分组
    Class<?>[] groups() default {};

    //负载
    Class<? extends Payload>[] payload() default {};

    //指定多个时使用
    @Target({FIELD, METHOD, PARAMETER, ANNOTATION_TYPE})
    @Retention(RUNTIME)
    @Documented
    @interface List {
        CannotHaveBlank[] value();
    }

}

咱们不须要关注太多东西，使用spring validation的原则即是便捷咱们的开发，例如payload，List ，groups，均可以忽略。

<1> 自定义注解中指定了这个注解真正的验证者类。

2 编写真正的校验者类

public class CannotHaveBlankValidator implements <1> ConstraintValidator<CannotHaveBlank, String> {

    @Override
    public void initialize(CannotHaveBlank constraintAnnotation) {
    }


    @Override
    public boolean isValid(String value, ConstraintValidatorContext context <2>) {
        //null时不进行校验
        if (value != null && value.contains(" ")) {
            <3>
            //获取默认提示信息
            String defaultConstraintMessageTemplate = context.getDefaultConstraintMessageTemplate();
            System.out.println("default message :" + defaultConstraintMessageTemplate);
            //禁用默认提示信息
            context.disableDefaultConstraintViolation();
            //设置提示语
            context.buildConstraintViolationWithTemplate("can not contains blank").addConstraintViolation();
            return false;
        }
        return true;
    }
}

<1> 全部的验证者都须要实现ConstraintValidator接口，它的接口也很形象，包含一个初始化事件方法，和一个判断是否合法的方法。

public interface ConstraintValidator<A extends Annotation, T> {

    void initialize(A constraintAnnotation);

    boolean isValid(T value, ConstraintValidatorContext context);
}

<2> ConstraintValidatorContext 这个上下文包含了认证中全部的信息，咱们能够利用这个上下文实现获取默认错误提示信息，禁用错误提示信息，改写错误提示信息等操做。

<3> 一些典型校验操做，或许能够对你产生启示做用。

值得注意的一点是，自定义注解能够用在METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER之上，ConstraintValidator的第二个泛型参数T，是须要被校验的类型。

手动校验

可能在某些场景下须要咱们手动校验，即便用校验器对须要被校验的实体发起validate，同步得到校验结果。理论上咱们既可使用Hibernate Validation提供Validator，也可使用Spring对其的封装。在spring构建的项目中，提倡使用通过spring封装事后的方法，这里两种方法都介绍下：

Hibernate Validation：

Foo foo = new Foo();
foo.setAge(22);
foo.setEmail("000");
ValidatorFactory vf = Validation.buildDefaultValidatorFactory();
Validator validator = vf.getValidator();
Set<ConstraintViolation<Foo>> set = validator.validate(foo);
for (ConstraintViolation<Foo> constraintViolation : set) {
    System.out.println(constraintViolation.getMessage());
}

因为依赖了Hibernate Validation框架，咱们须要调用Hibernate相关的工厂方法来获取validator实例，从而校验。

在spring framework文档的Validation相关章节，能够看到以下的描述：

Spring provides full support for the Bean Validation API. This includes convenient support for bootstrapping a JSR-303/JSR-349 Bean Validation provider as a Spring bean. This allows for a javax.validation.ValidatorFactory or javax.validation.Validator to be injected wherever validation is needed in your application. Use the LocalValidatorFactoryBean to configure a default Validator as a Spring bean:

bean id=”validator” class=”org.springframework.validation.beanvalidation.LocalValidatorFactoryBean”

The basic configuration above will trigger Bean Validation to initialize using its default bootstrap mechanism. A JSR-303/JSR-349 provider, such as Hibernate Validator, is expected to be present in the classpath and will be detected automatically.

上面这段话主要描述了spring对validation全面支持JSR-30三、JSR-349的标准，而且封装了LocalValidatorFactoryBean做为validator的实现。值得一提的是，这个类的责任实际上是很是重大的，他兼容了spring的validation体系和hibernate的validation体系，也能够被开发者直接调用，代替上述的从工厂方法中获取的hibernate validator。因为咱们使用了springboot，会触发web模块的自动配置，LocalValidatorFactoryBean已经成为了Validator的默认实现，使用时只须要自动注入便可。

@Autowired
Validator globalValidator; <1>

@RequestMapping("/validate")
public String validate() {
    Foo foo = new Foo();
    foo.setAge(22);
    foo.setEmail("000");

    Set<ConstraintViolation<Foo>> set = globalValidator.validate(foo);<2>
    for (ConstraintViolation<Foo> constraintViolation : set) {
        System.out.println(constraintViolation.getMessage());
    }

    return "success";
}

<1> 真正使用过Validator接口的读者会发现有两个接口，一个是位于javax.validation包下，另外一个位于org.springframework.validation包下，注意咱们这里使用的是前者javax.validation，后者是spring本身内置的校验接口，LocalValidatorFactoryBean同时实现了这两个接口。

<2> 此处校验接口最终的实现类即是LocalValidatorFactoryBean。

基于方法校验

@RestController
@Validated <1>
public class BarController {

    @RequestMapping("/bar")
    public @NotBlank <2> String bar(@Min(18) Integer age <3>) {
        System.out.println("age : " + age);
        return "";
    }

    @ExceptionHandler(ConstraintViolationException.class)
    public Map handleConstraintViolationException(ConstraintViolationException cve){
        Set<ConstraintViolation<?>> cves = cve.getConstraintViolations();<4>
        for (ConstraintViolation<?> constraintViolation : cves) {
            System.out.println(constraintViolation.getMessage());
        }
        Map map = new HashMap();
        map.put("errorCode",500);
        return map;
    }

}

<1> 为类添加@Validated注解

<2> <3> 校验方法的返回值和入参

<4> 添加一个异常处理器，能够得到没有经过校验的属性相关信息

基于方法的校验，我的不推荐使用，感受和项目结合的不是很好。

使用校验框架的一些想法

理论上spring validation能够实现不少复杂的校验，你甚至可使你的Validator获取ApplicationContext，获取spring容器中全部的资源，进行诸如数据库校验，注入其余校验工具，完成组合校验（如先后密码一致）等等操做，可是寻求一个易用性和封装复杂性之间的平衡点是咱们做为工具使用者应该考虑的，我推崇的方式，是仅仅使用自带的注解和自定义注解，完成一些简单的，可复用的校验。而对于复杂的校验，则包含在业务代码之中，毕竟如用户名是否存在这样的校验，仅仅依靠数据库查询还不够，为了不并发问题，仍是得加上惟一索引之类的额外工做，不是吗？