SpringBoot项目自定义校验枚举注解

最新推荐文章于 2024-05-14 13:42:57 发布
最新推荐文章于 2024-05-14 13:42:57 发布
阅读量3.1k 收藏 7
点赞数
分类专栏： java实战开发 # SpringBoot 文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37132495/article/details/122743682
版权

文章目录

1. 使用场景

某接口的入参某属性，只希望为系统中某枚举的中定义过的值。


例如：用户类型枚举中定义 10-普通用户 20-管理员 30-游客 40-中级用户 50-高级用户
希望某接口的入参 userType 只能填入这几种type


支持扩展场景：

  1. 只允许填入枚举中定义过的某些值
  2. 不允许填入某些值

2. 技术实现

2.1 实现思路

使用Hibernate Validator校验工具，自定义校验注解及其校验逻辑。


Hibernate Validator官方文档：
https://docs.jboss.org/hibernate/validator/7.0/reference/en-US/html_single/#validator-gettingstarted

2.2 代码实现

2.2.1 引入依赖

<!--springboot2.3.3版本后 参数校验需加上 begin-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-validation</artifactId>
 </dependency>
 <!--springboot2.3.3版本后 参数校验需加上 end-->

2.2.2 自定义校验注解

/**
 * 校验枚举类值注解
 *
 * @author Gangbb
 * @date 2021/11/6
 **/
@Target({ElementType.PARAMETER, ElementType.FIELD})
@Retention(RUNTIME)
@Repeatable(VerifyEnum.List.class)
@Constraint(validatedBy = {EnumValidator.class})
public @interface VerifyEnum {

    /**
     * 枚举类型
     */
    Class<? extends Enum<?>> enumClass();


    /**
     * 枚举中用于校验的属性值
     **/
    String keyColumn();

    /**
     * 只允许填的枚举code值(填了非枚举code值会报错)
     */
    String[] allowedValues() default { };

    /**
     * 不允许填的枚举code值
     */
    String[] notAllowedValues() default { };

    /**
     * 错误消息
     **/
    String message() default "";

    Class<?>[] groups() default { };

    Class<? extends Payload>[] payload() default {};

    @Target({ElementType.PARAMETER, ElementType.FIELD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface List {
        VerifyEnum[] value();
    }
}

2.2.3 校验工具类

/**
 * hibernate Validator校验工具类
 *
 * @author Gangbb
 * @date 2022/1/29
 **/
public class ValidatorUtils {
    /**
     * 验证器工程
     */
    private static ValidatorFactory factory;
    /**
     * 对象验证器
     */
    public static Validator validator;
    /**
     * 方法验证器
     */
    public static ExecutableValidator executableValidator;

    static {
        initValidator();
        clean();
    }

    /**
     * @Author Gangbb
     * @Description 初始化ValidatorFactory和Validator
     * @Date 2021/9/21
     **/
    public static void initValidator() {
        factory = Validation.byProvider(HibernateValidator.class)
                .configure()
                .failFast(true)
                .buildValidatorFactory();
        validator = factory.getValidator();
    }

    /**
     * @Author Gangbb
     * @Description 初始化ValidatorFactory和ExecutableValidator
     * @Date 2021/9/21
     **/
    public static void initExecutableValidator() {
        factory = Validation.buildDefaultValidatorFactory();
        executableValidator = factory.getValidator().forExecutables();
    }

    /**
     * @Author Gangbb
     * @Description 关闭ValidatorFactory工厂
     * @Date 2021/9/21
     **/
    public static void clean() {
        factory.close();
    }

    /**
     * @Author Gangbb
     * @Description 对类中的某方法参数校验
     * @Date 2021/9/21
     **/
    public static<T> Set<ConstraintViolation<T>> validMethod(T t, Method method, Object[] parameterValues){
        return executableValidator.validateParameters(t, method, parameterValues);
    }

    /**
     * 校验对象
     *
     * @Param [object：待检验对象, groups：对象分组]
     * @return void
     * @Author Gangbb
     * @Date 2021/10/25
     **/
    public static void validateObject(Object object, Class<?>... groups) {
        Set<ConstraintViolation<Object>> constraintViolations = validator.validate(object, groups);
        if(CollectionUtil.isNotEmpty(constraintViolations)){
            String errorMsg = StrUtil.format("对象{}校验异常：{}", object.getClass().getSimpleName(), getErrorMsg(constraintViolations));
            throw new ApiException(ResultEnum.PARAMETER_VERIFICATION_FAIL.getCode(), errorMsg);
        }

    }

    /**
     * 校验对象列表
     *
     * @param objectList 待校验对象列表
     * @param groups 校验分组
     * @date 2022/1/8
     **/
    public static void validateObjectList(List<Object> objectList, Class<?>... groups) {
        for (Object o : objectList) {
            validateObject(o, groups);
        }
    }

    /**
     * 校验填入值是否合法
     * 目前用于：DictValidator、EnumValidator
     *
     * @param allowedValues 允许填入值数组(在codeValues再)
     * @param notAllowedValues 不允许填入值数组
     * @param value 当前填入值须校验的值
     * @return String
     * @author Gangbb
     * @date 2022/01/29
     **/
    public static String validateValues(String[]  allowedValues, String[] notAllowedValues, Object value) {
        // notAllowedValues存在情况
        if (notAllowedValues != null && notAllowedValues.length > 0) {
            List<String> notAllowedList = Arrays.asList(notAllowedValues);
            if (notAllowedList.contains(String.valueOf(value))) {
                return StrUtil.format("不能填写以下值{}", notAllowedList);
            }
        }

        // allowedValues存在情况
        if (allowedValues != null && allowedValues.length > 0) {
            List<String> allowedList = Arrays.asList(allowedValues);
            if (!allowedList.contains(String.valueOf(value))) {
                return StrUtil.format("可填值只能为{}", Arrays.toString(allowedValues));
            }
        }
        return "";
    }

    /**
     * 校验填入值是否合法
     * 目前用于：DictValidator、EnumValidator
     *
     * @param allowedValues 允许填入值数组(在codeValues再)
     * @param notAllowedValues 不允许填入值数组
     * @param value 当前填入值须校验的值
     * @param codeValues 默认可填值
     * @return String
     * @author Gangbb
     * @date 2021/11/18
     **/
    public static String validateValues(String[]  allowedValues, String[] notAllowedValues,
                                        Object value, List<Object> codeValues) {
        // notAllowedValues存在情况
        if(notAllowedValues != null && notAllowedValues.length > 0){
            List<String> notAllowedList = Arrays.asList(notAllowedValues);
            codeValues.removeAll(notAllowedList);
            if(notAllowedList.contains(String.valueOf(value))){
                return StrUtil.format("不能填写以下值{}", notAllowedList);
            }
        }

        // allowedValues存在情况
        if(allowedValues != null && allowedValues.length > 0){
            List<String> allowedList = Arrays.asList(allowedValues);
            // 将codeValues统一转成String
            List<String> stringCodeValues = codeValues.stream().map(String::valueOf).collect(Collectors.toList());
            if(!stringCodeValues.containsAll(allowedList)){
                // @VerifyEnum填入allowedValues存在非枚举code值
                throw new RuntimeException("填入allowedValues存在非允许值");
            }else{
                if(allowedList.contains(String.valueOf(value))){
                    return "";
                }else{
                    return StrUtil.format("可填值只能为{}", Arrays.toString(allowedValues));
                }
            }
        }

        // 校验字段值是否是字典允许数据
        if(codeValues.contains(value)){
            return "";
        }else{
            // 重置错误提示
            return StrUtil.format("可填值只能为{}", codeValues);
        }
    }

    /**
     * 获取校验错误消息
     * @param c
     * @return
     */
    public static String getErrorMsg(Set<ConstraintViolation<Object>> c){
        StringBuffer msg = new StringBuffer();
        if (CollectionUtil.isNotEmpty(c)){
            for (ConstraintViolation<Object> constraintViolation : c) {
                String itemMessage = constraintViolation.getMessage();
                String itemName = constraintViolation.getPropertyPath().toString();
                msg.append("字段<").append(itemName).append(">--").append(itemMessage).append("。");
            }
        }
        return msg.toString();
    }

    /**
     * 拼装单个对象校验信息
     *
     * @Param [s, c]
     * @return void
     * @Author Gangbb
     * @Date 2021/10/25
     **/
    public static void getOneInfo(StringBuffer s, Set<ConstraintViolation<Object>> c){
        if (CollectionUtil.isNotEmpty(c)){
            s.append("{ ");
            for (ConstraintViolation<Object> constraintViolation : c) {
                String itemMessage = constraintViolation.getMessage();
                String itemName = constraintViolation.getPropertyPath().toString();
                s.append("字段<" + itemName + "> :" + itemMessage + "。");
            }
            s.append(" }");
        }
    }

    /**
     * 拼装多个对象校验信息
     *
     * @Param [s, collect]
     * @return void
     * @Author Gangbb
     * @Date 2021/10/25
     **/
    public static void getListInfo(StringBuffer s, List<Set<ConstraintViolation<Object>>> collect){
        for (int i = 0; i < collect.size(); i++) {
            Set<ConstraintViolation<Object>> constraintViolations = collect.get(i);
            if (CollectionUtil.isNotEmpty(constraintViolations)){
                s.append("[ " + "列表第["+ i + "]项校验不通过:");
                getOneInfo(s, constraintViolations);
                s.append(" ]");
            }
        }
    }

    /**
     * 注解校验,获取处理校验结果
     *
     * @param errorMsg 错误信息
     * @param context 校验上下文
     * @return boolean
     * @author Gangbb
     * @date 2021/10/29
     **/
    public static boolean getResult(String errorMsg, ConstraintValidatorContext context){
        if(StrUtil.isNotBlank(errorMsg)){
            // 重置错误提示
            context.disableDefaultConstraintViolation();
            context.buildConstraintViolationWithTemplate(errorMsg)
                    .addConstraintViolation();
            return false;
        }
        return true;
    }
}

2.2.4 校验处理逻辑

/**
 *  注解@VerifyEnum 处理逻辑方法
 *
 * @author Gangbb
 * @date 2022/1/29
 **/
public class EnumValidator implements ConstraintValidator<VerifyEnum, Object> {

    private Class<? extends Enum<?>> enumClass;

    private String[]  allowedValues;

    private String[]  notAllowedValues;

    private String keyColumn;


    @Override
    public void initialize(VerifyEnum constraintAnnotation) {
        enumClass = constraintAnnotation.enumClass();
        allowedValues = constraintAnnotation.allowedValues();
        notAllowedValues = constraintAnnotation.notAllowedValues();
        keyColumn = constraintAnnotation.keyColumn();
    }

    @Override
    public boolean isValid(Object value, ConstraintValidatorContext context) {
        if(value != null){
            // 校验enumClass中是否存在keyColumn字段
            if(!ReflectUtil.hasField(enumClass, keyColumn)){
                throw new RuntimeException(StrUtil.format("EnumValidator：<{}>中不存在填入的<{}>字段", enumClass.getSimpleName(), keyColumn));
            }
            // 获取所有该枚举的指定字段的值列表
            List<Object> codeValues = EnumUtil.getFieldValues(enumClass, keyColumn);

            String validateValueMsg = ValidatorUtils.validateValues(allowedValues, notAllowedValues, value, codeValues);
            if(StrUtil.isNotBlank(validateValueMsg)){
                return ValidatorUtils.getResult(validateValueMsg, context);
            }else{
                return true;
            }
        }
        return true;
    }
}

3. 使用示例

枚举类

/**
 * 组织架构类别枚举
 *
 * @author Gangbb
 * @date 2022/1/4
 **/
public enum SysDeptTypeEnum {
    SCHOOL(1, "学校"),
    INVALID(2, "单位/学院"),
    DEPARTMENT(3, "部门"),
    MAJOR(4, "专业"),

    ;
    private final int code;
    private final String name;

    SysDeptTypeEnum(int code, String info) {
        this.code = code;
        this.name = info;
    }

    public static String getValue(int code) {
        SysDeptTypeEnum[] enums = values();
        for (SysDeptTypeEnum item : enums) {
            if (item.code == code) {
                return item.getName();
            }
        }
        return null;
    }

    public int getCode() {
        return code;
    }

    public String getName() {
        return name;
    }
}

DTO请求参数实体类

@Data
public class SysDeptDto {


    /**
     * 组织架构d
     */
    @NotNull(message = "组织架构Id不能为空", groups = { EditGroup.class })
    private Long deptId;
    /**
     * 组织架构类别(字典类别：sys_dept_type)
     */
    @NotNull(message = "组织架构类别不能为空", groups = { AddGroup.class, EditGroup.class })
    @VerifyEnum(enumClass = SysDeptTypeEnum.class, keyColumn = "code", groups = { AddGroup.class, EditGroup.class })
    private Integer type;
	
	// 其他属性省略...
}

Controller接口

/**
     * 新增组织架构
     *
     * @param dto 组织架构新增/修改 请求参数Dto
     * @return ApiResult<Void>
     * @date 2022-01-05
     **/
    @PostMapping()
    public ApiResult<Void> add(@Validated(AddGroup.class) @RequestBody SysDeptDto dto){
        return toApiRes(sysDeptService.insertByDto(dto));
    }

请求测试
在这里插入图片描述
稍微修改下注解代码

@VerifyEnum(enumClass = SysDeptTypeEnum.class, keyColumn = "code", notAllowedValues = {"5"}, groups = { AddGroup.class, EditGroup.class })

测试：
在这里插入图片描述

Gangbb
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot系列之自定义枚举类的数据校验注解
Nicky's blog
12-16 2460
SpringBoot系列自定义枚举类的数据校验注解。数据校验，需要对枚举类型的数据传参，进行数据校验，不能随便传参。拓展，支持多个参数的枚举数据校验
springboot validator枚举值校验功能实现
08-25
主要介绍了springboot validator枚举值校验功能实现,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot - 自定义注解@Enum、@EnumValue校验前端参数是否为允许传入的值
你今天真好看呀
01-15 3761
文章目录1. 应用场景2. 回顾注解校验的使用3. 自定义注解校验整型枚举值4. 自定义注解校验各种类型枚举值4.1 使用示例14.2 使用示例24.3 使用示例34.4 实现自定义注解 1. 应用场景 在实际工作的项目中，我们经常会遇到参数校验的问题，比如status字段我们只允许前端传给我们0,1,2这三种值，又比如timeUnit字段我们只允许前端传给我们m,h,d这三种值，这种场景经常遇到，平时做项目可能对参数校验没有太多要求，但是在实际的工作过程中，参数校验是非常重要的。我们今天想要讲的是如何对参
SpringBoot自定义枚举类型参数校验
最新发布
qq_35615632的博客
05-14 866
String message() default "参数有误";Class<?Class<?Class<?try {if (!!throw new RuntimeException("校验方法不是布尔类型!");if (!throw new RuntimeException("校验方法不是静态方法!");return res!= null?
SpringBoot项目通过自定义注解+枚举实现入参字段分组校验
lunatic__的博客
10-23 1342
自定义注解 校验器扩展
SpringBoot自定义注解验证枚举
weixin_42712731的博客
01-28 642
业务场景：数据校验，需要对枚举类型的数据传参，进行数据校验，不能随便传参。
java 枚举值校验_【springboot】validator枚举值校验
weixin_34883093的博客
02-16 1157
转自：https://blog.csdn.net/aiyaya_/article/details/78588200一、前言在spring项目中，校验参数功能使用hibernate validator是一个不错的选择，我们的项目中也是使用它来进行校验的，省去了很多难看的校验逻辑，使代码的可读性也大大增加，本章将带你使用hibernate validator自定义注解功能实现一个 枚举值校验的逻辑。二...
Springboot 自定义校验代码实例
08-25
首先，自定义校验注解`StartWithValidation`是整个过程的核心。这个注解使用了`@Constraint`，表明它是一个约束注解，并且通过`validatedBy`属性指定了验证器`StartWithValidator`。`@Target`和`@Retention`分别定义...
自定义校验注解框架(validator)
04-18
综上所述，自定义校验注解框架"monkey-validator"可能包括了上述步骤的实现，提供了方便快捷的方式来创建和管理项目特定的参数校验规则。通过学习和使用这个框架，开发者可以更好地理解Java的注解机制以及如何构建...
springboot下自定义注解校验数据权限
05-22
以上就是使用Spring Boot自定义注解进行数据权限校验的基本步骤。通过这种方式，我们可以将权限逻辑从业务代码中分离出来，使得代码更加模块化和易于维护。在实际应用中，还可以根据项目需求进一步扩展和完善权限...
SpringBoot 枚举类型转换
07-09
在SpringBoot 项目中实现枚举转换，需要创建BaseEnumTypeHandler 类继承BaseEnum 和 BaseTypeHandler 等相关类。想要详细了解如何实现枚举转换的话，那你快点下载后深入理解吧！
springboot通过自定义注解完成简单的权限认证.zip
10-11
springboot自定义注解的demo;通过本案例实现了通过自定义注解的拦截的方法可以设置访问权限;通过拦截器获取指定方法上的自定义的注解,然后判断当前的接口需不要权限校验;然后通过对应的访问去处理;demo里面的代码...
SpringBoot——校验参数是否包含在枚举属性值中
Andya_net的博客
03-08 822
在一些枚举类调用中，我们需要对一些枚举的属性值做包含关系的判断，看是否匹配。通过反射机制获取对应方法，再获取对应的枚举属性值。下面是示例实现。
SpringBoot自定义Validated枚举校验器
weixin_44953227的博客
12-09 4318
前言：枚举校验器主要为了规范和统一使用固定的字符或者数字值 SpringBoot 版本 2.xx 依赖，一般使用添加了 spring-boot-starter-web 这个依赖就行了，他里面包含了数据校验的依赖，但还是在这里指明一下具体的依赖。 <!--数据校验--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-.
springBoot的注解
guyanqing0207的博客
01-14 343
@SpringBootApplication:用这个注解修饰的类是SpringBoot的启动类 它里面包含了 1.@Target:是元注解 作用:用来修饰注解的作用范围 此注解中有一个枚举类ElementType的数组变量value 说明这注解的作用范围可以定义在一个数组. 其中ElementType这个类中包含了一些属性元素: 1).TYPE:类/接口/枚举 2).FIELD:域 3).METHOD:方法 4).PARAMETER:参数 5).CONSTRUCTOR:构造器 6).LOCAL_VARIAB
Spring/SpringBoot常用注解总结！
leeta的博客
08-02 897
1. @SpringBootApplication 这里先单独拎出@SpringBootApplication 注解说一下，虽然我们一般不会主动去使用它。 注：这个注解是 Spring Boot 项目的基石，创建 SpringBoot 项目之后会默认在主类加上。 我们可以把 @SpringBootApplication看作是 @Configuration、@EnableAutoConfiguration、@ComponentScan 注解的集合。 根据 SpringBoot 官网
SpringMVC自定义注解进行参数校验（以校验枚举值是否合法为例）
虾米记的博客
12-06 4234
pom引入springMVC依赖，以springboot项目为例 &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.springframework.boot&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;spring-boot-starter-web&amp;lt;/artifactId&amp
springboot 自定义validation参数校验注解 校验枚举值
Wu_Shang001的博客
09-02 4130
在写springboot项目的时候，经常需要对参数进行校验。如果是一个参数还好，写一个if-else就好了。但如果传入的参数是一个对象，那就需要写很多if-else了，而且这个对象可能在很多地方作为参数使用。 validation 介绍 这个时候就可以考虑使用参数校验注解了，首先是引入依赖。 <dependency> <groupId>javax.validation</groupId> <artifactId>validation-api</
springboot项目校验枚举值
06-03
在Spring Boot项目中，我们可以使用Java Bean Validation（JSR 303）规范中的注解来校验枚举值。比如，我们可以使用@EnumValidator注解来校验枚举值。 首先，我们需要在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.hibernate.validator</groupId> <artifactId>hibernate-validator</artifactId> <version>6.2.0.Final</version> </dependency> ``` 接下来，我们可以在实体类中使用@EnumValidator注解来校验枚举值。比如，以下是一个使用@EnumValidator注解校验枚举值的示例代码： ```java public enum Gender { MALE, FEMALE } public class User { @NotNull private String name; @EnumValidator(enumClass = Gender.class, message = "gender must be MALE or FEMALE") private Gender gender; // getters and setters } ``` 在上述代码中，@EnumValidator注解用于校验gender属性是否为Gender枚举中的值。如果不是，会抛出校验异常并提示"gender must be MALE or FEMALE"。 最后，我们需要在Controller中使用@Valid注解来触发参数校验。比如，以下是一个使用@Valid注解触发参数校验的示例代码： ```java @RestController @RequestMapping("/users") public class UserController { @PostMapping public ResponseEntity<String> createUser(@Valid @RequestBody User user) { // do something return ResponseEntity.ok("User created successfully"); } } ``` 在上述代码中，@Valid注解用于触发参数校验。如果校验失败，会抛出异常并返回相应的错误信息。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值