java注解实现对参数的校验

最新推荐文章于 2023-08-29 17:55:50 发布
最新推荐文章于 2023-08-29 17:55:50 发布
阅读量592 收藏 1
点赞数
分类专栏： 工具类 文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49374492/article/details/129006357
版权

基本思想也比较简单，就是基于反射来实现对模型中参数的校验

定义注解
/**
 * @Author: feifei
 * @Date: 2023/02/13/10:44 上午
 * @Description:
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.PARAMETER})
public @interface ValidateFei {
    /**
     * 小数位数 >0
     */
    int digit() default 0;

    /**
     * @see {@link BigDecimal} Number舍入模式ROUND_*
     */
    int round() default BigDecimal.ROUND_HALF_UP;

    /**
     * null时设置默认值
     */
    String defValue() default "null";

    /**
     * 是否可以为空
     */
    boolean nullable() default true;

    /**
     * 自定义异常说明
     *
     * @return
     */
    String nullableDesc() default "";

    /**
     * 最大长度
     */
    int maxLength() default 0;

    String maxLengthDesc() default "";

    /**
     * 最小长度
     */
    int minLength() default 0;

    String minLengthDesc() default "";

    /**
     * 中文最大长度
     */
    int maxChineseLenghth() default 0;

    String maxChineseLenghthDesc() default "";


    /**
     * 中文最小长度
     */
    int minChineseLength() default 0;

    String minChineseLengthDesc() default "";


    /**
     * Number 金额不为0
     */
    boolean notZero() default false;

    String notZeroDesc() default "";


    /**
     * @see {@link RegexTypeEnum} 提供几种常用的正则验证
     */
    RegexTypeEnum regexType() default RegexTypeEnum.NONE;

    String regexTypeDesc() default "";


    /**
     * 自定义正则验证
     */
    String regexExpression() default "";

    String regexExpressionDesc() default "";

    /**
     * 参数或者字段描述,这样能够显示友好的异常信息
     */
    String description() default "";

    /**
     * 集合非空
     */
    boolean notEmpty() default false;

    /**
     * 对象非null
     */
    boolean notNull() default false;

    /**
     * 字符串非空
     */
    boolean notBlank() default false;
}

同时附上基本正则校验规则的枚举

public enum RegexTypeEnum {
    NONE,
    SPECIAL_CHAR,
    CHINESE,
    EMAIL,
    IP,
    NUMBER,
    PHONE_NUMBER;

    private RegexTypeEnum() {
    }
}
定义校验工具类
/**
 * @Author: feifei
 * @Date: 2023/02/13/10:44 上午
 * @Description:
 */
public class ValidateFeiUtils {
    /**
     *
     * @param object 要被校验的对象
     * @throws Exception
     */
    public static void valid(Object object) throws  Exception {
        // 获取object的类型
        Class<? extends Object> clazz = object.getClass();
        // 获取该类型声明的成员
        Field[] fields = clazz.getDeclaredFields();
        //循环遍历对象中的属性
        for (Field field : fields) {
            // 获取对象的成员的注解信息
            ValidateFei validator = field.getAnnotation(ValidateFei.class);
            if (validator == null) {
                continue;
            }
            if (!field.isAccessible()) {
                field.setAccessible(true);
            }
            Object value = field.get(object);
            validField(value, validator, field, object);
        }
    }

    private static void validField(Object value, ValidateFei validator, Field field, Object object) throws  Exception {
        /*************注解解析工作开始******************/
        setAmountDigit(value, validator, field, object);

        setDefaultValue(value, validator, field, object);

        String description;
        if (StringUtil.isBlank(validator.description())) {
            description = field.getName();
        } else {
            description = validator.description();
        }

        validateNullable(description, value, validator);

        validateNotEmpty(description,value,validator);

        validateNotNull(description,value,validator);

        validateNotBlank(description,value,validator);

        validateNotZero(description, value, validator);

        validateLength(description, value, validator);

        validateRegexType(description, value, validator);

        validateRegexExpression(description, value, validator);
        /*************注解解析工作结束******************/
    }
    private static void setAmountDigit(Object value, ValidateFei validator, Field field, Object object) throws IllegalAccessException {
        if (value != null && validator.digit() > 0 && value instanceof BigDecimal) {
            field.set(object, ((BigDecimal) value).setScale(validator.digit(), validator.round()));
        }
    }

    private static void setDefaultValue(Object value, ValidateFei validator, Field field, Object object) throws ParseException, IllegalAccessException {
        if (value == null && !"null".equals(validator.defValue())) {
            // 获取POJO中属性为null的默认值
            Object defaultValue = getDefaultValue(field.getType(), validator.defValue());
            if (defaultValue != null) {
                field.set(object, defaultValue);
            }
        }
    }

    private static Object getDefaultValue(Class<?> type, String value) throws ParseException {
        if (type == Long.class) {
            return Long.valueOf(value);
        }
        if (type == Byte.class) {
            return Byte.valueOf(value);
        }
        if (type == BigDecimal.class) {
            return new BigDecimal(value);
        }
        if (type == Date.class) {
            return DateUtil.parse(value);
        }
        if (type == String.class) {
            return value;
        }
        return null;
    }

    private static void validateNullable(String description, Object value, ValidateFei validator) {
        if (validator.nullable()) {
            return;
        }
        if (StringUtils.isNotBlank(validator.nullableDesc())) {
            description = validator.nullableDesc();
        } else {
            description = description + "不能为空";
        }
        if(value instanceof java.util.List &&
                CollectionUtils.isEmpty((Collection<?>) value)){
            throw new IllegalArgumentException(description);
        }
        if (value == null) {
            throw new IllegalArgumentException(description);
        }
        if (value instanceof String && StringUtils.isBlank(value.toString())) {
            throw new IllegalArgumentException(description);
        }
    }

    private static void validateNotEmpty(String description, Object value, ValidateFei validator){
        if (!validator.notEmpty()) {
            return;
        }
        if (StringUtils.isNotBlank(validator.description())) {
            description = validator.description();
        } else {
            description = description + "不能为空";
        }
        if (value == null) {
            throw new IllegalArgumentException(description);
        }
        if(value instanceof Collection && CollectionUtils.isEmpty((Collection<?>) value)){
            throw new IllegalArgumentException(description);
        }
    }

    private static void validateNotNull(String description, Object value, ValidateFei validator){
        if (!validator.notNull()) {
            return;
        }
        if (StringUtils.isNotBlank(validator.description())) {
            description = validator.description();
        } else {
            description = description + "不能为空";
        }
        if (value == null) {
            throw new IllegalArgumentException(description);
        }
    }

    private static void validateNotBlank(String description, Object value, ValidateFei validator){
        if (!validator.notBlank()) {
            return;
        }
        if (StringUtils.isNotBlank(validator.description())) {
            description = validator.description();
        } else {
            description = description + "不能为空";
        }
        if (value == null) {
            throw new IllegalArgumentException(description);
        }
        if(value instanceof String && StringUtils.isBlank((String) value)){
            throw new IllegalArgumentException(description);
        }
    }

    private static void validateNotZero(String description, Object value, ValidateFei validator) {
        if (!validator.notZero()) {
            return;
        }
        if (value instanceof Number) {
            if (((Number) value).doubleValue() == 0) {
                if (StringUtils.isNotBlank(validator.notZeroDesc())) {
                    throw new IllegalArgumentException(validator.notZeroDesc());
                }
                throw new IllegalArgumentException(description + "不能为0");
            }
        }
    }

    private static void validateLength(String description, Object value, ValidateFei validator) {
        if (value != null && validator.maxLength() != 0 && value.toString().length() > validator.maxLength()) {
            if (StringUtils.isNotBlank(validator.maxLengthDesc())) {
                throw new IllegalArgumentException(validator.maxLengthDesc());
            }
            throw new IllegalArgumentException(description + "长度不能超过" + validator.maxLength());
        }
        if (value != null && validator.maxChineseLenghth() != 0 && ChineseCheckUtil.getChineseLength(value.toString()) > validator.maxChineseLenghth()) {
            if (StringUtils.isNotBlank(validator.maxChineseLenghthDesc())) {
                throw new IllegalArgumentException(validator.maxChineseLenghthDesc());
            }
            throw new IllegalArgumentException(description + "中文长度不能超过" + validator.maxChineseLenghth());
        }
        if (value != null && validator.minLength() != 0 && value.toString().length() < validator.minLength()) {
            if (StringUtils.isNotBlank(validator.minLengthDesc())) {
                throw new IllegalArgumentException(validator.minLengthDesc());
            }
            throw new IllegalArgumentException(description + "长度不能小于" + validator.minLength());
        }
        if (value != null && validator.minChineseLength() != 0 && ChineseCheckUtil.getChineseLength(value.toString()) < validator.minChineseLength()) {
            if (StringUtils.isNotBlank(validator.minChineseLengthDesc())) {
                throw new IllegalArgumentException(validator.minChineseLengthDesc());
            }
            throw new IllegalArgumentException(description + "中文长度不能小于" + validator.minChineseLength());
        }
    }

    private static void validateRegexType(String description, Object value, ValidateFei validator) {
        if (value == null || validator.regexType() == RegexTypeEnum.NONE) {
            return;
        }
        switch (validator.regexType()) {
            case NONE:
                break;
            case SPECIAL_CHAR:
                if (RegexUtils.hasSpecialChar(value.toString())) {
                    if (StringUtils.isNotBlank(validator.regexTypeDesc())) {
                        throw new IllegalArgumentException(validator.regexTypeDesc());
                    }
                    throw new IllegalArgumentException(description + "不能含有特殊字符");
                }
                break;
            case CHINESE:
                if (RegexUtils.isChinese2(value.toString())) {
                    if (StringUtils.isNotBlank(validator.regexTypeDesc())) {
                        throw new IllegalArgumentException(validator.regexTypeDesc());
                    }
                    throw new IllegalArgumentException(description + "不能含有中文字符");
                }
                break;
            case EMAIL:
                if (!RegexUtils.isEmail(value.toString())) {
                    if (StringUtils.isNotBlank(validator.regexTypeDesc())) {
                        throw new IllegalArgumentException(validator.regexTypeDesc());
                    }
                    throw new IllegalArgumentException(description + "地址格式不正确");
                }
                break;
            case IP:
                if (!RegexUtils.isIp(value.toString())) {
                    if (StringUtils.isNotBlank(validator.regexTypeDesc())) {
                        throw new IllegalArgumentException(validator.regexTypeDesc());
                    }
                    throw new IllegalArgumentException(description + "地址格式不正确");
                }
                break;
            case NUMBER:
                if (!RegexUtils.isNumber(value.toString())) {
                    if (StringUtils.isNotBlank(validator.regexTypeDesc())) {
                        throw new IllegalArgumentException(validator.regexTypeDesc());
                    }
                    throw new IllegalArgumentException(description + "不是数字");
                }
                break;
            case PHONE_NUMBER:
                if (!RegexUtils.isPhoneNumber(value.toString())) {
                    if (StringUtils.isNotBlank(validator.regexTypeDesc())) {
                        throw new IllegalArgumentException(validator.regexTypeDesc());
                    }
                    throw new IllegalArgumentException(description + "格式不正确");
                }
                break;
            default:
                break;
        }
    }

    private static void validateRegexExpression(String description, Object value, ValidateFei validator) {
        if (StringUtil.isBlank(validator.regexExpression())) {
            return;
        }
        if (value != null && !value.toString().matches(validator.regexExpression())) {
            if (StringUtils.isNotBlank(validator.regexExpressionDesc())) {
                throw new IllegalArgumentException(validator.regexExpressionDesc());
            }
            throw new IllegalArgumentException(description + "格式不正确");
        }
    }
}
基本测试

测试的model定义

/**
 * @Author: feifei
 * @Date: 2023/02/13/11:00 上午
 * @Description:
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TestModel {
    @ValidateFei(notEmpty = true,description = "姓名集合")
    private List<String> nameList;
    @ValidateFei(regexType = RegexTypeEnum.PHONE_NUMBER,description = "手机号码")
    private String number;
}

测试的main方法

/**
 * @Author: feifei
 * @Date: 2023/02/13/11:02 上午
 * @Description:
 */
public class Test {
    public static void main(String[] args) throws  Exception {
        TestModel testModel = new TestModel();
        testModel.setNumber("13279930454");
        ValidateFeiUtils.valid(testModel);
    }
}

至此结束，同样的可以自己添加适合自己业务需求的校验规则

Quare_feifei
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Java实战】使用自定义注解实现参数校验详解
~~~~~~~BUG FLY~~~~~~~~~
04-19 2022
由于实际开发中遇到大量相同的条件参数验证，不想写重复代码及让代码看起来更加优雅简洁，所以决定使用自定义注解进行参数校验Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能，注解相关类都包含在java.lang.annotation包中其中参数校验的注解来自三方面，分别是javax.validation:validation-api，对应包javax.validation.constraints。
自定义注解--实现参数校验
weixin_58633569的博客
03-16 1311
学习内容： 自定义注解，校验传入数据是否为“asc”或“desc” 学习心得： 1.自定义注解的基本步骤： 在项目中新建一个包annotation，用于以后存放自定义的注解。 在annotation包中新建一个注解类，根据注解的功能命名，命名需要遵循大驼峰法则。 在注解类的类名上方，添加注解 @Target(用于说明注解可以应用的范围，比如类、类的属性、方法、方法参数等) @Retention（用于说明注解起作用的时间，比如在源代码中、在编译时、在运行时） @Constraint实现注解的功能时需要用，
JAVA里自定义注解来进行数据验证
weixin_34337381的博客
08-16 319
API开发中经常会遇到一些对请求数据进行验证的情况，这时候如果使用注解就有两个好处，一是验证逻辑和业务逻辑分离，代码清晰，二是验证逻辑可以轻松复用，只需要在要验证的地方加上注解就可以。 Java提供了一些基本的验证注解，比如@NotNull、@Size，但是更多情况下需要自定义验证逻辑，这时候就可以自己实现一个验证注解，方法很简单，仅需要两个东西： 一个自定义的注解，并且指定验证器 一个验证器的...
java 数据验证_JAVA中通过自定义注解进行数据验证的方法
weixin_39562338的博客
02-15 307
前言最近为了工作也为了更加深入了解掌握java注解的使用，决定自定义注解来实现数据验证。API开发中经常会遇到一些对请求数据进行验证的情况，这时候如果使用注解就有两个好处，一是验证逻辑和业务逻辑分离，代码清晰，二是验证逻辑可以轻松复用，只需要在要验证的地方加上注解就可以。Java提供了一些基本的验证注解，比如@NotNull、@Size，但是更多情况下需要自定义验证逻辑，这时候就可以自己实现一个验...
Java中自定义注解进行参数验证
重复生活的博客
03-14 6647
Java自定义参数验证注解
java实现自定义校验注解
abc1932513663的博客
11-28 936
java自定义校验注解 是元注解，可以修饰其他注解，可以修饰其他注解，如果一注解没有被@Documented修饰，最终生成的文档中不会带此注解。
注解+AOP优雅的实现java项目的接口参数校验(含源码)
01-17
基于Spring boot + maven，以注解+AOP方式实现的java后端项目接口参数校验框架。迄今为止使用最简单、最容易理解的参数校验方案。博客地址：https://blog.csdn.net/weixin_42686388/article/details/104009771
java自定义注解实现前后台参数校验的实例
09-01
总的来说，Java自定义注解提供了一种灵活且可扩展的方式来实现参数校验，使得代码更加模块化，提高了代码的可读性和维护性。在项目开发中，合理地使用自定义注解可以有效地提升代码质量，减少因输入数据不合法导致的...
自定义注解实现参数校验
weixin_44889538的博客
08-13 304
实体类中参数校验使用自定义注解 1.参数校验工具依赖 <dependency> <groupId>javax.validation</groupId> <artifactId>validation-api</artifactId> <version>2.0.1.Final</version> </dependency> 2.自定义注解校验器 public class IsBooleanC
JAVA中通过自定义注解进行数据验证的方法
08-27
java 自定义注解验证可自己添加所需要的注解，下面这篇文章主要给大家介绍了关于JAVA中通过自定义注解进行数据验证的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧
JAVA: 自定义注解来进行数据验证
Java笔记虾
11-09 605
点击上方“后端技术精选”，选择“置顶公众号”技术文章第一时间送达！作者：Decouplecnblogs.com/xz816111/p/9484902.htmlAPI开发中经常会遇到一些对请求数据进行验证的情况，这时候如果使用注解就有两个好处，一是验证逻辑和业务逻辑分离，代码清晰，二是验证逻辑可以轻松复用，只需要在要验证的地方加上注解就可以。Java提供了一些基本的验证注解，比如@NotNull、@...
Java自定义注解进行参数校验
小学生的博客
05-25 2744
Java自定义注解 关于自定义注解的使用方法和原理，以及通过自定义注解进行参数校验
java 自定义注解校验
qq_33732195的博客
04-14 684
有时候JSR303的规范自带的注解不满足我们的数据校验需求，例如显示状态showStatus，只能接受0和1，这时我们可以自己写自定义注解校验规则； 在实体类加@ListValue注解，vals里面的值表示只能接收的值； @ListValue(vals={0,1}) private Integer showStatus; 编写自定义ListValue自定义校验接口类； import javax.validation.Constraint; import javax.validation.Payload;
Java自定义校验注解实现List、set集合字段唯一性校验
suiyishiguang的博客
08-04 3069
Java自定义校验注解实现List、set集合字段唯一性校验
java自定义注解实现请求参数校验
05-13 1360
java自定义注解实现请求参数校验创建自定义注解通过Java反射获取entity属性AOP切面用法示例 创建自定义注解 // 加在属性字段上 @Traget(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface NotNullField { // 最小值 int min() default 0; // 最大值 int max() default 0; // 最大长度 int length() d
java自定义注解实现校验对象属性是否为空
cpown的博客
07-03 6811
前面学习了如何自定义一个注解：java如何优雅的自定义一个注解 下面来实战演示一下如何使用自定义注解做一些实际的功能。比如校验对象属性是否为空。 一、自定义一个NotNull注解 我们自定义一个NotNull注解，里面有一个参数message 默认为“”； /** * 自定义注解 * 判断屬性不为空注解 */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface NotNull { /*
Java自定义校验注解
pig_boss的博客
08-29 863
​ JSR303 是一套JavaBean参数校验的标准，它定义了很多常用的校验注解，我们可以直接将这些注解加在我们JavaBean的属性上面(面向注解编程的时代)，就可以在需要校验的时候进行校验了,在SpringBoot中已经包含在starter-web中,再其他项目中可以引用依赖,并自行调整版本--springboot 新版本需要validation启动器-->当框架提供的注解无法满足我们的需求时，我们就可以自定义注解进行校验。
Java开发中自定义校验注解
雲浩的博客
03-28 3296
在日常的开发中可能会对手机号、邮箱、身份证号的合法性进行校验，然而每次使用if语句调用校验函数进行校验又显得过于麻烦，这时候自定义校验注解用处就很大了。 1、需要的依赖 <!-- hibernate validator --> <dependency> <groupId>javax.validation</groupId> ...
java自定义注解实现参数校验
最新发布
09-08
通过自定义注解实现参数校验可以方便地对代码进行统一的校验规则管理，提高代码的可维护性和可读性。同时，由于注解是在运行时通过反射获取，可以对代码进行动态改变和扩展，使得我们可以更加灵活地进行参数校验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Quare_feifei

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值