自定义注解，让你的参数检验更完备

前言：配和org.springframework.validation.annotation.Validated一起进行参数验证

• 引入依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

• validated的简单使用
  • controller

  
    import com.example.demo.model.vo.UserVo;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.validation.Valid;
    
    /**
     * @program: demo
     * @author: zzg
     * @create: 2020-09-17 15:30
     */
    @Api(tags = "测试")
    @RestController
    public class TestController {
    
        @ApiOperation(value = "测试接口1")
        @PostMapping("/test")
        public Object swagger( @Validated  @RequestBody UserVo userVo){
    
            System.out.println(userVo);
            return null;
        }
    }
  
  

  • UserVo

  
  
    import com.example.demo.annotation.valid.OddValid;
    import lombok.Data;
    
    import javax.validation.Valid;
    import javax.validation.constraints.NotBlank;
    import javax.validation.constraints.NotNull;
    
    /**
     * @program: demo
     * @author: zzg
     * @create: 2020-09-17 16:46
     */
    
    @Data
    public class UserVo {
    
       //groups表示组别，@Validated({UserVo.insert.class})配合使用
        @NotBlank(message ="姓名不为空",groups = {insert.class})
        private String name;
    
    
        @NotNull(message ="年龄不能为空",groups = {insert.class})
        //自定义的注解
        // @OddValid(message = "test")
        private Integer age;
    
    
        // @Validate搭配@Valid可以检验多重
        @Valid
        private OtherVo otherVo;
    
    
    
        public interface insert{
    
        }
    }
    
    
    import io.swagger.annotations.ApiModel;
    import lombok.Data;
    import javax.validation.constraints.NotBlank;
    
    
    @ApiModel
    @Data
    public class OtherVo {
        @NotBlank(message ="姓名不为空")
        private String name1;
    
    
        private Integer age1;
    }
  
  

接下来是自定义了

• 自定义注解校验

  • 步骤：

    • 定义一个注解
    • 实现ConstraintValidator接口

  • 定义注解

  
  import javax.validation.Constraint;
  import javax.validation.Payload;
  import java.lang.annotation.ElementType;
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  import java.lang.annotation.Target;
  
  /**
  * 判断是否是奇数
  *
  * @program: demo
  * @author: zzg
  * @create: 2020-09-17 16:39
  */
  //属性使用范围（具体值看ElementType）
  @Target(ElementType.FIELD)
  // 注解生命周期，一般都是这个RetentionPolicy.RUNTIME
  @Retention(RetentionPolicy.RUNTIME)
  // 指定检验类，就是第二步骤要实现的类
  @Constraint(validatedBy = {oddValidor.class})
  public @interface OddValid {
  
     String message() default "Age Must Be Odd";
     //以下两个不动
     Class<?>[] groups() default {};
     Class<? extends Payload>[] payload() default {};
  }
  
  
  /**
  public enum ElementType {
     /** 类，接口（包括注解类型）或枚举的声明 */
     TYPE,
  
     /** 属性的声明 */
     FIELD,
  
     /** 方法的声明 */
     METHOD,
  
     /** 方法形式参数声明 */
     PARAMETER,
  
     /** 构造方法的声明 */
     CONSTRUCTOR,
  
     /** 局部变量声明 */
     LOCAL_VARIABLE,
  
     /** 注解类型声明 */
     ANNOTATION_TYPE,
  
     /** 包的声明 */
     PACKAGE
  }**/
  
  

  • 注解校验类

  
  import javax.validation.ConstraintValidator;
  import javax.validation.ConstraintValidatorContext;
  
  /**
  * @program: demo
  * @author: zzg
  * @create: 2020-09-17 17:43
  */
  public class oddValidor implements ConstraintValidator<OddValid,Integer> {
     @Override
     public void initialize(OddValid constraintAnnotation) {
  
     }
  
     @Override
     public boolean isValid(Integer integer, ConstraintValidatorContext constraintValidatorContext) {
         if(integer !=null){
             int i =integer%2;
             if(i==1){
                 return true;
             }
         }
  
         return false;
     }
  }
  
  

• 定义全局校验异常捕获

  
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.validation.BindException;
  import org.springframework.validation.FieldError;
  import org.springframework.web.bind.MethodArgumentNotValidException;
  import org.springframework.web.bind.annotation.ControllerAdvice;
  import org.springframework.web.bind.annotation.ExceptionHandler;
  import org.springframework.web.bind.annotation.ResponseBody;
  
  import javax.servlet.http.HttpServletRequest;
  import java.util.List;
  
  
  /**
   * 异常处理类
   *
   * @program: ahdx
   * @author: zzg
   * @create: 2020-07-24 13:25
   */
  
  @Slf4j
  @ControllerAdvice
  public class ValidHandle {
  
      @ExceptionHandler({BindException.class})
      @ResponseBody
     public Object except(BindException e,  HttpServletRequest request){
          System.out.println(e);
          StringBuilder mes = new StringBuilder();
          List<FieldError> fieldErrors = e.getFieldErrors();
          for (FieldError fieldError : fieldErrors) {
              mes.append(fieldError.getDefaultMessage());
              mes.append(" ; ");
          }
          //简单输出一个json
         HashMap<String, Object> map = new HashMap<>();
          map.put("code",1000);
          map.put("mes",mes);
          map.put("data",null);
          return map;
     }
  
  
      @ExceptionHandler({MethodArgumentNotValidException.class})
      @ResponseBody
      public Object except(MethodArgumentNotValidException e,  HttpServletRequest request){
          StringBuilder mes = new StringBuilder();
          List<FieldError> fieldErrors = e.getBindingResult().getFieldErrors();
          for (FieldError fieldError : fieldErrors) {
              mes.append(fieldError.getDefaultMessage());
              mes.append(" ; ");
          }
          HashMap<String, Object> map = new HashMap<>();
          map.put("code",1000);
          map.put("mes",mes);
          map.put("data",null);
          return map;
      }
  }

测试

推广