精华内容
下载资源
问答
  • 如果前端需要传入一个Date类型的参数来查询,比如createdTime,如果按swagger给的日期参数,那么是会报错的。解决办法就是在参数上面加上: @JsonFormat(timezone="GMT+8", pattern="yyyy-MM-dd") 比如我的参数是...

    如果前端需要传入一个Date类型的参数来查询,比如createdTime,如果按swagger给的日期参数,那么是会报错的。解决办法就是在参数上面加上:

    @JsonFormat(timezone="GMT+8", pattern="yyyy-MM-dd")
    

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

    展开全文
  • 普通web请求可以通过 javax.validation.constraints package下的注解进行参数校验,那么校验后返回的校验失败的结果怎么友好型提醒呢?通过下面异常拦截处理: package com.oyo.supplier.web; import ...

    普通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端传入参数的时候,要对用户填入的格式进行校验。...2、“后端进行参数校验,...

    故事的开始:

    前端进行校验,这个概念应该是没有问题的吧?比如:前端输入手机号的、链接的、邮箱地址的,我们是不是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群里会有很多热心的小伙伴,大家一起讨论解决问题。

     

     

     

    展开全文
  • 在我们实际项目开发过程中,避免了的就是参数的校验,一般参数的校验,分为...在本章我们将围绕HTTP请求中参数校验的应用Controller几种接收参数的方式在介绍验证框架之前,我们来介绍下通过Controller接收参数...

    在我们实际项目开发过程中,避免不了的就是参数的校验,一般参数的校验,分为如下几种情况;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 请求信息如下

    30152f7879f611e4dd72f7ffb8f89d4c.png

    对应后端代码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中对应参数如下

    f4fbb6e9f2d69048aa293da67300c4a7.png

    对应后端代码如下:

    @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

    a53dc36a9094620f2850caf373a98292.png

    对应后端代码如下

    @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请求如下,可以看到请求后,返回了系统异常,应该是被全局异常拦截了

    7272bfd02a8e990a5599b355328de487.png

    我们再看后台打印的日志

    dbdf3dce0112096ceb80eaeec1725417.png

    如果我们系统中有很多地方都用到了参数校验,那么我们最好是能够在全局异常拦截处直接拦截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请求后,得到如下结果

    1820892bb972b9646cfc042d2247cfb9.png

    实体参数校验

    一般我们在传入参数比较少的情况下,就直接用上面的方法进行了验证了,但是,如果我们传入的是一个对象,直接在方法上一个一个属性设置,就显得有点不美观了,因此我们一般都是封装一个接收参数的对象。如下面实例提供的,添加用户接口,我们对用户对象的变量设置了校验规则,如下

    @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);    }

    其实大家可能就会问,那要是参数校验不同过,这里应该是抛出什么异常呢,当我们执行如上代码,设定超出范围的参数后,在后端可以看到异常如下

    47420f638b41cce00132e54cb733ea01.png

    可以看到,这里抛出的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的区别

    以上我们分别用示例进行了详细阐述,希望对你后期的开发工作有所帮助;如果你在这方面有不同的实战经验,也欢迎在评论区进行留言。

    展开全文
  • spring 参数校验

    2021-02-02 14:10:52
    有参数传递的地方都少不了参数校验。在web开发中,前端的参数校验是为了用户体验,后端的参数校验是为了安全。 试想一下,如果在controller层中没有经过任何校验的参数通过service层、dao层一路来到了数据库就可能...
  • SpringMVC 参数校验

    千次阅读 2017-08-21 20:48:44
    参数校验的步骤我就在赘述,推荐: 参数校验的步骤 我感觉这篇文章,博主其实写的还可以。 我这只说参数校验的另外一种方法,通过继承和引用实现参数校验。 首先是Model参数类: speaker.javapackage ...
  • 组件的参数校验:父组件通过属性传递给子组件数据,子组件有权对这些数据进行约束,这就是参数校验。...-- 下面会报错,因为content传递的是一个数组,参数校验不通过 --&gt; &lt;child :
  • SpringBoot 参数校验

    2020-11-03 17:32:43
    通过注解实现参数校验。 单个参数校验 /** * controller 上必须加 @Validated ,同时NotNull和 RequestParam本身的非空冲突 * 加 @Validated之后,并意味着其他类型参数校验可以不用@Validated * @param id *...
  • Hibernate Validator参数校验

    千次阅读 2017-07-29 19:37:48
    日常开发中经常会遇到需要参数校验的情况,比如某个字段能为空、长度能超过5等都属于参数校验的范围。对于简单的参数校验通过写几个if-else判断语句就搞定,但是对于复杂的多个参数校验的情况,就不是那么简单了...
  • 在我们实际项目开发过程中,避免了的就是参数的校验,一般参数的校验,分为...在本章我们将围绕HTTP请求中参数校验的应用Controller几种接收参数的方式在介绍验证框架之前,我们来介绍下通过Controller接收参数...
  • SpringMVC参数校验

    2019-06-07 13:02:16
    # 前言 在 Web 开发中, 我们经常需要校验各种参数,这是一件繁琐又重要的事情,对于很多人来说,在做参数校验的时候,会有以下几种类型的处理...有多少参数,我就写多少个 if 语句做判断,校验不通过的都写一句...
  • 最近通过@ControllerAdvice和@ExceptionHandler做了异常的全局处理,在全局异常处理类中加了参数验证异常处理,需要再重复在controller里面判断参数是否通过验证; 对应的方法如下: @ExceptionHandler(value = ...
  • 参数校验:简单的就逐个手动写代码校验,推荐用Valid,使用hibernate-validator提供的,如果参数通过校验,报400错误,请求格式正确:步骤1:在参数对象的属性上添加校验注解如@NotBlank步骤2:用@Valid注解...
  • 参数校验常用注解注解验证的数据类型备注Null任意类型参数值必须是 NullNotNull任意类型参数值必须不是 NullNotBlank只能作用于字符串字符串能为 null,而且字符串长度必须大于0,至少包含一个非空字符串...
  • Jersey框架:参数校验

    千次阅读 2019-04-21 16:47:06
    在进行数据库查询前,后端程序会先对前端提交的参数进行校验,如果校验不通过则直接提示相应错误,避免无谓的错误操作。 Jersey参数校验机制 Jersey支持参数校验,注解定义在javax.validation.constraints包中,是一...
  • 在之前,曾经写过一篇博客对于@Validated的使用说明,但是对于参数校验不通过之后的异常信息,又如何封装到一个JSON对象返回给前端呢? controller层的代码: 如图所示,如果我们仅仅使用@Validated进行校验,...
  • koa2参数校验方案

    千次阅读 2020-05-08 20:27:13
    通过json进行前后端交互已经成为了必可少的部分,而对json数据的校验工作会随着项目的逐步扩大而变得日益臃肿而难以维护,尤其是中后台的项目提交的有些表单含有的参数特别的多且结构复杂,如果能很好的设计一种...
  • 参数校验作为后端工程师,接口的参数校验重要性不言而喻,...controller 层参数校验1、单个参数的校验注意:Validated 注解需要写到类上,不然生效。访问如下链接,会抛出异常。http://127.0.0.1:8009/userLogin....
  • 背景 在web服务接口调用时,会有各种各样的输入参数,为了...因此,我们引入了validation,通过添加@NotNull,@NotEmpty等注解进行参数校验,参数合法的调用请求根本就给进入到方法的机会。 加入依赖 spring...
  • 前端后端进行交互时,前端上送的参数校验,简单的通过注解实现,方便快捷,而需要再次开发代码逻辑; 1,参数校验的前提是controller层的方法里需使用@Valid开启校验 @PostMapping("/test") public String Test...
  • 参数校验的多种方式

    千次阅读 2019-09-08 14:31:03
    参数校验的几种方式 如果默认的字段类型和选项能满足需求,需要再补充校验行为,可以使用以下三种方法: 通过字段中的validators 选项进行校验 validate_<field_name>方法:对<field_name>字段进行...
  • 通过上图有没有发现,数据校验可谓是贯穿所有的应用程序层,一个 API 接口或方法简单只有两个输入参数,多则几十个参数,都在进行参数校验,这样既耗时又容易出错。 有没有办法简化这个流程呢? 大家都知道 ...
  • ​ 在开发http接口的时候,参数校验是必须有的一个环节,当参数校验较少的时候,一般是直接按照校验条件做校验,校验不通过,返回错误信息。比如以下校验用户名不为空的校验: if (userName == null || “”.equals...
  • 在实际的java开发中,参数校验是个比较零碎繁琐的事情,但是却必可少,本文通过aop来实现对参数的校验,可以节省大量的时间和提交代码的可读性与整洁性,方便更加集中的编写业务逻辑。 代码: ParamCheckAop: ...
  • 比如最大值、最小值约束,涉及到手机号、身份证等规则校验,参数是否为空等等,刚进入java领域的小伙伴们大部分第一时间都是针对每个参数进行一一判别校验、当接口参数校验,判断逻辑代码就显得极其冗杂,美观也...
  • 我现在有点问题,后端参数合法校验各种if判断太麻烦,如果前后端代码分别部署在两台服务器上,后端服务器ip端口只对前端服务器开放,前端服务器做参数校验,外网请求到后端服务器ip端口,只能通过前端服务器请求...
  • 甩锅型校验太麻烦了,让客户端去负责校验就行了,调用方传错了是调用方的问题,不是服务的问题,甩个 500 错误让他们好好反省:劳模型有多少参数,我就写多少个 if 语句做判断,校验不通过的都写一句友好的...
  • 甩锅型校验太麻烦了,让客户端去负责校验就行了,调用方传错了是调用方的问题,不是服务的问题,甩个 500 错误让他们好好反省:劳模型有多少参数,我就写多少个 if 语句做判断,校验不通过的都写一句友好的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 934
精华内容 373
关键字:

参数校验不通过