如果前端需要传入一个Date类型的参数来查询，比如createdTime，如果按swagger给的日期参数，那么是会报错的。解决办法就是在参数上面加上：
@JsonFormat(timezone="GMT+8", pattern="yyyy-MM-dd")

比如我的参数是封装在vo里面的，那么就在vo中的日期参数上面就上就好了。

普通web请求可以通过 javax.validation.constraints package下的注解进行参数校验，那么校验后返回的校验失败的结果怎么友好型提醒呢？通过下面异常拦截处理：

package com.oyo.supplier.web;

import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import com.oyo.common.enums.ResponseCode;
import com.oyo.common.exception.ServiceException;
import com.oyo.common.response.BaseResponse;
import com.oyo.supplier.common.enums.CommonEnum;
import com.oyo.supplier.web.response.ArgumentInvalidResponse;
import lombok.extern.slf4j.Slf4j;
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;

import javax.servlet.http.HttpServletRequest;
import java.sql.SQLException;
import java.util.List;

/**
 * @author kermit.liu on 2019/2/22
 */
@ControllerAdvice
@ResponseBody
@Slf4j
public class DefaultControllerAdvice {

    /**
     * 添加全局异常处理流程，根据需要设置需要处理的异常
     *
     * @param request   request
     * @param exception exception
     * @return BaseResponse
     */
    @ExceptionHandler(value = MethodArgumentNotValidException.class)
    public BaseResponse methodArgumentNotValidHandler(HttpServletRequest request, MethodArgumentNotValidException exception) {
        log.warn(request.getRequestURI() + " exception, params = " + JSON.toJSONString(request.getParameterMap()), exception);
        // 按需重新封装需要返回的错误信息
        List<ArgumentInvalidResponse> invalidArguments = Lists.newArrayList();
        // 解析原错误信息，封装后返回，此处返回非法的字段名称，原始值，错误信息
        StringBuilder msg = new StringBuilder();
        msg.append(ResponseCode.ILLEGAL_ARGUMENT.getMsg()).append(": ");
        for (FieldError error : exception.getBindingResult().getFieldErrors()) {
            ArgumentInvalidResponse argumentInvalidResponse = ArgumentInvalidResponse.builder()
                    .field(error.getField())
                    .defaultMessage(error.getDefaultMessage())
                    .rejectedValue(error.getRejectedValue())
                    .build();
            invalidArguments.add(argumentInvalidResponse);
            msg = msg.append(error.getDefaultMessage()).append(";");
        }
        BaseResponse<Object> fail = BaseResponse.fail(ResponseCode.ILLEGAL_ARGUMENT.getCode(), msg.toString());
        fail.setData(JSON.toJSONString(invalidArguments));
        return fail;
    }

    @ExceptionHandler(value = SQLException.class)
    public BaseResponse methodSQLHandler(HttpServletRequest request, SQLException exception) {
        log.warn(request.getRequestURI() + " exception, params = " + JSON.toJSONString(request.getParameterMap()), exception);
        BaseResponse<Object> fail = BaseResponse.fail(CommonEnum.RESPONSE.SQL_ERROR.getCode(), CommonEnum.RESPONSE.SQL_ERROR.getDesc());
        fail.setData(JSON.toJSONString(exception.getErrorCode()));
        return fail;
    }

    @ExceptionHandler({Exception.class})
    public BaseResponse handException(HttpServletRequest request, Exception e) {
        if (e instanceof ServiceException) {
            log.warn(request.getRequestURI() + " exception, params = " + JSON.toJSONString(request.getParameterMap()), e);
            return BaseResponse.fail(((ServiceException) e).getCode(), ((ServiceException) e).getMsg());
        } else {
            log.error(request.getRequestURI() + " exception, params = " + JSON.toJSONString(request.getParameterMap()), e);
            BaseResponse<Object> fail = BaseResponse.fail(CommonEnum.RESPONSE.SERVER_ERROR.getCode(), CommonEnum.RESPONSE.SERVER_ERROR.getDesc());
            fail.setData(e.getMessage());
            return fail;
        }
    }
}


 

故事的开始：

前端进行校验，这个概念应该是没有问题的吧？比如：前端输入手机号的、链接的、邮箱地址的，我们是不是web端传入参数的时候，要对用户填入的格式进行校验。OK，这个概念大家都懂。但是，一般情况下，后端我们也要进行校验。

为什么？后端为什么校验？

我目前听到的两种说法：1、“客户端传来的参数都是不可信的”我大boss说的，具体原因不知道，就是说是行业的一种说法；2、“后端进行参数校验，是防止别人通过接口乱刷服务”。反正我是信第二种说法的，如果一些不安好心的人，通过接口刷我们的服务，随便哪个参数我们都允许填入，会导致数据库中导致大量的脏数据、风险。如果注入的是病毒怎么办？所以，后端是要进行参数校验的。

怎么进行后端参数校验？

我目前也是了解到了两种做法。

1、通过注解的方法，在实体上加注解。通过工具，当客户端传入参数的时候，自动进行校验。

大概的方法：pom中引入工具类；然后实体中添加注解；controller层传入数据时添加@validator进行参数校验。参考下面这篇文章：

后端参数校验：通过对实体添加注解——Hibernate validator

2、通过工具类，进行参数校验。

思路：将常用的校验方法放在一个类中，然后哪个参数需要校验，就调用工具类中的方法。我自认为很好用。

下面提供一个工具类，正则表达式工具类:RegexUtils.java



import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author Meng
 * @Date 2018/12/14 14:00
 */
public class RegexUtils {

        /**
         * 验证Email
         * @param email email地址，格式：zhangsan@zuidaima.com，zhangsan@xxx.com.cn，xxx代表邮件服务商
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkEmail(String email) {
            String regex = "\\w+@\\w+\\.[a-z]+(\\.[a-z]+)?";
            return Pattern.matches(regex, email);
        }

        /**
         * 验证身份证号码
         * @param idCard 居民身份证号码15位或18位，最后一位可能是数字或字母
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkIdCard(String idCard) {
            String regex = "[1-9]\\d{13,16}[a-zA-Z0-9]{1}";
            return Pattern.matches(regex,idCard);
        }

        /**
         * 验证手机号码（支持国际格式，+86135xxxx...（中国内地），+00852137xxxx...（中国香港））
         * @param mobile 移动、联通、电信运营商的号码段
         *<p>移动的号段：134(0-8)、135、136、137、138、139、147（预计用于TD上网卡）
         *、150、151、152、157（TD专用）、158、159、187（未启用）、188（TD专用）</p>
         *<p>联通的号段：130、131、132、155、156（世界风专用）、185（未启用）、186（3g）</p>
         *<p>电信的号段：133、153、180（未启用）、189</p>
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkMobile(String mobile) {
            String regex = "(\\+\\d+)?1[34578]\\d{9}$";
            return Pattern.matches(regex,mobile);
        }

        /**
         * 验证固定电话号码
         * @param phone 电话号码，格式：国家（地区）电话代码 + 区号（城市代码） + 电话号码，如：+8602085588447
         * <p><b>国家（地区） 代码 ：</b>标识电话号码的国家（地区）的标准国家（地区）代码。它包含从 0 到 9 的一位或多位数字，
         *  数字之后是空格分隔的国家（地区）代码。</p>
         * <p><b>区号（城市代码）：</b>这可能包含一个或多个从 0 到 9 的数字，地区或城市代码放在圆括号——
         * 对不使用地区或城市代码的国家（地区），则省略该组件。</p>
         * <p><b>电话号码：</b>这包含从 0 到 9 的一个或多个数字 </p>
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkPhone(String phone) {
            String regex = "(\\+\\d+)?(\\d{3,4}\\-?)?\\d{7,8}$";
            return Pattern.matches(regex, phone);
        }

        /**
         * 验证整数（正整数和负整数）
         * @param digit 一位或多位0-9之间的整数
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkDigit(String digit) {
            String regex = "\\-?[1-9]\\d+";
            return Pattern.matches(regex,digit);
        }

        /**
         * 验证整数和浮点数（正负整数和正负浮点数）
         * @param decimals 一位或多位0-9之间的浮点数，如：1.23，233.30
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkDecimals(String decimals) {
            String regex = "\\-?[1-9]\\d+(\\.\\d+)?";
            return Pattern.matches(regex,decimals);
        }

        /**
         * 验证空白字符
         * @param blankSpace 空白字符，包括：空格、\t、\n、\r、\f、\x0B
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkBlankSpace(String blankSpace) {
            String regex = "\\s+";
            return Pattern.matches(regex,blankSpace);
        }

        /**
         * 验证中文
         * @param chinese 中文字符
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkChinese(String chinese) {
            String regex = "^[\u4E00-\u9FA5]+$";
            return Pattern.matches(regex,chinese);
        }

        /**
         * 验证日期（年月日）
         * @param birthday 日期，格式：1992-09-03，或1992.09.03
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkBirthday(String birthday) {
            String regex = "[1-9]{4}([-./])\\d{1,2}\\1\\d{1,2}";
            return Pattern.matches(regex,birthday);
        }

        /**
         * 验证URL地址
         * @param url 格式：http://blog.csdn.net:80/xyang81/article/details/7705960? 或 http://www.csdn.net:80
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkURL(String url) {
            String regex = "(https?://(w{3}\\.)?)?\\w+\\.\\w+(\\.[a-zA-Z]+)*(:\\d{1,5})?(/\\w*)*(\\??(.+=.*)?(&.+=.*)?)?";
            return Pattern.matches(regex, url);
        }

        /**
         * <pre>
         * 获取网址 URL 的一级域
         * </pre>
         *
         * @param url
         * @return
         */
        public static String getDomain(String url) {
            Pattern p = Pattern.compile("(?<=http://|\\.)[^.]*?\\.(com|cn|net|org|biz|info|cc|tv)", Pattern.CASE_INSENSITIVE);
            // 获取完整的域名
            // Pattern p=Pattern.compile("[^//]*?\\.(com|cn|net|org|biz|info|cc|tv)", Pattern.CASE_INSENSITIVE);
            Matcher matcher = p.matcher(url);
            matcher.find();
            return matcher.group();
        }
        /**
         * 匹配中国邮政编码
         * @param postcode 邮政编码
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkPostcode(String postcode) {
            String regex = "[1-9]\\d{5}";
            return Pattern.matches(regex, postcode);
        }

        /**
         * 匹配IP地址(简单匹配，格式，如：192.168.1.1，127.0.0.1，没有匹配IP段的大小)
         * @param ipAddress IPv4标准地址
         * @return 验证成功返回true，验证失败返回false
         */
        public static boolean checkIpAddress(String ipAddress) {
            String regex = "[1-9](\\d{1,2})?\\.(0|([1-9](\\d{1,2})?))\\.(0|([1-9](\\d{1,2})?))\\.(0|([1-9](\\d{1,2})?))";
            return Pattern.matches(regex, ipAddress);
        }


}

 怎么用？我是直接在controller层进行调用的。!RegexUtils.checkEmail(obj.getContactsEmail())


    @RequestMapping(value = "/submit", method = RequestMethod.POST)
    @ResponseBody
    public BaseResponse submitTenantInfo(@RequestBody WebObjRequest<TenantInfo> request) {
        TenantInfo obj = request.getObj();
        if (obj == null || !request.isCorrectParams()|| !RegexUtils.checkEmail(obj.getContactsEmail())) {
            return new BaseResponse(RespConstants.GLOBAL_PARAM_ERROR);
        }
       ```````
        return new BaseResponse(RespConstants.GLOBAL_SUCCESS);
    }

最后，我想说的是。客户端校验和服务端校验的不同：我的理解是，客户端校验的提示，是提示用户正确输入，加强用户体验。服务端校验是为了接口安全，防止非法用户乱刷。所以，服务端进行参数校验的时候，返回的错误码不要具体到具体的错误，返回“参数异常”相关异常的错误即可。

相关拓展：常用的正则表达式

你是技术宅么？那就加入我们吧！点击下方链接 或 扫描二维码 即可。

欢迎加入 CSDN技术交流群2：（点击即可加群）QQ群:456543087 

               CSDN技术交流群(已满员)：（点击即可加群）QQ群:681223095。   

商务合作@群主，谢谢！

因经常有人留言，未能及时查看到和回复，所以特建此群，以方便交流。方便问题讨论,有问题和没有问题的小伙伴均可加入，用作自我学习和共同进步。本博主不一定长期在线，但是qq群里会有很多热心的小伙伴，大家一起讨论解决问题。



 

 

 

	

在我们实际项目开发过程中，避免不了的就是参数的校验，一般参数的校验，分为如下几种情况；1.前端直接验证；2. 在Controller层单独验证；3. 通过集成验证框架验证；显然3种里面，我们一般建议1+3结合的方式进行参数的校验比较合理和安全。在本章我们将围绕HTTP请求中参数校验的应用
Controller几种接收参数的方式
在介绍验证框架之前，我们来介绍下通过Controller接收参数的方式；现在大部分都是通过注解的方式进行参数的接收，主流的有如下几种
请求路径参数
@PathVariable 获取路径参数。即url/{id}这种形式。
@RequestParam 获取查询参数。即url?name=这种形式
代码形式如下：
GET http://localhost:8080/demo/SN20201011021211?name=hank
对应的接收代码如下：
@GetMapping("/demo/{sn}")public void demo(@PathVariable(name = "sn") String sn, @RequestParam(name = "name") String name) {    System.out.println("sn="+sn);    System.out.println("name="+name);}
Body参数
Body参数一般是POST请求，主要有两种方式
以JSON格式接收可通过@RequestBody获取对应的参数
以form表单形式提交的，暂无注解适配，可直接对象接收
JSON参数接收
例如：添加用户的接口,PostMan 请求信息如下
对应后端代码1，通过Map接收
@PostMapping(value = "/user/map")public ResultVO createUser(@RequestBody Map<String,Object> user){    String name=user.get("name").toString();    return RV.success(user);}
对应后代代码2 通过定义的对象接收
@PostMapping(value = "/user")public ResultVO createUser2(@RequestBody User user){    System.out.println("User Info:"+user.toString());    return RV.success(user);}
FORM 参数接收
form方式提交，在PostMan中对应参数如下
对应后端代码如下：
@PostMapping(value = "/user/form")public ResultVO createUser3(User user){    System.out.println("User Info:"+user.toString());    return RV.success(user);}
请求头和Cookie参数
@RequestHeader，是直接获取请求头HttpServletRequest对象里面Header中的参数
@CookieValue 可以直接获取HttpServletRequest对象里面Cookies中的参数
通过注解的方式获取，分别如下
@GetMapping("demo3")public void demo3(@RequestHeader(name = "myHeader") String myHeader,        @CookieValue(name = "myCookie") String myCookie) {    System.out.println("myHeader=" + myHeader);    System.out.println("myCookie=" + myCookie);}
通过硬编码的获取方式为
@GetMapping("/demo3")public void demo3(HttpServletRequest request) {    System.out.println(request.getHeader("myHeader"));    for (Cookie cookie : request.getCookies()) {        if ("myCookie".equals(cookie.getName())) {            System.out.println(cookie.getValue());        }    }}
由上可以看出，通过注解的方式可以极大简化编码，使我们的代码变得美观大方，如果通过request对象直接获取，也是可以的，这个主要是看什么样的需求，一般情况下，通过注解的方式基本上能满足我们的绝大部分需求，所以在项目中我们比较推荐直接通过注解的方式获取参数。
文件上传
文件上传主要是基于@RequestParam 结合MultipartFile对象；如下示例；
这里需要注意，前端的传入需要用表单方式提交，并且在Head的Content-Type里面加入,如下信息
Content-Type: application/x-www-form-urlencoded
对应后端代码如下
@Value("${file.upload.url}")private String filePath;@RequestMapping("/upload")public ResultVO httpUpload(@RequestParam("files") MultipartFile files[]){    for(int i=0;i<files.length;i++){        String fileName = files[i].getOriginalFilename();  // 文件名        File dest = new File(filePath+'/'+fileName);        if (!dest.getParentFile().exists()) {            dest.getParentFile().mkdirs();        }        try {            files[i].transferTo(dest);        } catch (Exception e) {            log.error("{}",e);            return RV.result(ErrorCode.UPLOAD_FILE_ERROR,e);        }    }    return RV.success(null);}
参数校验
在Controller层的参数校验可以分为两种场景，单个参数校验和实体参数校验
单个参数校验
后端代码如下
@RestControllerpublic class ValidateController {    @GetMapping("/getUser")    @Validated    public ResultVO getUserStr(@NotNull(message = "name 不能为空") String name,                               @Max(value = 99, message = "不能大于99岁") Integer age) {        return RV.success("name: " + name + " ,age:" + age);    }}
在Postman请求如下，可以看到请求后，返回了系统异常，应该是被全局异常拦截了
我们再看后台打印的日志
如果我们系统中有很多地方都用到了参数校验，那么我们最好是能够在全局异常拦截处直接拦截ConstraintViolationException异常，并进行统一处理，可以在我们前面章节讲到的，在加了@RestControllerAdvice注解的GlobalException类中加入如下拦截的新方法;由于ConstraintViolationException继承了ValidationException异常类，所以我们可以直接拦截父类异常，直接进行多个不同的校验异常进行处理
@RestControllerAdvicepublic class GlobalException {    /**     * 描述:表单异常拦截     * @param [e]     * @date 2020/11/22     * @Author Hank     **/    @ExceptionHandler(value = ValidationException.class)    public  ResultVO validationException(ValidationException e){        Map map=new HashMap();        if(e instanceof ConstraintViolationException){            ConstraintViolationException exs = (ConstraintViolationException) e;            Set<ConstraintViolation>> violations = exs.getConstraintViolations();            for (ConstraintViolation> item : violations) {                //打印验证不通过的信息                System.out.println(item.getMessage());                map.put(item.getPropertyPath(),item.getMessage());            }        }        return RV.result(ErrorCode.FORM_VALIDATION_ERROR,map) ;    }}
同样，再通过Postman请求后，得到如下结果
实体参数校验
一般我们在传入参数比较少的情况下，就直接用上面的方法进行了验证了，但是，如果我们传入的是一个对象，直接在方法上一个一个属性设置，就显得有点不美观了，因此我们一般都是封装一个接收参数的对象。如下面实例提供的，添加用户接口，我们对用户对象的变量设置了校验规则，如下
@Dataclass Person {    @NotNull(message = "名称不能为空")    @Max(value = 30, message = "名称不能超过30个字符")    String name;    @Max(value = 200, message = "年龄不能超过200岁吧")    @NotNull(message = "年龄不能为空")    Integer age;    @NotNull(message = "地址信息不能为空")    String address;}
在Controller类中我们增加添加用户的方法,这里我们需要注意，我们只需要在方法对应的参数Person对象前面加上@Valid注解即可
    /**     * 描述:添加一个 Person     * @param [person]     * @date 2020/11/22     * @Author Hank     **/    @PostMapping(value = "/person")    public ResultVO<Person> addPerson(@RequestBody @Valid Person person) {        //此处略过处理业务的代码...        return RV.success(person);    }
其实大家可能就会问，那要是参数校验不同过，这里应该是抛出什么异常呢，当我们执行如上代码，设定超出范围的参数后，在后端可以看到异常如下
可以看到，这里抛出的MethodArgumentNotValidException与上面的异常截然不同；相同道理，我依然在GlobalException类中加入对MethodArgumentNotValidException异常的全局拦截即可
    /**     * 描述: 方法参数验证异常拦截     * @param [e]     * @date 2020/11/22     * @Author Hank     **/    @ExceptionHandler(value = MethodArgumentNotValidException.class)    public  ResultVO methodArgumentNotValidException(MethodArgumentNotValidException e){        List<ObjectError> errors = e.getBindingResult().getAllErrors();        String[] errMessage=new String[errors.size()];        for (int i = 0; i < errors.size(); i++) {            ObjectError error=errors.get(i);            errMessage[i]=error.getDefaultMessage();            System.out.println(error.getCode()+":"+error.getDefaultMessage());        }        return RV.result(ErrorCode.METHOD_ARGS_VALID_ERROR,errMessage) ;    }
Validated与Valid区别
@Validated: 用在方法的入参上无法单独提供嵌套验证功能。不能用在成员属性(字段)上，也无法提示框架进行嵌套验证。能配合嵌套验证注解@Valid进行嵌套验证。
@Valid:用在方法入的参上无法单独提供嵌套验证功能。能够用在成员属性(字段)上，提示验证框架进行嵌套验证。能配合嵌套验证注解@Valid进行嵌套验证。
如上Person对象，如果里面再有一个对象，比如还是Person，在提交的过程中，需要这种嵌套验证，就需要通过使用Valid的嵌套验证功能，即可将代码修改如下;
@Dataclass Person {    @NotNull(message = "名称不能为空")    @Size(min = 2,max = 30, message = "名称长度限定在2-30之间的长度")    String name;    @Max(value = 200, message = "年龄不能超过200岁吧")    @NotNull(message = "年龄不能为空")    Integer age;    @NotNull(message = "地址信息不能为空")    String address;    @Valid    Person p;}
常用参数校验的注解
这里我们主要介绍在springboot中的几种参数校验方式。常用的用于参数校验的注解如下：
@AssertFalse 所注解的元素必须是Boolean类型，且值为false
@AssertTrue 所注解的元素必须是Boolean类型，且值为true
@DecimalMax 所注解的元素必须是数字，且值小于等于给定的值
@DecimalMin 所注解的元素必须是数字，且值大于等于给定的值
@Digits 所注解的元素必须是数字，且值必须是指定的位数
@Future 所注解的元素必须是将来某个日期
@Max 所注解的元素必须是数字，且值小于等于给定的值
@Min 所注解的元素必须是数字，且值小于等于给定的值
@Range 所注解的元素需在指定范围区间内
@NotNull 所注解的元素值不能为null
@NotBlank 所注解的元素值有内容
@Null 所注解的元素值为null
@Past 所注解的元素必须是某个过去的日期
@PastOrPresent 所注解的元素必须是过去某个或现在日期
@Pattern 所注解的元素必须满足给定的正则表达式
@Size 所注解的元素必须是String、集合或数组，且长度大小需保证在给定范围之内
@Email 所注解的元素需满足Email格式
小结
本章主要围绕两方面内容作了详细的介绍
Controller的参数接收方式
请求路径参数
Body参数(JSON\FORM\请求头和Cookie参数)
文件上传
参数的校验
单个参数校验
实体参数校验
嵌套参数校验以及Validated与Valid的区别
以上我们分别用示例进行了详细阐述，希望对你后期的开发工作有所帮助；如果你在这方面有不同的实战经验，也欢迎在评论区进行留言。