手册   游戏   WEB   字典   单词   在线工具  

如何在 Spring/Spring Boot 中做参数校验? 你需要了解的都在这里!

本文为作者原创, 如需转载请在文首著名地址, 公众号转载请申请开白.

https://github.com/Snailclimb/springboot-guide : 适合新手入门以及有经验的开发人员查阅的 Spring Boot 教程 (业余时间维护中, 欢迎一起维护).

数据的校验的重要性就不用说了, 即使在前端对数据进行校验的情况下, 我们还是要对传入后端的数据再进行一遍校验, 避免用户绕过浏览器直接通过一些 HTTP 工具直接向后端请求一些违法数据.

本文结合自己在项目中的实际使用经验, 可以说文章介绍的内容很实用, 不了解的朋友可以学习一下, 后面可以立马实践到项目上去.

下面我会通过实例程序演示如何在 Java 程序中尤其是 Spring 程序中优雅地的进行参数验证.

基础设施搭建

相关依赖

如果开发普通 Java 程序的的话, 你需要可能需要像下面这样依赖:

  1. <dependency>
  2.             <groupId>org.hibernate.validator</groupId>
  3.             <artifactId>hibernate-validator</artifactId>
  4.             <version>6.0.9.Final</version>
  5.    </dependency>
  6.    <dependency>
  7.              <groupId>javax.el</groupId>
  8.              <artifactId>javax.el-API</artifactId>
  9.              <version>3.0.0</version>
  10.      </dependency>
  11.      <dependency>
  12.             <groupId>org.glassfish.Web</groupId>
  13.             <artifactId>javax.el</artifactId>
  14.             <version>2.2.6</version>
  15.      </dependency>

使用 Spring Boot 程序的话只需要 spring-boot-starter-Web 就够了, 它的子依赖包含了我们所需要的东西. 除了这个依赖, 下面的演示还用到了 lombok , 所以不要忘记添加上相关依赖.

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-Web</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.projectlombok</groupId>
  8.             <artifactId>lombok</artifactId>
  9.             <optional>true</optional>
  10.         </dependency>
  11.         <dependency>
  12.             <groupId>org.springframework.boot</groupId>
  13.             <artifactId>spring-boot-starter-test</artifactId>
  14.             <scope>test</scope>
  15.         </dependency>
  16.     </dependencies>

实体类

下面这个是示例用到的实体类.

  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. public class Person {
  5.     @NotNull(message = "classId 不能为空")
  6.     private String classId;
  7.     @Size(max = 33)
  8.     @NotNull(message = "name 不能为空")
  9.     private String name;
  10.     @Pattern(regexp = "((^Man$|^Woman$|^UGM$))", message = "sex 值不在可选范围")
  11.     @NotNull(message = "sex 不能为空")
  12.     private String sex;
  13.     @Email(message = "email 格式不正确")
  14.     @NotNull(message = "email 不能为空")
  15.     private String email;
  16. }

正则表达式说明:

- ^string : 匹配以 string 开头的字符串

- string$ : 匹配以 string 结尾的字符串

- ^string$ : 精确匹配 string 字符串

- ((^Man$|^Woman$|^UGM$)) : 值只能在 Man,Woman,UGM 这三个值中选择

下面这部分校验注解说明内容参考自: https://www.cnkirito.moe/spring-validation/ , 感谢 @徐靖峰 https://github.com/lexburner .

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, 且长度必须大于 0

@Email 被注释的元素必须是电子邮箱地址

@Length(min=,max=) 被注释的字符串的大小必须在指定的范围内

@NotEmpty 被注释的字符串的必须非空

@Range(min=,max=,message=)

被注释的元素必须在合适的范围内

验证 Controller 的输入

验证请求体 (RequestBody)

Controller:

我们在需要验证的参数上加上了 @Valid 注解, 如果验证失败, 它将抛出 MethodArgumentNotValidException. 默认情况下, Spring 会将此异常转换为 HTTP Status 400(错误请求).

  1. @RestController
  2. @RequestMapping("/api")
  3. public class PersonController {
  4.     @PostMapping("/person")
  5.     public ResponseEntity<Person> getPerson(@RequestBody @Valid Person person) {
  6.         return ResponseEntity.ok().body(person);
  7.     }
  8. }
  9. ExceptionHandler:

自定义异常处理器可以帮助我们捕获异常, 并进行一些简单的处理. 如果对于下面的处理异常的代码不太理解的话, 可以查看这篇文章 《SpringBoot 处理异常的几种常见姿势》.

  1. @ControllerAdvice(assignableTypes = {PersonController.class})
  2. public class GlobalExceptionHandler {
  3.     @ExceptionHandler(MethodArgumentNotValidException.class)
  4.     public ResponseEntity<Map<String, String>> handleValidationExceptions(
  5.             MethodArgumentNotValidException ex) {
  6.         Map<String, String> errors = new HashMap<>();
  7.         ex.getBindingResult().getAllErrors().forEach((error) -> {
  8.             String fieldName = ((FieldError) error).getField();
  9.             String errorMessage = error.getDefaultMessage();
  10.             errors.put(fieldName, errorMessage);
  11.         });
  12.         return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errors);
  13.     }
  14. }

通过测试验证:

下面我通过 MockMvc 模拟请求 Controller 的方式来验证是否生效, 当然你也可以通过 Postman 这种工具来验证.

我们试一下所有参数输入正确的情况.

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. @AutoConfigureMockMvc
  4. public class PersonControllerTest {
  5.     @Autowired
  6.     private MockMvc mockMvc;
  7.     @Autowired
  8.     private ObjectMapper objectMapper;
  9.     @Test
  10.     public void should_get_person_correctly() throws Exception {
  11.         Person person = new Person();
  12.         person.setName("SnailClimb");
  13.         person.setSex("Man");
  14.         person.setClassId("82938390");
  15.         person.setEmail("Snailclimb@qq.com");
  16.         mockMvc.perform(post("/api/person")
  17.                 .contentType(MediaType.APPLICATION_JSON_UTF8)
  18.                 .content(objectMapper.writeValueAsString(person)))
  19.                 .andExpect(MockMvcResultMatchers.jsonPath("name").value("SnailClimb"))
  20.                 .andExpect(MockMvcResultMatchers.jsonPath("classId").value("82938390"))
  21.                 .andExpect(MockMvcResultMatchers.jsonPath("sex").value("Man"))
  22.                 .andExpect(MockMvcResultMatchers.jsonPath("email").value("Snailclimb@qq.com"));
  23.     }
  24. }

验证出现参数不合法的情况抛出异常并且可以正确被捕获.

  1. @Test
  2.     public void should_check_person_value() throws Exception {
  3.         Person person = new Person();
  4.         person.setSex("Man22");
  5.         person.setClassId("82938390");
  6.         person.setEmail("SnailClimb");
  7.         mockMvc.perform(post("/api/person")
  8.                 .contentType(MediaType.APPLICATION_JSON_UTF8)
  9.                 .content(objectMapper.writeValueAsString(person)))
  10.                 .andExpect(MockMvcResultMatchers.jsonPath("sex").value("sex 值不在可选范围"))
  11.                 .andExpect(MockMvcResultMatchers.jsonPath("name").value("name 不能为空"))
  12.                 .andExpect(MockMvcResultMatchers.jsonPath("email").value("email 格式不正确"));
  13.     }

使用 Postman 验证结果如下:

验证请求参数 (Path Variables 和 Request Parameters)

Controller:

一定一定不要忘记在类上加上 Validated 注解了, 这个参数可以告诉 Spring 去校验方法参数.

  1. @RestController
  2. @RequestMapping("/api")
  3. @Validated
  4. public class PersonController {
  5.     @GetMapping("/person/{id}")
  6.     public ResponseEntity<Integer> getPersonByID(@Valid @PathVariable("id") @Max(value = 5,message = "超过 id 的范围了") Integer id) {
  7.         return ResponseEntity.ok().body(id);
  8.     }
  9.     @PutMapping("/person")
  10.     public ResponseEntity<String> getPersonByName(@Valid @RequestParam("name") @Size(max = 6,message = "超过 name 的范围了") String name) {
  11.         return ResponseEntity.ok().body(name);
  12.     }
  13. }
  14. ExceptionHandler:
  15. @ExceptionHandler(ConstraintViolationException.class)
  16.     ResponseEntity<String> handleConstraintViolationException(ConstraintViolationException e) {
  17.         return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getMessage());
  18.     }

通过测试验证:

  1. @Test
  2.     public void should_check_param_value() throws Exception {
  3.         mockMvc.perform(get("/api/person/6")
  4.                 .contentType(MediaType.APPLICATION_JSON_UTF8))
  5.                 .andExpect(status().isBadRequest())
  6.                 .andExpect(content().string("getPersonByID.id: 超过 id 的范围了"));
  7.     }
  8.     @Test
  9.     public void should_check_param_value2() throws Exception {
  10.         mockMvc.perform(put("/api/person")
  11.                 .param("name","snailclimbsnailclimb")
  12.                 .contentType(MediaType.APPLICATION_JSON_UTF8))
  13.                 .andExpect(status().isBadRequest())
  14.                 .andExpect(content().string("getPersonByName.name: 超过 name 的范围了"));
  15.     }

验证 Service 中的方法

我们还可以验证任何 Spring 组件的输入, 而不是验证控制器级别的输入, 我们可以使用 @Validated 和 @Valid 注释的组合来实现这一需求.

一定一定不要忘记在类上加上 Validated 注解了, 这个参数可以告诉 Spring 去校验方法参数.

  1. @Service
  2. @Validated
  3. public class PersonService {
  4.     public void validatePerson(@Valid Person person){
  5.         // do something
  6.     }
  7. }

通过测试验证:

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. @AutoConfigureMockMvc
  4. public class PersonServiceTest {
  5.     @Autowired
  6.     private PersonService service;
  7.     @Test(expected = ConstraintViolationException.class)
  8.     public void should_throw_exception_when_person_is_not_valid() {
  9.         Person person = new Person();
  10.         person.setSex("Man22");
  11.         person.setClassId("82938390");
  12.         person.setEmail("SnailClimb");
  13.         service.validatePerson(person);
  14.     }
  15. }

Validator 编程方式手动进行参数验证

某些场景下可能会需要我们手动校验并获得校验结果.

  1. @Test
  2.     public void check_person_manually() {
  3.         ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
  4.         Validator validator = factory.getValidator();
  5.         Person person = new Person();
  6.         person.setSex("Man22");
  7.         person.setClassId("82938390");
  8.         person.setEmail("SnailClimb");
  9.         Set<ConstraintViolation<Person>> violations = validator.validate(person);
  10.         //output:
  11.         //email 格式不正确
  12.         //name 不能为空
  13.         //sex 值不在可选范围
  14.         for (ConstraintViolation<Person> constraintViolation : violations) {
  15.             System.out.println(constraintViolation.getMessage());
  16.         }
  17.     }

上面我们是通过 Validator 工厂类获得的 Validator 示例, 当然你也可以通过 @Autowired 直接注入的方式. 但是在非 Spring Component 类中使用这种方式的话, 只能通过工厂类来获得 Validator.

  1. @Autowired
  2. Validator validate

自定以 Validator(实用)

如果自带的校验注解无法满足你的需求的话, 你还可以自定义实现注解.

案例一: 校验特定字段的值是否在可选范围

比如我们现在多了这样一个需求: Person 类多了一个 region 字段, region 字段只能是 China,China-Taiwan,China-HongKong 这三个中的一个.

第一步你需要创建一个注解:

  1. @Target({FIELD})
  2. @Retention(RUNTIME)
  3. @Constraint(validatedBy = RegionValidator.class)
  4. @Documented
  5. public @interface Region {
  6.     String message() default "Region 值不在可选范围内";
  7.     Class<?>[] groups() default {};
  8.     Class<? extends Payload>[] payload() default {};
  9. }

第二步你需要实现 ConstraintValidator 接口, 并重写 isValid 方法:

  1. import javax.validation.ConstraintValidator;
  2. import javax.validation.ConstraintValidatorContext;
  3. import java.util.HashSet;
  4. public class RegionValidator implements ConstraintValidator<Region, String> {
  5.     @Override
  6.     public boolean isValid(String value, ConstraintValidatorContext context) {
  7.         HashSet<Object> regions = new HashSet<>();
  8.         regions.add("China");
  9.         regions.add("China-Taiwan");
  10.         regions.add("China-HongKong");
  11.         return regions.contains(value);
  12.     }
  13. }

现在你就可以使用这个注解:

  1. @Region
  2.     private String region;

案例二: 校验电话号码

校验我们的电话号码是否合法, 这个可以通过正则表达式来做, 相关的正则表达式都可以在网上搜到, 你甚至可以搜索到针对特定运营商电话号码段的正则表达式.

PhoneNumber.java

  1. import javax.validation.Constraint;
  2. import java.lang.annotation.Documented;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.Target;
  5. import static java.lang.annotation.ElementType.FIELD;
  6. import static java.lang.annotation.ElementType.PARAMETER;
  7. import static java.lang.annotation.RetentionPolicy.RUNTIME;
  8. @Documented
  9. @Constraint(validatedBy = PhoneNumberValidator.class)
  10. @Target({FIELD, PARAMETER})
  11. @Retention(RUNTIME)
  12. public @interface PhoneNumber {
  13.     String message() default "Invalid phone number";
  14.     Class[] groups() default {};
  15.     Class[] payload() default {};
  16. }

PhoneNumberValidator.java

  1. import javax.validation.ConstraintValidator;
  2. import javax.validation.ConstraintValidatorContext;
  3. public class PhoneNumberValidator implements ConstraintValidator<PhoneNumber,String> {
  4.     @Override
  5.     public boolean isValid(String phoneField, ConstraintValidatorContext context) {
  6.         if (phoneField == null) {
  7.             // can be null
  8.             return true;
  9.         }
  10.         return phoneField.matches("^1(3[0-9]|4[57]|5[0-35-9]|8[0-9]|70)\\d{8}$") && phoneField.length()> 8 && phoneField.length() < 14;
  11.     }
  12. }

搞定, 我们现在就可以使用这个注解了.

  1. @PhoneNumber(message = "phoneNumber 格式不正确")
  2. @NotNull(message = "phoneNumber 不能为空")
  3. private String phoneNumber;

使用验证组

某些场景下我们需要使用到验证组, 这样说可能不太清楚, 说简单点就是对对象操作的不同方法有不同的验证规则, 示例如下 (这个就我目前经历的项目来说使用的比较少, 因为本身这个在代码层面理解起来是比较麻烦的, 然后写起来也比较麻烦).

先创建两个接口:

  1. public interface AddPersonGroup {
  2. 	
  3. }
  4. public interface DeletePersonGroup {
  5. 	
  6. }

我们可以这样去使用验证组

  1. @NotNull(groups = DeletePersonGroup.class)
  2. @Null(groups = AddPersonGroup.class)
  3. private String group;
  4. @Service
  5. @Validated
  6. public class PersonService {
  7.     public void validatePerson(@Valid Person person) {
  8.         // do something
  9.     }
  10.     @Validated(AddPersonGroup.class)
  11.     public void validatePersonGroupForAdd(@Valid Person person) {
  12.         // do something
  13.     }
  14.     @Validated(DeletePersonGroup.class)
  15.     public void validatePersonGroupForDelete(@Valid Person person) {
  16.         // do something
  17.     }
  18. }

通过测试验证:

  1. @Test(expected = ConstraintViolationException.class)
  2.     public void should_check_person_with_groups() {
  3.         Person person = new Person();
  4.         person.setSex("Man22");
  5.         person.setClassId("82938390");
  6.         person.setEmail("SnailClimb");
  7.         person.setGroup("group1");
  8.         service.validatePersonGroupForAdd(person);
  9.     }
  10.     @Test(expected = ConstraintViolationException.class)
  11.     public void should_check_person_with_groups2() {
  12.         Person person = new Person();
  13.         person.setSex("Man22");
  14.         person.setClassId("82938390");
  15.         person.setEmail("SnailClimb");
  16.         service.validatePersonGroupForDelete(person);
  17.     }

使用验证组这种方式的时候一定要小心, 这是一种反模式, 还会造成代码逻辑性变差.

代码地址: https://github.com/Snailclimb/springboot-guide/tree/master/source-code/advanced/bean-validation-demo

  1. @NotNull vs
  2. @Column(nullable = false)
  3. (重要)

在使用 JPA 操作数据的时候会经常碰到 @Column(nullable = false) 这种类型的约束, 那么它和 @NotNull 有何区别呢? 搞清楚这个还是很重要的!

@NotNull 是 JSR 303 Bean 验证批注, 它与数据库约束本身无关.

@Column(nullable = false)

: 是 JPA 声明列为非空的方法.

总结来说就是即前者用于验证, 而后者则用于指示数据库创建表的时候对表的约束.

TODO

[ ] 原理分析

参考

  1. https://reflectoring.io/bean-validation-with-spring-boot/
  2. https://www.cnkirito.moe/spring-validation//

开源项目推荐

作者的其他开源项目推荐:

https://github.com/Snailclimb/JavaGuide :[Java 学习 + 面试指南] 一份涵盖大部分 Java 程序员所需要掌握的核心知识.

https://github.com/Snailclimb/springboot-guide : 适合新手入门以及有经验的开发人员查阅的 Spring Boot 教程 (业余时间维护中, 欢迎一起维护).

: 我觉得技术人员应该有的一些好习惯!

: 从零入门 !Spring Security With JWT(含权限验证) 后端部分代码.

来源: https://www.cnblogs.com/javaguide/p/11832752.html


与本文相关文章

  1. Spring boot 自定义 Resolver 支持 interface 类型参数
  2. Java 可变参数列表
  3. Spring Boot 统一异常处理以及参数校验
  4. Spring Boot 2.x 基础教程: JSR-303 实现请求参数校验
  5. java自定义注解实现前后台参数校验的实例
  6. Spring 中 Controller 获取请求参数的方法笔记
  7. 想要在静态方法中访问类的实例对象需要接受该类型的参数, 然后通过参数来访问.
  8. java 自定义注解实现前后台参数校验的实例
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1