Spring Boot 實作各種參數校驗，寫得太好了……

之前也寫過一篇關于Spring Validation使用的文章，不過自我感覺還是浮于表面，本次打算徹底搞懂Spring Validation。

本文會詳細介紹Spring Validation各種場景下的最佳實踐及其實作原理，死磕到底！

項目源碼：spring-validation(https://github.com/chentianming11/spring-validation)

簡單使用

Java API規範(JSR303)定義了Bean校驗的标準validation-api，但沒有提供實作。hibernate validation是對這個規範的實作，并增加了校驗注解如@Email、@Length等。

Spring Validation是對hibernate validation的二次封裝，用于支援spring mvc參數自動校驗。接下來，我們以spring-boot項目為例，介紹Spring Validation的使用。

引入依賴

如果spring-boot版本小于2.3.x，spring-boot-starter-web會自動傳入hibernate-validator依賴。如果spring-boot版本大于2.3.x，則需要手動引入依賴：

推薦一個 Spring Boot 基礎教程及實戰示例： https://github.com/javastacks/spring-boot-best-practice

對于web服務來說，為防止非法參數對業務造成影響，在Controller層一定要做參數校驗的！大部分情況下，請求參數分為如下兩種形式：

POST、PUT請求，使用requestBody傳遞參數；

GET請求，使用requestParam/PathVariable傳遞參數。

下面我們簡單介紹下requestBody和requestParam/PathVariable的參數校驗實戰！

requestBody參數校驗

POST、PUT請求一般會使用requestBody傳遞參數，這種情況下，後端使用DTO對象進行接收。隻要給DTO對象加上@Validated注解就能實作自動參數校驗。

比如，有一個儲存User的接口，要求userName長度是2-10，account和password字段長度是6-20。如果校驗失敗，會抛出MethodArgumentNotValidException異常，Spring預設會将其轉為400（Bad Request）請求。

DTO表示資料傳輸對象（Data Transfer Object），用于伺服器和用戶端之間互動傳輸使用的。在spring-web項目中可以表示用于接收請求參數的Bean對象。

在DTO字段上聲明限制注解

這種情況下，使用@Valid和@Validated都可以。

requestParam/PathVariable參數校驗

GET請求一般會使用requestParam/PathVariable傳參。如果參數比較多(比如超過6個)，還是推薦使用DTO對象接收。否則，推薦将一個個參數平鋪到方法入參中。

在這種情況下，必須在Controller類上标注@Validated注解，并在入參上聲明限制注解(如@Min等)。如果校驗失敗，會抛出ConstraintViolationException異常。代碼示例如下：

@RequestMapping("/api/user")
@RestController
@Validated
public class UserController {
    // 路徑變量
    @GetMapping("{userId}")
    public Result detail(@PathVariable("userId") @Min(10000000000000000L) Long userId) {
        // 校驗通過，才會執行業務邏輯處理
        UserDTO userDTO = new UserDTO();
        userDTO.setUserId(userId);
        userDTO.setAccount("11111111111111111");
        userDTO.setUserName("xixi");
        userDTO.setAccount("11111111111111111");
        return Result.ok(userDTO);
    }

    // 查詢參數
    @GetMapping("getByAccount")
    public Result getByAccount(@Length(min = 6, max = 20) @NotNull String  account) {
        // 校驗通過，才會執行業務邏輯處理
        UserDTO userDTO = new UserDTO();
        userDTO.setUserId(10000000000000003L);
        userDTO.setAccount(account);
        userDTO.setUserName("xixi");
        userDTO.setAccount("11111111111111111");
        return Result.ok(userDTO);
    }
}

統一異常處理

前面說過，如果校驗失敗，會抛出MethodArgumentNotValidException或者ConstraintViolationException異常。在實際項目開發中，通常會用統一異常處理來傳回一個更友好的提示。

比如我們系統要求無論發送什麼異常，http的狀态碼必須傳回200，由業務碼去區分系統的異常情況。

@RestControllerAdvice
public class CommonExceptionHandler {

    @ExceptionHandler({MethodArgumentNotValidException.class})
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    public Result handleMethodArgumentNotValidException(MethodArgumentNotValidException ex) {
        BindingResult bindingResult = ex.getBindingResult();
        StringBuilder sb = new StringBuilder("校驗失敗:");
        for (FieldError fieldError : bindingResult.getFieldErrors()) {
            sb.append(fieldError.getField()).append("：").append(fieldError.getDefaultMessage()).append(", ");
        }
        String msg = sb.toString();
       return Result.fail(BusinessCode.參數校驗失敗, msg);
    }

    @ExceptionHandler({ConstraintViolationException.class})
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    public Result handleConstraintViolationException(ConstraintViolationException ex) {
        return Result.fail(BusinessCode.參數校驗失敗, ex.getMessage());
    }
}

進階使用

分組校驗

在實際項目中，可能多個方法需要使用同一個DTO類來接收參數，而不同方法的校驗規則很可能是不一樣的。這個時候，簡單地在DTO類的字段上加限制注解無法解決這個問題。

是以，spring-validation支援了分組校驗的功能，專門用來解決這類問題。還是上面的例子，比如儲存User的時候，UserId是可空的，但是更新User的時候，UserId的值必須>=10000000000000000L；其它字段的校驗規則在兩種情況下一樣。這個時候使用分組校驗的代碼示例如下：

限制注解上聲明适用的分組資訊groups

@Data
public class UserDTO {

    @Min(value = 10000000000000000L, groups = Update.class)
    private Long userId;

    @NotNull(groups = {Save.class, Update.class})
    @Length(min = 2, max = 10, groups = {Save.class, Update.class})
    private String userName;

    @NotNull(groups = {Save.class, Update.class})
    @Length(min = 6, max = 20, groups = {Save.class, Update.class})
    private String account;

    @NotNull(groups = {Save.class, Update.class})
    @Length(min = 6, max = 20, groups = {Save.class, Update.class})
    private String password;

    /**
     * 儲存的時候校驗分組
     */
    public interface Save {
    }

    /**
     * 更新的時候校驗分組
     */
    public interface Update {
    }
}

@Validated 注解上指定校驗分組

@PostMapping("/save")
public Result saveUser(@RequestBody @Validated(UserDTO.Save.class) UserDTO userDTO) {
    // 校驗通過，才會執行業務邏輯處理
    return Result.ok();
}

@PostMapping("/update")
public Result updateUser(@RequestBody @Validated(UserDTO.Update.class) UserDTO userDTO) {
    // 校驗通過，才會執行業務邏輯處理
    return Result.ok();
}

嵌套校驗

前面的示例中，

DTO

類裡面的字段都是

基本資料類型

和

String

類型。但是實際場景中，有可能某個字段也是一個對象，這種情況先，可以使用

嵌套校驗

。

比如，上面儲存

User

資訊的時候同時還帶有

Job

資訊。需要注意的是，此時

DTO

類的對應字段必須标記

@Valid

注解。

@Data
public class UserDTO {

    @Min(value = 10000000000000000L, groups = Update.class)
    private Long userId;

    @NotNull(groups = {Save.class, Update.class})
    @Length(min = 2, max = 10, groups = {Save.class, Update.class})
    private String userName;

    @NotNull(groups = {Save.class, Update.class})
    @Length(min = 6, max = 20, groups = {Save.class, Update.class})
    private String account;

    @NotNull(groups = {Save.class, Update.class})
    @Length(min = 6, max = 20, groups = {Save.class, Update.class})
    private String password;

    @NotNull(groups = {Save.class, Update.class})
    @Valid
    private Job job;

    @Data
    public static class Job {

        @Min(value = 1, groups = Update.class)
        private Long jobId;

        @NotNull(groups = {Save.class, Update.class})
        @Length(min = 2, max = 10, groups = {Save.class, Update.class})
        private String jobName;

        @NotNull(groups = {Save.class, Update.class})
        @Length(min = 2, max = 10, groups = {Save.class, Update.class})
        private String position;
    }

    /**
     * 儲存的時候校驗分組
     */
    public interface Save {
    }

    /**
     * 更新的時候校驗分組
     */
    public interface Update {
    }
}

嵌套校驗可以結合分組校驗一起使用。還有就是嵌套集合校驗會對集合裡面的每一項都進行校驗，例如List<Job>字段會對這個list裡面的每一個Job對象都進行校驗。

集合校驗

如果請求體直接傳遞了json數組給背景，并希望對數組中的每一項都進行參數校驗。此時，如果我們直接使用java.util.Collection下的list或者set來接收資料，參數校驗并不會生效！我們可以使用自定義list集合來接收參數：

包裝List類型，并聲明@Valid注解

public class ValidationList<E> implements List<E> {

    @Delegate // @Delegate是lombok注解
    @Valid // 一定要加@Valid注解
    public List<E> list = new ArrayList<>();

    // 一定要記得重寫toString方法
    @Override
    public String toString() {
        return list.toString();
    }
}

@Delegate

注解受

lombok

版本限制，

1.18.6

以上版本可支援。如果校驗不通過，會抛出

NotReadablePropertyException

，同樣可以使用統一異常進行處理。

比如，我們需要一次性儲存多個

User

對象，

Controller

層的方法可以這麼寫：

自定義校驗

業務需求總是比架構提供的這些簡單校驗要複雜的多，我們可以自定義校驗來滿足我們的需求。自定義spring validation非常簡單，假設我們自定義加密id（由數字或者a-f的字母組成，32-256長度）校驗，主要分為兩步：

自定義限制注解

這樣我們就可以使用

@EncryptId

進行參數校驗了！

程式設計式校驗

上面的示例都是基于

注解

來實作自動校驗的，在某些情況下，我們可能希望以

程式設計方式

調用驗證。這個時候可以注入

javax.validation.Validator

對象，然後再調用其

api

@Valid和@Validated差別

差別 @Valid @Validated

提供者 JSR-303規範 Spring

是否支援分組不支援支援

标注位置 METHOD, FIELD, CONSTRUCTOR, PARAMETER, TYPE_USE TYPE, METHOD, PARAMETER

嵌套校驗支援不支援

實作原理

requestBody參數校驗實作原理

在spring-mvc中，RequestResponseBodyMethodProcessor是用于解析@RequestBody标注的參數以及處理@ResponseBody标注方法的傳回值的。顯然，執行參數校驗的邏輯肯定就在解析參數的方法resolveArgument()中：

public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMet

public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor {
    @Override
    public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

        parameter = parameter.nestedIfOptional();
        //将請求資料封裝到DTO對象中
        Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
        String name = Conventions.getVariableNameForParameter(parameter);

        if (binderFactory != null) {
            WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
            if (arg != null) {
                // 執行資料校驗
                validateIfApplicable(binder, parameter);
                if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
                    throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
                }
            }
            if (mavContainer != null) {
                mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
            }
        }
        return adaptArgumentIfNecessary(arg, parameter);
    }
}

可以看到，

resolveArgument()

調用了

validateIfApplicable()

進行參數校驗。

最終發現底層最終還是調用了Hibernate Validator進行真正的校驗處理。

方法級别的參數校驗實作原理

上面提到的将參數一個個平鋪到方法參數中，然後在每個參數前面聲明限制注解的校驗方式，就是方法級别的參數校驗。實際上，這種方式可用于任何Spring Bean的方法上，比如Controller/Service等。

其底層實作原理就是AOP，具體來說是通過MethodValidationPostProcessor動态注冊AOP切面，然後使用MethodValidationInterceptor對切點方法織入增強。

public class MethodValidationPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessorimplements InitializingBean {
    @Override
    public void afterPropertiesSet() {
        //為所有`@Validated`标注的Bean建立切面
        Pointcut pointcut = new AnnotationMatchingPointcut(this.validatedAnnotationType, true);
        //建立Advisor進行增強
        this.advisor = new DefaultPointcutAdvisor(pointcut, createMethodValidationAdvice(this.validator));
    }

    //建立Advice，本質就是一個方法攔截器
    protected Advice createMethodValidationAdvice(@Nullable Validator validator) {
        return (validator != null ? new MethodValidationInterceptor(validator) : new MethodValidationInterceptor());
    }
}

接着看一下

MethodValidationInterceptor

：

public class MethodValidationInterceptor implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        //無需增強的方法，直接跳過
        if (isFactoryBeanMetadataMethod(invocation.getMethod())) {
            return invocation.proceed();
        }
        //擷取分組資訊
        Class<?>[] groups = determineValidationGroups(invocation);
        ExecutableValidator execVal = this.validator.forExecutables();
        Method methodToValidate = invocation.getMethod();
        Set<ConstraintViolation<Object>> result;
        try {
            //方法入參校驗，最終還是委托給Hibernate Validator來校驗
            result = execVal.validateParameters(
                invocation.getThis(), methodToValidate, invocation.getArguments(), groups);
        }
        catch (IllegalArgumentException ex) {
            ...
        }
        //有異常直接抛出
        if (!result.isEmpty()) {
            throw new ConstraintViolationException(result);
        }
        //真正的方法調用
        Object returnValue = invocation.proceed();
        //對傳回值做校驗，最終還是委托給Hibernate Validator來校驗
        result = execVal.validateReturnValue(invocation.getThis(), methodToValidate, returnValue, groups);
        //有異常直接抛出
        if (!result.isEmpty()) {
            throw new ConstraintViolationException(result);
        }
        return returnValue;
    }
}

實際上，不管是

requestBody參數校驗

還是

方法級别的校驗

，最終都是調用

Hibernate Validator

執行校驗，

Spring Validation

隻是做了一層封裝。

Spring Boot 實作各種參數校驗，寫得太好了……

嵌套校驗

程式設計式校驗

繼續閱讀

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

vue-cli簡介（中文翻譯）

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Ajax發送和擷取json資料到Spring mvc 1.spring mvc後端2.web前段

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method

JSONObject包導入異常 java.lang.NoClassDefFoundErrorweb項目的導入包的問題