注解方式校验vo

最新推荐文章于 2024-06-16 09:11:36 发布
最新推荐文章于 2024-06-16 09:11:36 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： 优雅代码 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42179326/article/details/110478869
版权

目录结构

1、注解类

package com.annotation.validation.annotation;

import java.lang.annotation.*;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface FieldValidate {

    /**
     * 字段属性是否为空
     * @return
     */
    public boolean isEmpty() default false;

    /**
     * 字段长度
     * @return
     */
    public int max() default 0;

    /**
     * 当字段为条件必填时，需要配合conKey和conVal一起，例如conKey="idKind",conVal="90"
     * @return
     */
    public String conKey() default "";

    public String conVal() default "";
}

package com.annotation.validation.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface BigDecimalValidate {
    /**
     * 字段长度
     * @return
     */
    public int length() default 10;

    /**
     * 保留小数位
     * @return
     */
    public int scale() default 2;

    /**
     * 是否可以是负数
     * @return
     */
    public boolean isNegative() default false;
}

package com.annotation.validation.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DateValidate {

    /**
     * 日期格式
     * @return
     */
    public String format() default "yyyy-MM-dd";
}

package com.annotation.validation.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ObjectValidate {

    public Class<?> className();
}

2、校验工具类

package com.annotation.validation.utils;

import com.annotation.validation.annotation.BigDecimalValidate;
import com.annotation.validation.annotation.DateValidate;
import com.annotation.validation.annotation.FieldValidate;
import com.annotation.validation.annotation.ObjectValidate;
import com.annotation.validation.vo.ValidateVo;
import org.apache.commons.lang.StringUtils;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;

public class ValidateUtil {

    private static Map<String ,Object> REFLECT_CACHE = new ConcurrentHashMap<>();

    public static Map<String,Object> validateJson(Object bean,String prefixMsg){
        Map <String,Object> result = new HashMap();
        result.put("message","校验通过");
        result.put("result",true);
        Class<?> cls = bean.getClass();
        StringBuffer errorMsgBuffer = new StringBuffer(prefixMsg);

        boolean flag = true;
        //检测field是否存在
        String key = null;
        try{
            Field [] fields = null;
            key = cls.getName();
            if(REFLECT_CACHE.containsKey(key)){
                fields = (Field[])REFLECT_CACHE.get(key);
            }else{
                fields = cls.getDeclaredFields();
                REFLECT_CACHE.put(cls.getName(),fields);
            }
            for (Field field : fields) {
                field.setAccessible(true);//反射时访问私有变量
                Object value = field.get(bean);//获取字段值
                Annotation[] annoArr = null;//获取字段上的注解集合
                key = String.format("%s_%s",cls.getName(),field.getName());
                if(REFLECT_CACHE.containsKey(key)){
                    annoArr = (Annotation[]) REFLECT_CACHE.get(key);
                }else{
                    annoArr = field.getAnnotations();
                    REFLECT_CACHE.put(key,annoArr);
                }
                for (Annotation annotation : annoArr) {
                    Class<? extends Annotation> aClass = annotation.annotationType();//获取注解类型
                    Method [] methodArr = null;
                    key = String.format("%s_%s_%s",cls.getName(),field.getName(),aClass.getName());
                    if(REFLECT_CACHE.containsKey(key)){
                        methodArr = (Method[]) REFLECT_CACHE.get(key);
                    }else{
                        methodArr = aClass.getDeclaredMethods();
                        REFLECT_CACHE.put(key,methodArr);
                    }
                    for (Method method : methodArr) {
                        String methodName = method.getName();//获取注解类中的方法名
                        if("message".equals(methodName)||"conVal".equals(methodName)){//过滤错误提示方法的调用
                            continue;
                        }
                        if("conKey".equals(methodName)){//当字段为必填时,做特殊校验
                            result.put("message","校验通过");
                            result.put("result",true);
                            FieldValidate ann = field.getAnnotation(FieldValidate.class);
                            if(StringUtils.isNotBlank(ann.conKey())&&StringUtils.isNotBlank(ann.conVal())){
                                Method m = null;
                                key = String.format("METHOD_%s_%s",cls.getName(),methodName);
                                if(REFLECT_CACHE.containsKey(key)){
                                    m = (Method) REFLECT_CACHE.get(key);
                                }else{
                                    m = cls.getMethod(getMethodName(ann.conKey()));
                                    REFLECT_CACHE.put(key,m);
                                }
                                String valStr = (String)m.invoke(bean);
                                String tmpr = ("," + ann.conVal() + ",");
                                int temp = ("," + ann.conVal() + ",").indexOf("," + valStr + ",");
                                if((StringUtils.isNotBlank(valStr)) && ("," + ann.conVal() + ",").indexOf("," + valStr + ",") >= 0) {
                                    if(StringUtils.isBlank((String)value)) {
                                        flag = false;
                                        errorMsgBuffer.append(String.format("当字段[%s]符合条件[%s]时，[%s]字段不能为空",ann.conKey(),ann.conVal(),field.getName()) + ";");
                                    }
                                }
                            }
                            continue;
                        }
                        // 初始化注解验证的方法处理类 （我的处理方法加载本类中）
                        Object obj = ValidateUtil.class.newInstance();
                        // 获取方法
                        try {
                            // 根据方法名获取该方法
                            Method m =  null;
                            if(REFLECT_CACHE.containsKey(String.format("METHOD_%s", methodName))) {
                                m = (Method) REFLECT_CACHE.get(String.format("METHOD_%s", methodName));
                            } else {
                                m = obj.getClass().getDeclaredMethod(methodName, Object.class, Field.class);
                                REFLECT_CACHE.put(String.format("METHOD_%s", methodName), m);
                            }
                            // 调用该方法
                            result = (Map<String, Object>)m.invoke(obj, value, field);
                            /* 验证结果 拼接字符串 */
                            if(result.get("result").equals(false)) {
                                errorMsgBuffer.append(result.get("message"));
                                if(! (annotation instanceof ObjectValidate)) {
                                    errorMsgBuffer.append(";");
                                }
                                flag = false;
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                            result.put("result", false);
                            result.put("message", String.format("%s执行数据校验时异常1：%s", prefixMsg, e));
                            return result;
                        }
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            result.put("result", false);
            result.put("message", String.format("%s执行数据校验时异常2：%s", prefixMsg, e));
            return result;
        }
        result.put("result", flag);
        result.put("message", flag ? "校验成功" : errorMsgBuffer.toString());
        return result;
    }

    public static String getMethodName(String fieldName){
        byte[] bytes = fieldName.getBytes();
        bytes[0] = (byte)((char)bytes[0] - 'a' + 'A');
        return "get".concat(new String(bytes));
    }
    /**
     * 验证最大值
     *
     * @author zhy
     * @param value 参数值
     * @param field 字段
     * @return
     */
    public Map<String, Object> max(Object value, Field field) {
        Map<String, Object> validateResult = new HashMap<String, Object>();
        FieldValidate annotation = field.getAnnotation(FieldValidate.class);
        int len = 0;
        if(value instanceof String) {
            len = value.toString().length();
        }
        if(value != null && !value.equals("") && annotation.max() > 0 &&  len > annotation.max()) {
            validateResult.put("message", String.format("[%s]]字段长度过长, 长度最大限制为%s", field.getName(), annotation.max()));
            validateResult.put("result", false);
        } else {
            validateResult.put("message", "验证通过");
            validateResult.put("result", true);
        }

        return validateResult;
    }

    /**
     * 验证是否空值
     *
     * @author zhy
     * @param value 参数值
     * @param field 字段
     * @return
     */
    public Map<String, Object> isEmpty(Object value, Field field) {
        Map<String, Object> validateResult = new HashMap<String, Object>();
        validateResult.put("message", "验证通过");
        validateResult.put("result", true);

        FieldValidate annotation = field.getAnnotation(FieldValidate.class);
        if(!annotation.isEmpty()) {
            if(value == null || value.equals("")) {
                validateResult.put("message", String.format("[%s]字段不能为空值", field.getName()));
                validateResult.put("result", false);
            }

            if(value != null && value instanceof List) {
                if(((List)value).size() == 0) {
                    validateResult.put("message", String.format("[%s]字段不能为空值", field.getName()));
                    validateResult.put("result", false);
                }
            }
        }

        return validateResult;
    }

    /**
     * 校验日期格式是否正确
     * @param value
     * @param field
     * @return
     */
    public Map<String, Object> format(Object value, Field field) {
        Map<String, Object> validateResult = new HashMap<String, Object>();
        validateResult.put("message", "验证通过");
        validateResult.put("result", true);

        DateValidate annotation = field.getAnnotation(DateValidate.class);
        if(StringUtils.isNotBlank((String)value)) {
            try {
                Date dateTime = convertStringToDate(annotation.format(), (String)value);
                String dateStr = getDateString(dateTime, annotation.format());
                if(!dateStr.equals((String)value)) {
                    validateResult.put("message", String.format("[%s]字段日期格式不正确, 日期格式为%s", field.getName(), annotation.format()));
                    validateResult.put("result", false);
                }
            } catch (Exception e) {
                validateResult.put("message", String.format("[%s]字段日期格式不正确, 日期格式为%s", field.getName(), annotation.format()));
                validateResult.put("result", false);
            }
        }

        return validateResult;
    }

    /**
     * 校验是否为Decimal规定的格式：校验长度
     * @param value
     * @param field
     * @return
     */
    public Map<String, Object> length(Object value, Field field) {
        Map<String, Object> validateResult = new HashMap<String, Object>();
        validateResult.put("message", "验证通过");
        validateResult.put("result", true);
        BigDecimalValidate annotation = field.getAnnotation(BigDecimalValidate.class);
        String strVal = (String)value;
        if(StringUtils.isNotBlank(strVal)) {
            boolean flag = Pattern.matches("^-?[0-9]+\\.?[0-9]*$", strVal);
            if(!flag) {
                validateResult.put("message", String.format("[%s]字段不符合金额规则", field.getName()));
                validateResult.put("result", false);
                return validateResult;
            }

            if(strVal.replace(".", "").replace("-", "").length() > annotation.length()) {
                validateResult.put("message", String.format("[%s]字段长度过长，最大长度为%s", field.getName(), annotation.length()));
                validateResult.put("result", false);
            }
        }

        return validateResult;
    }

    /**
     * 校验是否可以是负数
     * @param value
     * @param field
     * @return
     */
    public Map<String, Object> isNegative(Object value, Field field) {
        Map<String, Object> validateResult = new HashMap<String, Object>();
        validateResult.put("message", "验证通过");
        validateResult.put("result", true);
        BigDecimalValidate annotation = field.getAnnotation(BigDecimalValidate.class);
        String strVal = (String)value;
        if(StringUtils.isNotBlank(strVal) && !annotation.isNegative()) {
            boolean flag = Pattern.matches("^-?[0-9]+\\.?[0-9]*$", strVal);
            if(flag) {
                BigDecimal bigDecimal = new BigDecimal(strVal);
                if(bigDecimal.compareTo(new BigDecimal(0)) < 0) {
                    validateResult.put("message", String.format("[%s]字段不能为负值", field.getName()));
                    validateResult.put("result", false);
                }
            }
        }

        return validateResult;
    }
    /**
     * 校验是否为Decimal规定的格式：校验小数点位数
     * @param value
     * @param field
     * @return
     */
    public Map<String, Object> scale(Object value, Field field) {
        Map<String, Object> validateResult = new HashMap<String, Object>();
        validateResult.put("message", "验证通过");
        validateResult.put("result", true);
        BigDecimalValidate annotation = field.getAnnotation(BigDecimalValidate.class);
        String strVal = (String)value;
        if(StringUtils.isNotBlank(strVal)) {
            String[] strs = strVal.split("\\.");
            if((strs.length == 1 ? 0 : strs[1].length()) > annotation.scale()) {
                validateResult.put("message", String.format("[%s]字段小数点位数过长，最大长度为%s", field.getName(), annotation.scale()));
                validateResult.put("result", false);
            }
        }

        return validateResult;
    }

    /**
     * 对字段类型为对象或者List进行校验
     * @param value
     * @param field
     * @return
     */
    public Map<String, Object> className(Object value, Field field) {
        Map<String, Object> validateResult = new HashMap<String, Object>();
        if(value != null) {
            if(value instanceof ArrayList) {
                List<Object> list = (List<Object>) value;
                validateResult.put("message", "验证通过");
                validateResult.put("result", true);
                StringBuffer buffer = new StringBuffer();
                boolean flag = true;
                for(Object val : list) {
                    Map<String, Object> result = ValidateUtil.validateJson(val, "");
                    if(!result.get("result").equals(true)) {
                        ObjectValidate annotation = field.getAnnotation(ObjectValidate.class);
                        flag = false;
                        buffer.append(String.format("%s对象中的参数有误：{%s}", annotation.className().getSimpleName(),
                                result.get("message")));
                    }
                }

                validateResult.put("result", flag);
                validateResult.put("message", flag ? "验证通过" : buffer.toString());
            } else {
                Map<String, Object> result = ValidateUtil.validateJson(value, "");
                if(result.get("result").equals(true)) {
                    validateResult.put("message", "验证通过");
                    validateResult.put("result", true);
                } else {
                    ObjectValidate annotation = field.getAnnotation(ObjectValidate.class);
                    validateResult.put("result", false);
                    validateResult.put("message", String.format("%s对象中的参数有误：{%s}", annotation.className().getSimpleName(),
                            result.get("message")));
                }
            }
        } else {
            validateResult.put("message", "验证通过");
            validateResult.put("result", true);
        }

        return validateResult;
    }
    public static final Date convertStringToDate(String aMask, String strDate) throws ParseException {
        SimpleDateFormat df = null;
        Date date = null;
        df = new SimpleDateFormat(aMask);
        try {
            date = df.parse(strDate);
        } catch (ParseException pe) {
            throw new ParseException(pe.getMessage(), pe.getErrorOffset());
        }

        return date;
    }

    public static String getDateString(Date _date, String patternString) {
        String dateString = "";
        if (_date != null) {
            SimpleDateFormat formatter = new SimpleDateFormat(patternString);
            dateString = formatter.format(_date);
        }
        return dateString;
    }
}

3、测试方法

public static void main(String []args){
        ValidateVo vo = new ValidateVo();
        vo.setApplicationId("csy12132");
        vo.setLoanAmount("2.4444");
        vo.setLoanDate("2020-10-23");
        ValidateVo.InnerVo innerVo = new ValidateVo.InnerVo();
        innerVo.setApplicationId("大世界");
        List<ValidateVo.InnerVo>list = new ArrayList<>();
        list.add(innerVo);
        vo.setInnerList(list);
        Map<String, Object> validateMap = ValidateUtil.validateJson(vo,String.format("调用接口[%s]参数有误",vo));
        validateMap.forEach((key,value)->
                System.out.println("key:"+key+",value:"+value));
    }

4、输出

 

 

 

 

 

 

林深时雾起~
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring注解式参数校验
凤歌
06-15 9万+
spring hibenate注解式参数验证
人体行为识别算法java_（原创）JAVA注解应用——实现属性的自动检测
weixin_29435115的博客
02-27 520
一、什么是注解Annotation(注解)是JDK5.0及以后版本引入的新特性。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注解是以‘@注解名’在代码中存在的，根据注解参数的个数，我们可以将注解分为：标记注解、单值注解、完整注解三类。它们都不会直接影响到程序的语义，只是作为注解(标识)存在，我们可以通过反射机制编程实现对这些元数据(用来描述数据的数据)的访问。二、注解能做什么A...
WebUtils工具类解析
热门推荐
weixin_38938982的博客
06-01 1万+
WebUtils根据名称，知道是Spring当中一个工具类，主要用于Web应用程序，供各种框架使用。其下有一些方法，如下：1.将一个系统性质设置到上下文根路径 public static void setWebAppRootSystemProperty(ServletContext servletContext) throws IllegalStateException { Assert.no...
Springboot 接口参数Vo传递校验
最新发布
qq_42898915的博客
06-16 36
在Spring Boot中，验证传入的实体属性
将map对象转换成vo对象
杨杨杨~~的博客
11-17 826
如果您觉得有用的话，记得给，写作不易啊^ _ ^。而且听说，实在白嫖的话，那欢迎常来啊!!!
map转换成VO
qingcyb的博客
05-25 2618
1、pom.xml依赖 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.16.10</version> </dependency> <dependency> <groupId>com.fasterxml.jackson
easycode模板，创作不易，谢谢支持！
05-20
实体类不做任何修改保证类与表统一，不使用冗余的vo dto，一个dto解决所有问题 2、实体类涵盖多种注解 日期格式编码、Long类型转String、字段自动填充、validate校验 3、自带insertOrUpdateBatch方法 4、自动生成...
04、商品服务1
08-03
接口文档是开发中不可或缺的部分，它详细描述了各个接口的使用方式和参数，方便开发者理解和调用。示例中给出了一个接口文档的地址，开发者可以通过该地址查看具体接口信息。 10. **对象划分**： 除了PO、DO和TO...
Struts2入门教程(全新完整版)
01-07
方式一、与Servlet解耦合的非IOC方式 20 方式二、与Servlet解耦合的IOC方式 21 方式三、与Servlet耦合的非IOC方式 21 方式四、与Servlet耦合的IOC方式 22 四、OGNL与ValueStack(VS) 22 1.值栈入门 22 2.OGNL入门 24 ...
Java编码规范【简易版】.pdf
12-28
4. `validGroup` 文件包：包含数据校验接口，每个模块一个校验组类。 命名规范是编码规范中的核心部分，它包括： - 参数命名：应清晰明了，反映参数的实际用途。 - 接口和方法：接口地址命名应简洁且描述性强，...
settlement-reconciliation.rar
09-25
Validated参数校验是Spring的一个注解驱动的验证框架，用于验证方法的输入参数。在本项目中，开发者利用Validated注解对入参进行约束，如非空检查、数据类型检查等，有效防止了因非法数据导致的错误。 参数实体化是...
后端对VO请求参数校验以及文件校验
罗格的博客
11-03 705
控制层请求入参 /** * 保存 */ @RequestMapping("/save") @ResponseBody public ApiResponses<Void> save(@RequestParam(value = "appCompanyCheckVOJson")String appCompanyCheckVOJson, //主表附件
JavaBeanVo字段注解校验hibernate.validate
CsbLanca
10-18 423
1.Controller对象参数添加注解 import javax.validation.Valid; // ... @PostMapping("insert") public ResultVo insertClient(@RequestBody @Valid ClientInfoVo clientInfoVo) { if(ObjectUtils.isEmpty(clientInfoVo)){ return ResultVo.fail("新增对象不能为空"
java vo 非空校验_GitHub - AggerChen/validator-test: SpringBoot参数校验框架使用demo
weixin_42451850的博客
02-26 630
SpringBoot使用@Validated验证参数一、前言在前端传递参数给后台接口的时候，后端会对传递的参数做一个基础校验，以前是手动写if一个个验证，效率极其低，而且还做了很多重复工作。本例没有太对基础和原理讲解，直接上代码，就是要简单粗暴，大家先用起来再说。项目源代码请访问github获取。二、使用步骤Hibernate Validator在JSR 303校验框架中提供了很多注解类。此Hib...
java中的前台传入参数检验,Spring Boot使用@Valid校验前端传递的参数
weixin_35775807的博客
03-21 1792
@Valid使用@Valid注解标注的参数，可直接配置校验注解拦截请求。@NotNull：字段不能为空。@NotBlank：字段不能为空或空白字符。@NotEmpty：字段不能为空或数量为零。(字符长度、集合大小、map大小、数组长度不能为零)@Size：字段元素大小范围。(null也视为有效元素)@Null：字段必须为空。@Min：字段最小值。(不适用double和float)@Max：字段最大...
@Validated对VO的多个参数进行顺序校验
yanglin_163_com的博客
12-25 2848
一、目的   使用@Validated对VO进行校验时，对多个参数进行顺序校验。 二、操作方法 1、假设有这样一个请求类RequestVo public class RequestVo{    private String name;//姓名    private String mobile;//手机号 } 姓名和手机号都需要校验，则创建两个接口类NameCheck和MobileC...
swagger日期参数校验不通过的解决办法
qq_44663150的博客
03-04 1349
如果前端需要传入一个Date类型的参数来查询，比如createdTime，如果按swagger给的日期参数，那么是会报错的。解决办法就是在参数上面加上： @JsonFormat(timezone="GMT+8", pattern="yyyy-MM-dd") 比如我的参数是封装在vo里面的，那么就在vo中的日期参数上面就上就好了。 ...
Java Bean Validation+springboot对API接口入参（vo）参数校验
aegsegher的博客
03-04 303
1. Api上加@Validated。2. 在vo上加@Validated。
使用validation 判断必填项，并且返回错误信息
chenxingde的博客
04-03 862
java 使用validation 判断必填项，并且返回错误信息
vo类中int型校验注解
05-24
您可以使用Java Bean Validation框架中的@Min和@Max注解来对int类型的字段进行校验。例如，如果您希望一个int字段的值必须大于等于0，可以这样写： ``` public class MyVO { @Min(0) private int myIntField; // getter and setter methods } ``` 类似的，如果您希望一个int字段的值必须小于等于100，可以这样写： ``` public class MyVO { @Max(100) private int myIntField; // getter and setter methods } ``` 您还可以使用@Range注解来限制int字段的范围。例如，如果您希望一个int字段的值必须在1到100之间，可以这样写： ``` public class MyVO { @Range(min = 1, max = 100) private int myIntField; // getter and setter methods } ``` 这些注解都是在运行时进行校验的，如果校验失败，会抛出ConstraintViolationException异常。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值