自己动手实现Java Validation

最新推荐文章于 2024-07-18 09:55:51 发布
最新推荐文章于 2024-07-18 09:55:51 发布
阅读量459 收藏
点赞数
分类专栏： J2EE 文章标签： java
参数检查用得最多的是JSR 303，用法示例：
[url]http://blog.csdn.net/caihaijiang/article/details/7463514[/url]
但JSR 303有个缺点，那就是当参数的限制发生变化时，例如某String类型的最大长度由10改为20，就需要改代码重新编译。
那有没有办法只改配置文件重启程序就达到目的呢？
网上还没有类似的解决方案，那就自己实现Java Validation。

思路：
参数检查时，从配置文件中取得参数的限制条件，通过反射取得对应的字段值，并进行验证。

用法： 

	//利用反射和注解自行实现的参数检查

            Order order = newOrder();
            Map<String, String> configMap = ConfigMap.INSTANCE.getMap();

			//需要两个参数：一是需要参数检查的对象，二是参数的限制条件
            List<String> list = Checker.INSTANCE.check(order, configMap);
            for (String str : list) {

				/*输出示例：
				cardNo不符合正则表达式\d+
				name长度最小不能小于2
				address长度最小不能小于2
				intVal最大不能超过9
				integerVal最小不能小于4
				longVal最小不能小于4
				longGVal最小不能小于4
				*/
                System.out.println(str);
            }

        }



	
package com.ljn.validation;

import java.util.HashMap;
import java.util.Map;

/**
 * 
 * 模拟从配置文件中读取配置值
 * 用点号分隔，最后是字段名
 */
public enum ConfigMap {
    INSTANCE;

    private Map<String, String> map;

    ConfigMap() {
        map = new HashMap<String, String>();

        //在配置文件中这样写：check.com.ljn.validation.MyOrder.userId.max=3
        //表示MyOrder这个类的userId字段，长度最大为3
        map.put("check.com.ljn.validation.MyOrder.userId.max", "3");
        map.put("check.com.ljn.validation.MyOrder.name.max",  "3");
        map.put("check.com.ljn.validation.MyOrder.address.max", "3");

        map.put("check.com.ljn.validation.MyOrder.cardNo.reg", "\\d+");

        map.put("check.com.ljn.validation.MyOrder.intVal.max",  "9");
        map.put("check.com.ljn.validation.MyOrder.integerVal.max",  "9");
        map.put("check.com.ljn.validation.MyOrder.longVal.max",  "9");
        map.put("check.com.ljn.validation.MyOrder.longGVal.max",  "9");

        map.put("check.com.ljn.validation.MyOrder.userId.min", "2");
        map.put("check.com.ljn.validation.MyOrder.name.min",  "2");
        map.put("check.com.ljn.validation.MyOrder.address.min", "2");

        map.put("check.com.ljn.validation.MyOrder.intVal.min",  "4");
        map.put("check.com.ljn.validation.MyOrder.integerVal.min",  "4");
        map.put("check.com.ljn.validation.MyOrder.longVal.min",  "4");
        map.put("check.com.ljn.validation.MyOrder.longGVal.min",  "4");

        map.put("check.com.ljn.validation.MyOrder.bigDecimalVal.maxBigDecimalIntegerSize",  "5");
        map.put("check.com.ljn.validation.MyOrder.bigDecimalVal.maxBigDecimalFractionSize",  "2");
    }

}


package com.ljn.validation;

import java.math.BigDecimal;
import java.util.List;

import javax.validation.constraints.Digits;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

public class Order {

    @Check(NotNull=true)
    @NotNull
    private List nullVal;

    @Size(min =2, max = 3)
    @Check(Min=true,Max=true)
    private String name;

    @Size(min =2, max = 3)
    @Check(Min=true, Max=true)
    private String address;

    private String userId;

    @Min(4)
    @Max(9)
    @Check(Min=true, Max=true)
    private int intVal;

    @Min(4)
    @Max(9)
    @Check(Min=true, Max=true)
    private Integer integerVal;

    @Min(4)
    @Max(9)
    @Check(Min=true, Max=true)
    private long longVal;

    @Min(4)
    @Max(9)
    @Check(Min=true, Max=true)
    private Long longGVal;

    @Digits(integer=5, fraction=2)
    @Check(MaxBigDecimalFractionSize=true, MaxBigDecimalIntegerSize=true)
    private BigDecimal bigDecimalVal;

//...setter and getter
    }

测试表明，Checker比JSR 303速度更快。Checker没有JSR 303那么全面，但也基本够用。

源码： 

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

/**
 * 1.NotNull/NotBlank默认值为false，其他为true
 * 2.即使Min/Max/MaxBigDecimalIntegerSize/MaxBigDecimalFractionSize/RegExp这些选项配置为true，
 *   也需要在配置文件中配置了具体值才会进行检查
 * 3.对于String类型，不要同时配置NotNull和NotBlank，建议只配置NotBlank
 * @author ljn
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Check {

    /**
     * 检查是否为null，适用所有数据类型
     */
    public boolean NotNull() default false;

    /**
     * 检查字符串是否为空字符串（包括null），相当于StringUtils.isBlank
     */
	public boolean NotBlank() default false;

	/**
	 * 对于String类型，检查字符串长度是否小于最小长度
	 * 对于short/Short/int/Integer/long/Long类型，检查是否小于最小值
	 */
	public boolean Min() default true;

	/**
     * 对于String类型，检查字符串长度是否超过最大长度
     * 对于short/Short/int/Integer/long/Long类型，检查是否超过最大值
     */
	public boolean Max() default true;

	/**
	 * 检查BigDecimal类型的整数部分的长度是否超过最大长度
	 */
	public boolean MaxBigDecimalIntegerSize() default true;

	/**
     * 检查BigDecimal类型的小数部分的长度是否超过最大长度
     */
	public boolean MaxBigDecimalFractionSize() default true;

	/**
	 * 检查字符串类型的值是否符合正则表达式指定的格式
	 */
	public boolean RegExp() default true;

}

public enum Checker {

    INSTANCE;


    public static final String KEY_SEPARATOR = ".";
    public static final String PREFIX = "check";
    public static final String SUFFIX_MAX = "max";
    public static final String SUFFIX_MIN = "min";
    public static final String SUFFIX_MAX_BIGDECIMAL_INTEGER_SIZE = "maxBigDecimalIntegerSize";
    public static final String SUFFIX_MAX_BIGDECIMAL_FRACTION_SIZE = "maxBigDecimalFractionSize";
    public static final String SUFFIX_REG_EXP = "regExp";

    private Map<Class<?>, List<Field>> classFields = new HashMap<Class<?>, List<Field>>();

    /**
     * 
     * @param obj 对obj进行参数检查
     * @param configMap 配置值，配置了各字段的限制值，例如最小长度，最大长度
     * @return 参数不合法的信息列表
     */
    public List<String> check(Object obj, Map<String, String> configMap){
        List<String> list = new ArrayList<String>();

        if (obj == null || configMap == null || configMap.isEmpty()) {
            return list;
        }

        Class<? extends Object> clazz = obj.getClass();
        List<Field> fields = classFields.get(clazz);
        if (fields == null) {
            fields = getFieldsUpTo(clazz, Object.class);
            if (fields == null || fields.isEmpty()) {
                return list;
            }
            classFields.put(clazz, fields);
        }

        for (Field field : fields) {
            field.setAccessible(true);
            Check check = field.getAnnotation(Check.class);
            if (check == null) {
                continue;
            }

            Class<?> fieldType = field.getType();
            String fieldName = field.getName();
            Object value = null;
            try {
                value = field.get(obj);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }

            if (value == null) {
                if (check.NotNull()) {
                    list.add(fieldName + "不能为null");
                } else if ( check.NotBlank() && fieldType.equals(String.class)) {
                    list.add(fieldName + "不能为空");
                }
            } else {

                //check_className_fieldName_suffix
                String minKey = StringUtils.join(new String[]{PREFIX, clazz.getName(), fieldName, SUFFIX_MIN}, KEY_SEPARATOR);                
                String maxKey = StringUtils.join(new String[]{PREFIX, clazz.getName(), fieldName, SUFFIX_MAX}, KEY_SEPARATOR);                
                String maxBigDecimalIntegerSizeKey = StringUtils.join(new String[]{PREFIX, clazz.getName(), fieldName, SUFFIX_MAX_BIGDECIMAL_INTEGER_SIZE}, KEY_SEPARATOR);
                String maxBigDecimalFractionSizeKey = StringUtils.join(new String[]{PREFIX, clazz.getName(), fieldName, SUFFIX_MAX_BIGDECIMAL_FRACTION_SIZE}, KEY_SEPARATOR);
                String regExpKey = StringUtils.join(new String[]{PREFIX, clazz.getName(), fieldName, SUFFIX_REG_EXP}, KEY_SEPARATOR);

                if (fieldType.equals(String.class)) {
                    String val = (String)value;
                    if (check.NotBlank() && StringUtils.isBlank(val)) {
                        list.add(fieldName + "不能为空");
                    }
                    if (check.Min()) {
                        int min = getInt(configMap, minKey);
                        if (min != -1 && val.length() < min) {
                            list.add(fieldName + "长度最小不能小于" + min); 
                        }
                    }
                    if (check.Max()) {
                        int max = getInt(configMap, maxKey);
                        if (max != -1 && val.length() > max) {
                            list.add(fieldName + "长度最大不能超过" + max); 
                        }
                    }
                    if (check.RegExp()) {
                        String exp = configMap.get(regExpKey);
                        if (StringUtils.isNotBlank(exp) && StringUtils.isNotBlank(val) && !val.matches(exp)) {
                            list.add(fieldName + "不符合正则表达式" + exp);
                        }
                    }
                }

                if (fieldType.equals(Integer.class) || fieldType.equals(int.class)) {
                    Integer val = (Integer)value;
                    if (check.Min()) {
                        int min = getInt(configMap, minKey);
                        if (min != -1 && val < min) {
                            list.add(fieldName + "最小不能小于" + min); 
                        }
                    }
                    if (check.Max()) {
                        int max = getInt(configMap, maxKey);
                        if (max != -1 && val > max) {
                            list.add(fieldName + "最大不能超过" + max); 
                        }
                    }
                }

                if (fieldType.equals(Short.class) || fieldType.equals(short.class)) {
                    Short val = (Short)value;
                    if (check.Min()) {
                        int min = getInt(configMap, minKey);
                        if (min != -1 && val < min) {
                            list.add(fieldName + "最小不能小于" + min); 
                        }
                    }
                    if (check.Max()) {
                        int max = getInt(configMap, maxKey);
                        if (max != -1 && val > max) {
                            list.add(fieldName + "最大不能超过" + max); 
                        }
                    }
                }

                if (fieldType.equals(Long.class) || fieldType.equals(long.class)) {
                    Long val = (Long)value;
                    if (check.Min()) {
                        long min = getLong(configMap, minKey);
                        if (min != -1 && val < min) {
                            list.add(fieldName + "最小不能小于" + min); 
                        }
                    }
                    if (check.Max()) {
                        long max = getLong(configMap, maxKey);
                        if (max != -1 && val > max) {
                            list.add(fieldName + "最大不能超过" + max); 
                        }
                    }
                }

                if (fieldType.equals(BigDecimal.class)) {
                    BigDecimal val = (BigDecimal)value;
                    String str = val.toPlainString();
                    String[] parts = str.split("\\.");
                    if (parts == null || parts.length == 0) {
                        continue;
                    }
                    int integerSize = parts[0].length();
                    int fractionSize = parts.length == 2 ? parts[1].length() : 0;
                    if (check.MaxBigDecimalIntegerSize()) {
                        int max = getInt(configMap, maxBigDecimalIntegerSizeKey);
                        if (max != -1 && integerSize > max) {
                            list.add(fieldName + "整数部分长度最大不能超过" + max);
                        }
                    }
                    if (check.MaxBigDecimalFractionSize()) {
                        int max = getInt(configMap, maxBigDecimalFractionSizeKey);
                        if (max != -1 && fractionSize > max) {
                            list.add(fieldName + "小数部分长度最大不能超过" + max);
                        }
                    }
                }


            }


        }
        return list;
    }

    /**
     * 获取所有的Field
     * @param startClass
     * @param exclusiveParent
     * @return
     */
    public List<Field> getFieldsUpTo(Class<?> startClass, Class<?> exclusiveParent) {

        List<Field> currentClassFields = new ArrayList<Field>();
        Field[] declaredFields = startClass.getDeclaredFields();
        for (Field field : declaredFields) {
            currentClassFields.add(field);
        }
        Class<?> parentClass = startClass.getSuperclass();

        if (parentClass != null && (exclusiveParent == null || !(parentClass.equals(exclusiveParent)))) {
            List<Field> parentClassFields = (List<Field>) getFieldsUpTo(parentClass, exclusiveParent);
            currentClassFields.addAll(parentClassFields);
        }

        return currentClassFields;
    }

    private static int getInt(Map<String, String> map, String key) {
        String val = map.get(key);
        if (val != null) {
            return Integer.parseInt(val);
        }
        return -1;
    }

    private static long getLong(Map<String, String> map, String key) {
        String val = map.get(key);
        if (val != null) {
            return Long.parseLong(val);
        }
        return -1;
    }


}


bylijinnan
关注
专栏目录
【大模型应用开发 动手做AI Agent】思维树
程序员光剑
06-03 353
随着深度学习技术的不断发展，人工智能领域的应用不断拓展。其中，大型模型（Large Model）在各个领域中取得了显著的成功，包括自然语言处理、图像识别、计算机视觉等。今天，我们将探讨如何开发大型模型应用，特别是在AI Agent（智能代理）领域的应用。随着深度学习技术的不断发展，大型模型应用在各个领域中取得了显著的成功。然而，未来还面临着一些挑战，例如，数据质量问题、计算资源限制、安全性问题等。
java validate 注解_Java Validation Api如何实现自定义注解
weixin_31807925的博客
02-24 677
背景官方提供的注解多数可以解决现实业务场景中基本业务校验，但有些特殊场景因业务的复杂性，也还是需要在入口处对入参进行各种角度的校验，以求简化业务层的处理，降低业务处理复杂性与方法入口的强约束性。 以上背景，下面就举个简单Demo进行自定义注解校验的实现。注解定义类import javax.validation.Constraint;import javax.validation.Payload;i...
自写 js validation 验证框架
生活需要用心
02-15 225
 一、背景：    一个表单的填写，分了n个页面，第一个页面必须首先填写，再可填其他页面，tab切换的时候要验证当前页面的元素，验证不通过的不能切换的其他页继续填写表单。。。。由于很多验证框架都是与form绑定的，导致无法实现这样的需求  针对这样的需求，写了一个验证框架，目前只支持IE，其他还有待完善，也希望各位大大们给些修改的建议，满足如下： 1、可通过form或者table的id，验证f...
Java参数校验Validation，SpringBoot中使用@Valid@Validated注解
最新发布
weixin_45951955的博客
07-18 714
因为本人暂时没用到，所以先不写。可以参考别的大佬写的：
SpringMVC 使用JSR-303进行校验
周洲 （Julie）
05-31 792
一、准备校验时使用的JAR validation-api-1.0.0.GA.jar：JDK的接口； hibernate-validator-4.2.0.Final.jar是对上述接口的实现； log4j、slf4j、slf4j-log4j   二、编写需要校验的bean @NotNull(message="名字不能为空") private String userNa
validation自定义注解校验枚举类型
东境物语
02-21 4436
java validation内没有对枚举的校验工具，但是离散的枚举值校验确实是有必要的。javax.validation包提供了方便的自定义校验的入口，就是javax.validation.ConstraintValidator,故可以通过自定义校验枚举类型方式实现。 一、定义一个校验注解，类似于@NotNull @Size等等那样 import javax.validat...
java自定义校验
qq_42313997的博客
09-18 820
java自定义校验注解
java后台验证不能为空_java validation 后台参数验证的使用详解
weixin_34470566的博客
03-08 3468
一、前言在后台开发过程中，对参数的校验成为开发环境不可缺少的一个环节。比如参数不能为null，email那么必须符合email的格式，如果手动进行if判断或者写正则表达式判断无意开发效率太慢，在时间、成本、质量的博弈中必然会落后。所以把校验层抽象出来是必然的结果，下面说下几种解决方案。二、几种解决方案1、struts2的valid可以通过配置xml，xml中描述规则和返回的信息，这种方式比较麻烦、...
DJL-Java开发者动手学深度学习之使用Softmax进行分类代码实现
xxcnb的博客
12-25 1028
我们已经讲了Softmax的数学原理。在这里，我们就用Java代码来实现整个模型的训练。
Java之Redis队列+Websocket+定时器实现跑马灯实时刷新
阿毅
01-10 1万+
开心一笑【老婆对老公说：老公你说我奇怪不奇怪啊，我既然可以用眼睛吃饭也。老公：说的新鲜，怎么用眼睛怎么吃饭啊。老婆说：我看你一眼就饱了……】提出问题项目中如何利用Redis队列+定时器（quartz）+websocket实现实时刷新的跑马灯功能???解决问题1.业务描述这几天，公司有个业务，具体内容如下：在仪表盘banner区域滚动播放提示信息。也就是实现一个实时播放消息的跑马灯功能。播放的是一个任
【大模型应用开发 动手做AI Agent】人类的大脑了不起
程序员光剑
05-27 472
1. 背景介绍 近年来，人工智能（AI）和机器学习（ML）领域的快速发展为我们提供了许多令人兴奋的技术和创新解决方案。其中，深度学习（Deep Learning，DL）和生成模型（Generative Models）在许多领域取得了显著的成果。然而，尽管如此，我们的AI仍然没有达到人类大脑的水平。为什么？我们如何才能创造出类似人类大脑的AI呢？
Java Validation Api实现原理解析
09-07
主要介绍了Java Validation Api实现原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Bean Validation参数校验
u010486495的专栏
12-07 2788
Validation 加入validation校验 @Data public class StaffDto { /** * 用户名称 */ @NotBlank(message = "姓名不能为空！") private String name; /** * 年龄 */ @NotNull(message = "年龄不能为空！") private Integer age; /** * 手机号
java validate() 方法的用法
w73060815的博客
03-27 2451
在教程书书上看到了两次，第一次记得查过，第二次遇见觉得莫名其妙于是又在全网搜索，翻了很长时间，一堆垃圾信息，气得人强迫症都犯了。最后终于找到它在java.awt.Component包里，于是自己动手查API。 直接贴图 ...
自己实现一个枚举validation校验器
Mr1ght的博客
07-25 628
平时我们在进行接口校验的时候，我们会使用@Validation相关注解来帮助我们简化代码。其常用的注解其实已经能满足很大一部分需求，但是在进行枚举字段的接口校验的时候没有相关字段，尤其在我们不是使用枚举的name()方法来传递的时候，枚举的校验就需要很多类似的大段的方法来进行校验。而validation本身是提供了扩展的方法的，因此在次基础上实现了一个对枚举进行校验的注解。...
Validation校验框架的自定义注解
hanxiaozhang的博客
08-23 3635
前言： 最近单位在新开发一个系统，我主要负责订单模块的开发，这个模块的数据结构嵌套层数比较多，如果自己写一个校验方法，校验比较麻烦。所以，我选择了Validation校验框架。技术是一把双刃剑，Validation对非空，数据大小，长度这样简单的校验一个注解就可以搞定。但是对一些复杂的校验，明显感觉不是特别友好。Validation也对复杂的校验提供了自定义注解的解决方案，但是，可能还有一些复杂的校验Validation不能实现，这些就需要换另一些方式去实现。 正文： 一、Validation中的注解
Java代码简洁-validation参数校验
weixin_43994244的博客
07-09 8646
validation参数校验
使用spring validation完成数据后端校验
热门推荐
徐靖峰的专栏
08-16 12万+
前言数据的校验是交互式网站一个不可或缺的功能，前端的js校验可以涵盖大部分的校验职责，如用户名唯一性，生日格式，邮箱格式校验等等常用的校验。但是为了避免用户绕过浏览器，使用http工具直接向后端请求一些违法数据，服务端的数据校验也是必要的，可以防止脏数据落到数据库中，如果数据库中出现一个非法的邮箱格式，也会让运维人员头疼不已。我在之前保险产品研发过程中，系统对数据校验要求比较严格且追求可变性及效率，
java validation_Java bean validation 规范与参考实现
weixin_42332497的博客
02-16 315
JSR 303 – Bean Validation 是一个数据验证的规范。 2009年11月正式发布最终版本。在任何时候，当你要处理一个应用程序的业务逻辑，数据校验是你必须要考虑和面对的事情。应用程序必须通过某种手段来确保输入进来的数据从语义上来讲是正确的。在通常的情况下，应用程序是分层的，比如表现层，业务层，持久化层等，很多时候同样的数据验证逻辑会出现在不同的层，这样就会导致代码冗余和一些管理的...
Java Validation：后台参数验证实战与解析
"Java Validation是Java中用于后台参数验证的技术，它可以帮助开发者高效地校验输入数据，确保程序的稳定性和安全性。本文将详细介绍Java Validation的使用方法，并提供几种常见的解决方案，包括Bean Validation框架...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值