精华内容
下载资源
问答
  • 主要介绍了springboot+dubbo+validation 进行rpc参数校验的实现方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了如何在spring-boot中进行参数校验及lombok的使用详解,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • sap发票校验两个常用的用户参数sap发票校验两个常用的用户参数sap发票校验两个常用的用户参数sap发票校验两个常用的用户参数
  • 普通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;
            }
        }
    }
    

     

    展开全文
  • 使用SpringBoot通过自定义注解+AOP+全局异常处理实现参数统一非空校验
  • Spring Boot 参数校验

    2019-12-10 15:04:08
    Bean Validation是Java定义的一套基于注解的数据校验规范。这里简单实现了Spring Boot 参数校验,包括自定义注解,分组校验,全局异常处理等
  • 下面小编就为大家带来一篇java自定义注解实现前后台参数校验的实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍的Springboot使用@Valid 和AOP做参数校验及日志输出问题,本文通过代码讲解的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 参数校验参数是否为空接口,循环判断多个参数,可以直接使用
  • 基于Spring boot + maven,以注解+AOP方式实现的java后端项目接口参数校验框架。迄今为止使用最简单、最容易理解的参数校验方案。博客地址:https://blog.csdn.net/weixin_42686388/article/details/104009771
  • Koa2请求参数校验中间件,基于 安装 npm i -S koa-params-validator 环境要求 节点> = 7.6 Koa> = 2.0 快速开始 const validator = require ( 'koa-params-validator' ) const app = new require ( 'koa' ) ( ) ; ...
  • 主要介绍了Spring MVC参数校验的相关资料,主要是针对`@RequestBody`返回`400`的问题,文中通过示例代码介绍的非常详细,对大家具有一定的参考学习价值,需要的朋友们下面跟着小编来一起学习学习吧。
  • Java参数校验

    千次阅读 2019-01-23 16:19:56
    基本步骤 引入pom依赖 ...-- 参数校验 --&amp;amp;gt; &amp;amp;lt;!-- start --&amp;amp;gt; &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt

    基本步骤

    1. 引入pom依赖
    2. 书写需要校验的实体
    3. 书写实体校验工具类
    4. 编写测试代码

    引入pom依赖

            <!-- 参数校验 -->
            <!-- start -->
            <dependency>
                <groupId>javax.validation</groupId>
                <artifactId>validation-api</artifactId>
                <version>2.0.1.Final</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-validator</artifactId>
                <version>6.0.14.Final</version>
            </dependency>
            <dependency>
                <groupId>org.glassfish</groupId>
                <artifactId>javax.el</artifactId>
                <version>3.0.1-b11</version>
            </dependency>
            <!-- end -->
    

    书写需要校验的实体

    package com.ahut.common.utils;
    
    import javax.validation.constraints.Min;
    import javax.validation.constraints.NotNull;
    
    /**
     * desc : 新增用户请求
     * create_user : cheng
     * create_date : 2019/1/23 11:34
     */
    public class AddUserRequest {
    
        /**
         * 用户名
         */
        @NotNull(message = "用户名不能为空")
        private String userName;
        /**
         * 年龄
         */
        @Min(value = 0, message = "用户年龄最小为0")
        private int age;
    
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    书写实体校验工具类

    package com.ahut.common.utils;
    
    import com.ahut.common.entity.BeanValidateResult;
    import org.apache.commons.collections.CollectionUtils;
    
    import javax.validation.ConstraintViolation;
    import javax.validation.Validation;
    import javax.validation.Validator;
    import javax.validation.ValidatorFactory;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Set;
    import java.util.stream.Collectors;
    
    /**
     * desc : 实体校验工具类
     * create_user : cheng
     * create_date : 2019/1/23 13:54
     */
    public final class BeanValidateUtil {
    
        /**
         * 私有化构造方法
         */
        private BeanValidateUtil() {
        }
    
        /**
         * desc : 校验
         * create_user : cheng
         * create_date : 2019/1/23 13:56
         */
        public static <T> List<BeanValidateResult> validate(T bean) {
            // 校验null
            if (Objects.isNull(bean)) {
                return getNullValidateResultList();
            }
    
            // 获取验证器工厂
            ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();
            // 获取验证器
            Validator validator = validatorFactory.getValidator();
            // 执行验证
            Set<ConstraintViolation<T>> validateSet = validator.validate(bean);
            return getValidateResultList(validateSet);
        }
    
        /**
         * desc : 获取校验实体list
         * create_user : cheng
         * create_date : 2019/1/23 14:12
         */
        private static <T> List<BeanValidateResult> getValidateResultList(Set<ConstraintViolation<T>> validateSet) {
            List<BeanValidateResult> validateResultList = new ArrayList<>();
            if (CollectionUtils.isNotEmpty(validateSet)) {
                validateResultList = validateSet.stream().map(BeanValidateUtil::convertToBeanValidateResult).collect(Collectors.toList());
            }
            return validateResultList;
        }
    
        /**
         * desc : 转换类型
         * create_user : cheng
         * create_date : 2019/1/23 14:48
         */
        private static <T> BeanValidateResult convertToBeanValidateResult(ConstraintViolation<T> validate) {
            BeanValidateResult validateResult = new BeanValidateResult();
            validateResult.setFieldName(validate.getPropertyPath().toString());
            validateResult.setMessage(validate.getMessage());
            return validateResult;
        }
        /**
         * desc : 获取bean为null时的校验结果
         * create_user : cheng
         * create_date : 2019/1/24 10:39
         */
        private static List<BeanValidateResult> getNullValidateResultList() {
            List<BeanValidateResult> validateResultList = new ArrayList<>();
            BeanValidateResult validateResult = new BeanValidateResult();
            validateResult.setFieldName("validateBean");
            validateResult.setMessage("bean is null");
            validateResultList.add(validateResult);
            return validateResultList;
        }
    
    }
    
    package com.ahut.common.entity;
    
    /**
     * desc : 参数校验结果封装实体
     * create_user : cheng
     * create_date : 2019/1/23 14:45
     */
    public class BeanValidateResult {
    
        private String fieldName;
    
        private String message;
    
        public String getFieldName() {
            return fieldName;
        }
    
        public void setFieldName(String fieldName) {
            this.fieldName = fieldName;
        }
    
        public String getMessage() {
            return message;
        }
    
        public void setMessage(String message) {
            this.message = message;
        }
    }
    

    编写测试代码

    package com.ahut.common.utils;
    
    import com.ahut.common.entity.BeanValidateResult;
    import org.junit.Test;
    
    import java.util.List;
    
    /**
     * desc : 测试参数校验
     * create_user : cheng
     * create_date : 2019/1/23 14:21
     */
    public class BeanValidateUtilTest {
    
        /**
         * desc :
         * create_user : cheng
         * create_date : 2019/1/23 14:21
         */
        @Test
        public void testValidate() {
            AddUserRequest request = new AddUserRequest();
            request.setAge(-1);
    
            List<BeanValidateResult> validateResultList = BeanValidateUtil.validate(request);
            for (BeanValidateResult validateResult : validateResultList) {
                System.out.println(validateResult.getFieldName() + " : " + validateResult.getMessage());
            }
        }
    
    }
    

    输出结果

    userName : 用户名不能为空
    age : 用户年龄最小为0
    

    自定义注解

    定义注解

    package com.ahut.common.annotation;
    
    import com.ahut.common.annotation.validate.ListIsNotEmptyValidator;
    
    import javax.validation.Constraint;
    import javax.validation.Payload;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * desc : 校验list不为空的注解
     * create_user : cheng
     * create_date : 2019/1/24 16:33
     */
    @Target({ElementType.FIELD, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Constraint(validatedBy = ListIsNotEmptyValidator.class)
    public @interface ListIsNotEmpty {
    
        String message() default "{com.ahut.common.annotation.ListIsNotEmpty.message}";
    
        Class<?>[] groups() default {};
    
        Class<? extends Payload>[] payload() default {};
    }
    

    定义注解校验器

    package com.ahut.common.annotation.validate;
    
    import com.ahut.common.annotation.ListIsNotEmpty;
    import org.apache.commons.collections.CollectionUtils;
    
    import javax.validation.ConstraintValidator;
    import javax.validation.ConstraintValidatorContext;
    import java.util.List;
    
    /**
     * desc : 验证ListIsNotEmpty注解
     * create_user : cheng
     * create_date : 2019/1/24 16:38
     */
    public class ListIsNotEmptyValidator implements ConstraintValidator<ListIsNotEmpty, List> {
    
        /**
         * desc :
         * create_user : cheng
         * create_date : 2019/1/24 16:49
         */
        @Override
        public boolean isValid(List list, ConstraintValidatorContext constraintValidatorContext) {
            return CollectionUtils.isNotEmpty(list);
        }
    
        /**
         * desc : 初始化
         * create_user : cheng
         * create_date : 2019/1/24 16:49
         */
        @Override
        public void initialize(ListIsNotEmpty constraintAnnotation) {
        }
    
    }
    
    展开全文
  • 主要介绍了SpringBoot中的参数校验,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 故事的开始: 前端进行校验,这个概念应该是没有问题的吧?比如:前端输入手机号的、链接的、邮箱地址的,我们是不是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群里会有很多热心的小伙伴,大家一起讨论解决问题。

     

     

     

    展开全文
  • spring参数注解校验

    千次阅读 2018-08-21 13:01:51
    在写一些controller协议的时候,有些时候从前端传过来的参数较多,好的办法是定义一个实体类来封装请求参数,但是用实体类封装参数后,无法对参数值进行校验,可以使用spring的@Validated 结合java validation、...

    在写一些controller协议的时候,有些时候从前端传过来的参数较多,好的办法是定义一个实体类来封装请求参数,但是用实体类封装参数后,无法对参数值进行校验,可以使用spring的@Validated 结合java validation、hibernate validation注解进行校验。

    个人建议使用spring的Validated注解,而不要使用hibernate的validat注解,hibernate注解适用于和数据库相关连的对象。

    1.@validated 注解

    @Validated is org.springframework.validation.annotation.Validated.

    @RequestMapping(value = "/regist", method = {RequestMethod.GET, RequestMethod.POST})

    @ResponseBody

    public Object hualalaRegist(@Validated RegistVO registVO)

    ... }

     

    @Validated 注解后,表示需要对其中的参数进行校验。

    然后再对应的javabean里面的字段上使用注解校验字段,具体的注解见下面章节2

    public class RegistVO {
    
        @NotBlank
        @Pattern(regexp = "^\\d{11}$", message = "手机号码格式错误")
        String phoneNumber; //手机号码
    
        @NotBlank
        String name; //姓名
    
        @NotBlank
        String loanBody;//借款主体
    
        @NotBlank
        String loanBodyId;//借款主体ID
    
        @NotNull
        BigDecimal borrowAmount;//借款金额
    

    }

    使用这个注解去校验参数之后如果参数不合法会抛出一个异常 ConstraintViolationException。结合上一篇博客讲的全局异常处理,这样你就可以捕获到这个异常,然后进行统一的处理,比如返回给前端错误信息等。

    2.java validation 注解

    注解也可以直接使用在方法的参数上,比如

    public void getUser(@NotNull String name) {}

    还可以使用在javabean里面的字段上,当javabean作为一个参数的时候使用@Validated注解才能实现校验,如上面章节1所讲

    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=)  被注释的元素必须符合指定的正则表达式    

    3.hiberate validation 注解

     

    @Email  被注释的元素必须是电子邮箱地址    
    @Length(min=,max=)  被注释的字符串的大小必须在指定的范围内    
    @NotEmpty   被注释的字符串的必须非空    
    @Range(min=,max=,message=)  被注释的元素必须在合适的范围内
    @URL(protocol=,host=,    port=, regexp=, flags=)  合法的url

    主要区分下@NotNull  @NotEmpty  @NotBlank 3个注解的区别:

    @NotNull           任何对象的value不能为null

    @NotEmpty       集合对象的元素不为0,即集合不为空,也可以用于字符串不为null

    @NotBlank        只能用于字符串不为null,并且字符串trim()以后length要大于0

    使用注解的好处是不在需要在Controller层去写复杂的参数校验逻辑,大大减少代码行数,注解校验参数与方式建议只在Controller层使用,Service层还是建议自己写代码去实现参数校验,具体原因就是注解并不是万能的,过多的使用注解会让代码可读性变差。

    展开全文
  • java后台参数校验 一. 单个参数的校验方式 实现原理:@ControllerAdvice,@Validated注解对参数进行校验 实现方式: 1.创建统一的系统常量 package com.hm.middle_service.common; /** * @Author:huangzhimin * ...
  • SpringBoot使用validation-api实现对枚举类参数校验 前言 之前写了一个博客是关于使用SpringBoot使用validation-api实现参数校验,当时使用的注解都是validation-api自带的注解只能完成对空值、长度等简单的校验,在...
  • SpringBoot里参数校验/参数验证

    万次阅读 多人点赞 2019-05-08 13:47:56
    在控制器类的方法里自己写校验逻辑代码当然也可以,只是代码比较丑陋,有点“low”。业界有更好的处理方法,分别阐述如下。 2、PathVariable校验 @GetMapping("/path/{group:[a-zA-Z0-9_]+}/{userid}") @...
  • 参数取值范围校验

    千次阅读 2018-07-02 01:16:03
    通过相对路径获取配置文件中的数据3.从传参中获取所有待校验的字段,并根据校验规则进行校验扩展:Java 读取 .properties 配置文件的几种方式(1).读取相对路径下的.properties时,此时src为根路径,如果要读取src/config...
  • 验证参数注解校验总结

    千次阅读 2019-09-04 09:30:51
    参数校验注解的使用规则方法】: 空检查 @Null 验证对象是否为null @NotNull 验证对象是否不为null, 无法查检长度为0的字符串 @NotBlank 检查约束字符串是不是Null还有被Trim的长度是否大于0,只对字符串,且会...
  • 背景:在java后端项目开发过程中,其实有很多大一部分项目,后端都没有做接口参数校验,或者做了参数校验,但是实现方式都是简单的使用if判断;主要原因在于:API的参数校验目前缺少比较流行的方案、现有方案不适用...
  • Spring参数校验 @Validated @RequestParam

    千次阅读 2020-09-11 14:05:57
    } /** * 对象方式参数校验失败- t2 方法验证失败进入 * @param exception * @return */ @ExceptionHandler(value = BindException.class) public Object hadeConstraintViolationException...
  • Spring参数校验--List类型参数校验

    千次阅读 2019-03-06 00:05:27
    1.遇到的问题: 今天开发接口,遇到请求...发现参数校验失效。 // 控制器 @RequestMapping(value = "/saveVideo", method = RequestMethod.POST) @ResponseBody public List&lt;SaveVideoRe...
  • 该示例项目使用SpringBoot,添加web和aop依赖。...而网上对校验单个参数,譬如String,int之类的资料极少,这一篇就是讲这个的。校验JavaBeanpackage com.example.bean;import org.hibernate.validator.con
  • controller参数校验

    千次阅读 2019-11-14 11:27:30
    使用javax.validation去校验参数,可以避免过多的if判断。 对需要校验的入参类添加注解 public class TestVO { /*** 用户ID*/ @NotNull(message = "用户id不能为空") private Long userId; /** 用户名*/ @...
  • 参数校验的多种方式

    千次阅读 2019-09-08 14:31:03
    参数校验的几种方式 如果默认的字段类型和选项不能满足需求,需要再补充校验行为,可以使用以下三种方法: 通过字段中的validators 选项进行校验 validate_<field_name>方法:对<field_name>字段进行...
  • java中优雅的参数校验方法

    万次阅读 多人点赞 2019-09-12 01:52:42
    如何更有“逼格”地在java中写出高大上的参数校验方法?
  • 【dubbo】参数校验

    千次阅读 2019-03-10 19:46:00
    dubbo的SPI扩展是有关于参数校验的SP扩展,校难的原理其实也是用的拦截器原理。dubbo包有一个 ValidationFilter的拦截器实现。dubbo是有自己的校验器实现的JValidator,如果需要自定义的话,则需要实现 ...
  • SpringBoot统一参数校验

    千次阅读 2020-03-04 22:18:50
    在日常的开发中,参数校验是非常重要的一个环节,严格参数校验会减少很多出bug的概率,增加接口的安全性。也会减少对接时不必要的沟通。比如说:在对接的时候前端动不动就甩个截图过来说接口有问题,你检查了半天...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 375,700
精华内容 150,280
关键字:

参数未通过校验