服务器之家：专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - 基于自定义校验注解(controller、method、(groups)分组的使用)

基于自定义校验注解(controller、method、(groups)分组的使用)

2022-02-23 13:16子书少卿 Java教程

这篇文章主要介绍了基于自定义校验注解(controller、method、(groups)分组的使用)，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

1、首先创建两个自定义校验注解类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package com.example.demo.annotation;
import com.example.demo.interface2.CreateAction;
import javax.validation.Constraint;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import javax.validation.Payload;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
/**
 * 自定义校验注解
 */
@Constraint(validatedBy = {Name.NameUtil.class})
@Documented
@Retention(RUNTIME)
@Target({ElementType.ANNOTATION_TYPE, METHOD, ElementType.FIELD})
public @interface Name {
 
//     真坑,以下三个参数的名称必须为这三个，不能为其他
    String message() default "姓名必须为小黑";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    @Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER})
    @Retention(RUNTIME)
    @Documented
    @interface List{
        Name [] value();
    }
 
    class NameUtil implements ConstraintValidator<Name,String>, CreateAction {
 
        @Override
        public void initialize(Name constraintAnnotation) {
//        TODO 可以用以初始化数据
        }
 
        @Override
        public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) {
            if("小黑".equals(s)){
                return true;
            }else{
                return false;
            }
        }
    }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package com.example.demo.annotation;
import javax.validation.Constraint;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import javax.validation.Payload;
import java.lang.annotation.*;
 
/**
 * 自定义校验注解
 */
@Constraint(validatedBy = {Sex.SexUtil.class})
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
public @interface Sex {
 
    //     真坑,以下三个参数的名称必须为这三个，不能为其他
    String message() default "性别必须为女";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    class SexUtil implements ConstraintValidator<Sex, Object> {
 
        @Override
        public void initialize(Sex constraintAnnotation) {
//        TODO 可以用以初始化数据
        }
 
        @Override
        public boolean isValid(Object s, ConstraintValidatorContext constraintValidatorContext) {
 
//            System.out.println(s.toString());
//            System.out.println(s.getClass().getName());
            if("女".equals(s)){
                return true;
            }else{
                return false;
            }
        }
    }
}

实体bean

注意

@Valid在复杂类型上使用

如果bean该类包含具有其他复杂类型的字段，该字段应进行验证，则该字段也需要使用注释@Valid，复杂类型（对象）中的字段也需要注释@Valid

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.example.demo.entity;
import com.example.demo.annotation.Name;
import com.example.demo.annotation.Sex;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
 
@Data
@NoArgsConstructor
@AllArgsConstructor
@Sex(message = "性别必须为女2")
public class E {
    private int id;
    @Name(message = "姓名必须为小黑2")
    @NotNull
    private String name;
    private String age;
    @NotNull
    private String sex;
}

2、校验注解的使用

（spring、validation下的可以用触发器；hibernate下的抛出异常）

1>、controller中的使用

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RequestMapping(value = "/pAnnotation",method = RequestMethod.GET,produces = "application/json;charset=UTF-8")
 @ApiOperation(value = "测试自定义校验注解controller层")
 public void pAnnotation(@Valid E e ,BindingResult bindingResult){
     p1.pAnnotation(e,bindingResult);
 }
public void pAnnotation(E e , BindingResult bindingResult) {
     if (bindingResult.hasErrors()){
         bindingResult.getAllErrors().forEach(s-> {
             System.out.println(s.getDefaultMessage());
         });
     }else{
         System.out.println("没有报错");
     }
 }

2>、方法中触发注解

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package com.example.demo.util;
import com.example.demo.interface2.CreateAction;
import com.example.demo.interface2.UpdateAction;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.annotation.Validated;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import java.util.Set;
@Component
public class AnnotationCheck<T> {
 
    ----------------------------写法一 start------------------------------
//    private static Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
//
//    public void checkAnnotation(T t){
//
//            //执行验证
//            Set<ConstraintViolation<T>> constraintViolations = validator.validate(t);
//            //打印校验信息
//            if (!CollectionUtils.isEmpty(constraintViolations)) {
//                for (ConstraintViolation<T> constraintViolation : constraintViolations) {
//                    System.out.println(constraintViolation.getPropertyPath().toString() + ": " + constraintViolation.getMessage());
//                }
//            }
//    }
    ----------------------------写法一 end------------------------------
//    ----------------------------写法二 start------------------------------
//    当Spring实例化此服务时，它将自动将一个Validator实例注入构造函数。
//    此种写法更优秀
    private Validator validator;
 
    AnnotationCheck(Validator validator) {
        this.validator = validator;
    }
    public void checkAnnotation(T t){
 
            //执行验证
            Set<ConstraintViolation<T>> constraintViolations = validator.validate(t);
            //打印校验信息
            if (!CollectionUtils.isEmpty(constraintViolations)) {
                for (ConstraintViolation<T> constraintViolation : constraintViolations) {
                    System.out.println(constraintViolation.getPropertyPath().toString() + ": " + constraintViolation.getMessage());
                }
            }
    }
 
//    ----------------------------写法二 end------------------------------
}

调用：

?
1
annotationCheck.checkAnnotation(e);

3>、分组groups的使用

定义两个空接口，分别代表E对象的增加校验规则和修改校验规则

?
1
2
3
4
5
6
7
8
9
10
/**
 * 可以在一个Model上面添加多套参数验证规则，此接口定义添加Person模型新增时的参数校验规则
 */
public interface CreateAction {
}
/**
 * 可以在一个Model上面添加多套参数验证规则，此接口定义添加Person模型修改时的参数校验规则
 */
public interface UpdateAction {
}

修改实体中的注解

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.example.demo.entity;
import com.example.demo.annotation.Name;
import com.example.demo.annotation.Sex;
import com.example.demo.interface2.CreateAction;
import com.example.demo.interface2.UpdateAction;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
 
@Data
@NoArgsConstructor
@AllArgsConstructor
@Sex(message = "性别必须为女2")
public class E {
    private int id;
    @Name.List({
            @Name(groups = CreateAction.class ,message = "创建时姓名必须为小黑2"),
            @Name(groups = UpdateAction.class ,message = "修改时姓名必须为小黑2")
    })
    @NotNull
    private String name;
    private String age;
    @NotNull
    private String sex;
}

使用：此时只会对标注了‘CreateAction.classd的注解生效，

1、controller

?
1
2
3
4
5
6
7
8
9
10
11
@RequestMapping(value = "/pAnnotation3",method = RequestMethod.GET,produces = "application/json;charset=UTF-8")
   @ApiOperation(value = "测试自定义校验注解-groups分组")
   public void pAnnotation3( @Validated({CreateAction.class}) E e,BindingResult bindingResult){
       if (bindingResult.hasErrors()){
           bindingResult.getAllErrors().forEach(s-> {
               System.out.println(s.getDefaultMessage());
           });
       }else{
           System.out.println("没有报错");
       }
   }

结果

创建时姓名必须为小黑2

2、method

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  @RequestMapping(value = "/pAnnotation5",method = RequestMethod.GET,produces = "application/json;charset=UTF-8")
    @ApiOperation(value = "测试自定义校验注解-groups分组-方法")
    public String pAnnotation5( E e){
        return p1.pAnnotation3(e);
    }
 
    public String pAnnotation3(E e) {
//        try {
            beanGroupService.validateInCreate(e);
//            annotationCheck.checkAnnotation(e);
//        }catch (Exception ee){
//            System.out.println(ee.toString());
//        }
        return "qqqq";
//        annotationCheck.checkAnnotation(e);
    }
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.example.demo.service;
import com.example.demo.annotation.Name;
import com.example.demo.entity.E;
import com.example.demo.interface2.CreateAction;
import com.example.demo.interface2.UpdateAction;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import javax.validation.Valid;
 
@Validated
@Service
@Slf4j
public class BeanGroupService {
    @Validated(CreateAction.class)
    public String validateInCreate(@Valid E beanGroup) {
// 没有错误时的操作 TODO
        log.info("validateInCreate:{}", beanGroup);
        return "25347sfef";
    }
 
    @Validated(UpdateAction.class)
    public void validateInUpdate(@Valid E beanGroup) {
        log.info("validateInUpdate:{}", beanGroup);
    }
}

结果，异常抛出获取

创建时姓名必须为小黑2

单个注解用在方法上（@Validated--以异常形式抛出）

---在业务上不太建议使用

1、实例化MethodValidationPostProcessor

?
1
2
3
4
@Bean
    public MethodValidationPostProcessor methodValidationPostProcessor() {
        return new MethodValidationPostProcessor();
    }

2、在所要实现方法参数校验的类上面添加@Validated

如下---不需要的时候记得去掉，会影响方法上的注解

?
1
2
3
4
@RestController
@Validated
public class ValidateController {
}

3、在方法上面添加校验规则

?
1
2
3
4
5
@RequestMapping(value = "/test", method = RequestMethod.GET)
  public String paramCheck(@Length(min = 10) @RequestParam String name) {
      System.out.println(name);
      return null;
  }

当（不管是controller层还是service层的）方法上面的参数校验失败,spring 框架就回抛出异常，可以使用统一异常处理来处理（ExceptionResolver）---各个框架抛出的异常不一致

?
1
2
3
4
5
6
7
{
  "timestamp": "2020-05-07T11:51:00.141+0000",
  "status": 500,
  "error": "Internal Server Error",
  "message": "An Errors/BindingResult argument is expected to be declared immediately after the model attribute, the @RequestBody or the @RequestPart arguments to which they apply: public void com.example.demo.controller.PracticeController.pAnnotation4(java.lang.String,org.springframework.validation.BindingResult)",
  "path": "/practice/pAnnotation4"
}

自定义注解是BindException错误，其他组件的注解是ConstraintViolationException

注意，我们必须@Validated在类级别将Spring的注释添加到控制器，以告诉Spring评估方法参数上的约束注释。

该@Validated注解只计算在这种情况下，一流的水平，即使它允许在使用方法（我们将了解它为什么在方法层面讨论时允许确认团组更高版本）。

与请求正文验证相反，验证失败将触发ConstraintViolationException 而不是MethodArgumentNotValidException。Spring没有为此异常注册默认的异常处理程序，因此默认情况下它将导致HTTP状态为500（内部服务器错误）的响应。

如果我们想返回一个HTTP状态400（这很有意义，因为客户端提供了一个无效的参数，这使它成为一个错误的请求），我们可以向contoller中添加一个自定义的异常处理程序：来统一处理特定异常

可以用作统一处理注解信息的统一方式

?
1
2
3
4
5
6
7
8
9
10
@RestController
@Validated
class ValidateParametersController {
  // request mapping method omitted 
  @ExceptionHandler(ConstraintViolationException.class)
  @ResponseStatus(HttpStatus.BAD_REQUEST)
  ResponseEntity<String> handleConstraintViolationException(ConstraintViolationException e) {
    return new ResponseEntity<>("not valid due to validation error: " + e.getMessage(), HttpStatus.BAD_REQUEST);
  }
}

其他的一些注解

?
1
2
3
4
5
6
7
8
9
10
11
12
<!--jsr 303-->
  <dependency>
   <groupId>javax.validation</groupId>
   <artifactId>validation-api</artifactId>
   <version>1.1.0.Final</version>
  </dependency>
  <!-- hibernate validator-->
  <dependency>
   <groupId>org.hibernate</groupId>
   <artifactId>hibernate-validator</artifactId>
   <version>5.2.0.Final</version>
  </dependency>

JSR提供的校验注解：

  • @Null：被注释的元素必须为 null
  • @NotNull：被注释的元素必须不为 null
  • @AssertTrue：被注释的元素必须为 true
  • @AssertFalse：被注释的元素必须为 false
  • @Min(value)：被注释的元素必须是一个数字，其值必须大于等于指定的最小值
  • @Max(value)：被注释的元素必须是一个数字，其值必须小于等于指定的最大值
  • @DecimalMin(value)：被注释的元素必须是一个数字，其值必须大于等于指定的最小值
  • @DecimalMax(value)：被注释的元素必须是一个数字，其值必须小于等于指定的最大值
  • @Size(max=, min=)：被注释的元素的大小必须在指定的范围内
  • @Digits (integer, fraction)：被注释的元素必须是一个数字，其值必须在可接受的范围内
  • @Past：被注释的元素必须是一个过去的日期
  • @Future：被注释的元素必须是一个将来的日期
  • @Pattern(regex=,flag=)：被注释的元素必须符合指定的正则表达式

Hibernate Validator提供的校验注解：

  • @NotBlank(message =)：验证字符串非null，且trim后长度必须大于0
  • @Email：被注释的元素必须是电子邮箱地址
  • @Length(min=,max=)：被注释的字符串的大小必须在指定的范围内
  • @NotEmpty：被注释的字符串的必须非空
  • @Range(min=,max=,message=)：被注释的元素必须在合适的范围内

以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。

原文链接：https://shaoqing.blog.csdn.net/article/details/105975862

  • controller
  • Method
  • Groups
  • 校验注解

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    501 　 406 　 415 　 2000 　 1433 　 401 　 330 　 htmlparser 　 选择排序法 　 随机抽取 　 内存卡 　 下载器 　 十六进制字符 　 响应 　 静态工厂 　 构造函数 　 swt 　 Overview 　 对象池模式 　 子线程 　 支票 　 金额大写转换 　 空心菱形 　 AspectJ 　 面向切面编程 　 方法名 　 网址信息 　 动态代理模式 　 线程安全 　 校验注解 　
    © 2019-2022 服务器之家(www.zzvips.com) 版权所有关于我们联系我们版权申明网站地图