springboot中参数校验（validation）注解自定义

缺乏、安全感 2022-03-19 11:17 578阅读 0赞

在进行参数验证的时候，往往存在现有的约束注解不能满足的情况，此时就需要我们自己定义validation注解了，下面来介绍一下如何自己定义一个验证注解。

有关参数校验的使用可详见《springboot中参数校验（validation）使用》

如何自定义一个validation注解？

自己定义validation注解需要使用@Constraint。@Constraint注解中是这样进行描述的：

  1. * Marks an annotation as being a Bean Validation constraint.
  2.  * <p/>
  3.  * A given constraint annotation must be annotated by a { @code @Constraint}
  4.  * annotation which refers to its list of constraint validation implementations.
  5.  * <p/>
  6.  * Each constraint annotation must host the following attributes:
  7.  * <ul>
  8.  *     <li>{ @code String message() default [...];} which should default to an error
  9.  *     message key made of the fully-qualified class name of the constraint followed by
  10.  *     { @code .message}. For example { @code "{com.acme.constraints.NotSafe.message}"}</li>
  11.  *     <li>{ @code Class<?>[] groups() default { };} for user to customize the targeted
  12.  *     groups</li>
  13.  *     <li>{ @code Class<? extends Payload>[] payload() default { };} for
  14.  *     extensibility purposes</li>
  15.  * </ul>
  16.  * <p/>

可以看出，@Constraint用其来标注我们的注解是一个验证注解（Validation constraint），同时还指明了我们在自己定义验证注解的时候不可缺少的三个注解元素：

  1. String message() default [...];
  2. Class<?>[] groups() default { };
  3. Class<? extends Payload>[] payload() default { };

自定义validation注解的时候，不仅要写出一个满足我们要求的注解，好需要搭配一个验证实现(validator)，实现如下接口：

  1. javax.validation.ConstraintValidator

自定义validation注解案例

枚举验证注解@Enum

validation-api的注解和hibernate的扩展中没有对枚举值验证的注解，而在有些时候枚举值验证又是需要的，下面我们来自己定义这样一个validation注解，代码如下：

  1. package com.lazycece.sbac.validation.constraint;
  3. import com.lazycece.sbac.validation.constraint.validator.EnumValidator;
  5. import javax.validation.Constraint;
  6. import javax.validation.Payload;
  7. import java.lang.annotation.Documented;
  8. import java.lang.annotation.Repeatable;
  9. import java.lang.annotation.Retention;
  10. import java.lang.annotation.Target;
  12. import static java.lang.annotation.ElementType.*;
  13. import static java.lang.annotation.ElementType.PARAMETER;
  14. import static java.lang.annotation.ElementType.TYPE_USE;
  15. import static java.lang.annotation.RetentionPolicy.RUNTIME;
  17. /** * @author lazycece * @date 2019/2/15 */
  18. @Documented
  19. @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
  20. @Retention(RUNTIME)
  21. @Repeatable(Enum.List.class)
  22. @Constraint(validatedBy = { EnumValidator.class})
  23. public @interface Enum { 
  25.     String message() default "{*.validation.constraint.Enum.message}";
  27.     Class<?>[] groups() default { };
  29.     Class<? extends Payload>[] payload() default { };
  31.     /** * the enum's class-type * * @return Class */
  32.     Class<?> clazz();
  34.     /** * the method's name ,which used to validate the enum's value * * @return method's name */
  35.     String method() default "ordinal";
  37.     /** * Defines several {@link Enum} annotations on the same element. * * @see Enum */
  38.     @Documented
  39.     @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
  40.     @Retention(RUNTIME)
  41.     @interface List { 
  42.         Enum[] value();
  43.     }
  44. }

枚举验证注解validator

注解验证逻辑的validator代码如下，通过反射方式获取枚举的值进行判断。

  1. package com.lazycece.sbac.validation.constraint.validator;
  3. import com.lazycece.sbac.validation.constraint.Enum;
  5. import javax.validation.ConstraintValidator;
  6. import javax.validation.ConstraintValidatorContext;
  7. import java.lang.reflect.Method;
  9. /** * @author lazycece * @date 2019/2/15 */
  10. public class EnumValidator implements ConstraintValidator<Enum, Object> { 
  12.     private Enum annotation;
  14.     @Override
  15.     public void initialize(Enum constraintAnnotation) { 
  16.         this.annotation = constraintAnnotation;
  17.     }
  19.     @Override
  20.     public boolean isValid(Object value, ConstraintValidatorContext context) { 
  21.         if (value == null) { 
  22.             return false;
  23.         }
  25.         Object[] objects = annotation.clazz().getEnumConstants();
  26.         try { 
  27.             Method method = annotation.clazz().getMethod(annotation.method());
  28.             for (Object o : objects) { 
  29.                 if (value.equals(method.invoke(o))) { 
  30.                     return true;
  31.                 }
  32.             }
  33.         } catch (Exception e) { 
  34.             throw new RuntimeException(e);
  35.         }
  36.         return false;
  37.     }
  38. }

使用方式

@Enum注解的使用需要给出枚举类和获取需要验证的枚举值的方法（默认情况下是ordinal）。

如果我们定义的枚举类如下所示，那么在验证的时候会设计到四种方式的验证：

  1. package com.lazycece.sbac.validation.enums;
  3. /** * @author lazycece * @date 2019/02/15 */
  4. public enum Role { 
  6.     ADMIN(1, "ADMIN"),
  7.     TEST(2, "TEST"),
  8.     DEVELOP(3, "DEVELOP");
  10.     private int value;
  11.     private String desc;
  13.     Role(int value, String desc) { 
  14.         this.value = value;
  15.         this.desc = desc;
  16.     }
  18.     public int getValue() { 
  19.         return value;
  20.     }
  22.     public void setValue(int value) { 
  23.         this.value = value;
  24.     }
  26.     public String getDesc() { 
  27.         return desc;
  28.     }
  30.     public void setDesc(String desc) { 
  31.         this.desc = desc;
  32.     }
  33. }

  • 参数param为枚举的ordinal值

    1. @Enum(clazz = Role.class, message = "role参数错误")

  • 参数param为枚举的name值

    1. @Enum(clazz = Role.class, method = "name", message = "role参数错误")

  • 参数param为枚举的value值

    1. @Enum(clazz = Role.class, method = "getValue", message = "role参数错误")

  • 参数param为枚举的desc值

    1. @Enum(clazz = Role.class, method = "getDesc", message = "role参数错误")

案例源码

案例源码地址：https://github.com/lazycece/springboot-actual-combat/tree/master/springboot-ac-validation

发表评论

表情：
评论列表 （有 0 条评论，578人围观）

还没有评论，来说两句吧...

相关阅读