• Spring Boot DTO 验证示例

    在本教程中，我们将学习如何使用 Hibernate 验证器验证 Spring 启动 REST API DTO 请求。

    在Java中，Java Bean Validation框架已经成为处理Java项目中验证的事实标准。

    JSR 380 是用于 Bean 验证的 Java API 规范，它使用 @NotNull、@Min 和 @Max 等注释确保 Bean 的属性满足特定条件。

    Hibernate验证器是验证API的参考实现。

    我们创建并使用DTO（数据传输对象）在客户端和服务器之间转换数据。

    数据传输对象设计模式是一种常用的设计模式。它基本上用于一次性将具有多个属性的数据从客户端传递到服务器，以避免多次调用远程服务器。

    我们不会将 Java Bean 验证注释添加到 JPA 实体，而是将 Java Bean 验证注释添加到 DTO，因为我们将在 REST API 的请求和响应中使用 DTO。

    重要的 Java Bean 验证

    • @NotNull验证批注的属性值是否不为 null。
    • @Size验证批注属性值的大小是否介于属性 min 和 max 之间;可以应用于字符串、集合、映射和数组属性。
    • @Min验证批注属性的值不小于 value 属性。
    • @Max验证批注属性的值不大于 value 属性。
    • @Email验证批注属性是否为有效的电子邮件地址。
    • @NotEmpty验证属性是否为空或空;可以应用于字符串、集合、映射或数组值。
    • @NotBlank只能应用于文本值，并验证属性是否为 null 或空格。
    在此处查看完整列表Source Code Examples

    Spring 引导中的验证

    Spring boot 提供了与 Hibernate 验证器的良好集成支持。

    我们将使用 Hibernate Validator，它是 Bean 验证 API 的参考实现之一。

    从 Boot 2.3 开始，我们需要显式添加spring-boot-starter-validation依赖项：

    1.  
    2.     org.springframework.boot 
    3.     spring-boot-starter-validation

    弹簧引导 DTO 验证示例

    让我们创建一个分步示例来演示如何使用 Hibernate 验证器验证 Spring 启动 REST API DTO 请求。

    1. 在 STS 中创建 Spring 引导应用程序

    使用以下指南在 Eclipse STS IDE 中创建 Spring 引导项目：
    - 将项目名称作为弹簧启动验证。
    - 将以下依赖项添加到此项目：
    • 春网
    • 验证
    • 春季数据 JPA
    • H2 数据库

    2. Maven 依赖项

    创建 Spring 引导项目后，使用以下pom.xml 文件验证您的pom.xml： 
    3. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    4. 	4.0.0
    5. 	
    6. 		org.springframework.boot
    7. 		spring-boot-starter-parent
    8. 		2.4.3
    9. 		 
    10. 	
    11. 	net.javaguides
    12. 	springboot-validation
    13. 	0.0.1-SNAPSHOT
    14. 	springboot-validation
    15. 	Demo project for Spring Boot and Hibernate Validator
    16. 	
    17. 		1.8
    18. 	
    19. 	
    20. 		
    21. 			org.springframework.boot
    22. 			spring-boot-starter-data-jpa
    23. 		
    24. 		
    25. 			org.springframework.boot
    26. 			spring-boot-starter-validation
    27. 		
    28. 		
    29. 			org.springframework.boot
    30. 			spring-boot-starter-web
    31. 		
    32.  
    33. 		
    34. 			com.h2database
    35. 			h2
    36. 			runtime
    37. 		
    38. 		
    39. 			org.springframework.boot
    40. 			spring-boot-starter-test
    41. 			test
    42. 		
    43. 	
    44.  
    45. 	
    46. 		
    47. 			
    48. 				org.springframework.boot
    49. 				spring-boot-maven-plugin
    50. 			
    51. 		
    52. 	
    53.

    3. 创建用户类

    让我们创建一个新的模型包。在此模型包中，创建一个用户JPA 类并向其中添加以下内容： 
    1. package net.javaguides.springboot.model;
    2.  
    3. import javax.persistence.Column;
    4. import javax.persistence.Entity;
    5. import javax.persistence.GeneratedValue;
    6. import javax.persistence.GenerationType;
    7. import javax.persistence.Id;
    8. import javax.persistence.Table;
    9.  
    10. @Table(name = "users")
    11. @Entity
    12. public class User {
    13. 	
    14. 	@Id
    15. 	@GeneratedValue(strategy = GenerationType.IDENTITY)
    16. 	private long id;
    17. 	
    18. 	@Column(name = "name", nullable = false)
    19. 	private String name;
    20. 	
    21. 	private String email;
    22. 	
    23. 	private String password;
    24. 	
    25. 	public User() {
    26. 		
    27. 	}
    28. 	
    29. 	public User(String name, String email, String password) {
    30. 		super();
    31. 		this.name = name;
    32. 		this.email = email;
    33. 		this.password = password;
    34. 	}
    35. 	public long getId() {
    36. 		return id;
    37. 	}
    38. 	public void setId(long id) {
    39. 		this.id = id;
    40. 	}
    41. 	public String getName() {
    42. 		return name;
    43. 	}
    44. 	public void setName(String name) {
    45. 		this.name = name;
    46. 	}
    47. 	public String getEmail() {
    48. 		return email;
    49. 	}
    50. 	public void setEmail(String email) {
    51. 		this.email = email;
    52. 	}
    53. 	public String getPassword() {
    54. 		return password;
    55. 	}
    56. 	public void setPassword(String password) {
    57. 		this.password = password;
    58. 	}
    59. }

    4. 创建用户Dto 类

    让我们创建一个dto包。在dto包中，创建UserDto类并向其中添加以下内容： 
    1. package net.javaguides.springboot.dto;
    2.  
    3. import javax.validation.constraints.Email;
    4. import javax.validation.constraints.NotEmpty;
    5. import javax.validation.constraints.Size;
    6.  
    7. public class UserDto {
    8. 	
    9. 	private long id;
    10. 	
    11. 	// user name should not be null or empty
    12. 	// user name should have at least 2 characters
    13. 	@NotEmpty
    14. 	@Size(min = 2, message = "user name should have at least 2 characters")
    15. 	private String name;
    16. 	
    17. 	// email should be a valid email format
    18. 	// email should not be null or empty
    19. 	@NotEmpty
    20. 	@Email
    21. 	private String email;
    22. 	
    23. 	// password should not be null or empty
    24. 	// password should have at least 8 characters
    25. 	@NotEmpty
    26. 	@Size(min = 8, message = "password should have at least 8 characters")
    27. 	private String password;
    28. 	
    29. 	public UserDto() {
    30. 		
    31. 	}
    32. 	
    33. 	public UserDto(String name, String email, String password) {
    34. 		super();
    35. 		this.name = name;
    36. 		this.email = email;
    37. 		this.password = password;
    38. 	}
    39. 	public long getId() {
    40. 		return id;
    41. 	}
    42. 	public void setId(long id) {
    43. 		this.id = id;
    44. 	}
    45. 	public String getName() {
    46. 		return name;
    47. 	}
    48. 	public void setName(String name) {
    49. 		this.name = name;
    50. 	}
    51. 	public String getEmail() {
    52. 		return email;
    53. 	}
    54. 	public void setEmail(String email) {
    55. 		this.email = email;
    56. 	}
    57. 	public String getPassword() {
    58. 		return password;
    59. 	}
    60. 	public void setPassword(String password) {
    61. 		this.password = password;
    62. 	}
    63. }

    请注意，我们在下面添加了 Java Bean 验证注释到UserDto类：

    • @NotEmpty验证属性是否为空或空;可以应用于字符串、集合、映射或数组值。
    • @Size验证批注属性值的大小是否介于属性 min 和 max 之间;可以应用于字符串、集合、映射和数组属性。
    • @Email验证批注属性是否为有效的电子邮件地址。

    5. 配置数据库

    Spring boot 会自动为 H2 内存数据库配置数据库详细信息，因此我们无需在application.properties文件中显式添加数据库配置。

    6. 创建用户存储库

    让我们创建一个存储库包。在此包中，创建一个与数据库通信的UserRepository类。添加以下内容： 
    1. package net.javaguides.springboot.repository;
    2.  
    3. import org.springframework.data.jpa.repository.JpaRepository;
    4.  
    5. import net.javaguides.springboot.model.User;
    6.  
    7. public interface UserRepository extends JpaRepository{
    8.  
    9. }

    7. 创建用户服务类

    让我们创建一个服务包。在此包中，创建一个UserService类并向其中添加以下代码： 
    1. package net.javaguides.springboot.service;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.stereotype.Service;
    5.  
    6. import net.javaguides.springboot.model.User;
    7. import net.javaguides.springboot.repository.UserRepository;
    8.  
    9. @Service
    10. public class UserService {
    11. 	
    12. 	@Autowired
    13. 	private UserRepository userRepository;
    14. 	
    15. 	public User createUser(User user) {
    16. 		return userRepository.save(user);
    17. 	}	
    18. }

    8. 创建用户控制器类

    让我们创建一个控制器包。在此包中，创建一个UserController类并向其添加以下内容： 
    1. package net.javaguides.springboot.controller;
    2.  
    3. import javax.validation.Valid;
    4.  
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.http.HttpStatus;
    7. import org.springframework.http.ResponseEntity;
    8. import org.springframework.web.bind.annotation.PostMapping;
    9. import org.springframework.web.bind.annotation.RequestBody;
    10. import org.springframework.web.bind.annotation.RequestMapping;
    11. import org.springframework.web.bind.annotation.RestController;
    12.  
    13. import net.javaguides.springboot.model.User;
    14. import net.javaguides.springboot.dto.UserDto;
    15. import net.javaguides.springboot.service.UserService;
    16.  
    17. @RestController
    18. @RequestMapping("/api/")
    19. public class UserController {
    20. 	
    21. 	@Autowired
    22. 	private UserService userService;
    23. 	
    24. 	@PostMapping("users")
    25. 	public ResponseEntity createUser(@Valid @RequestBody UserDto userDto){
    26. 	
    27. 		// convert UserDto to User entity
    28. 		User user = new User();
    29. 		user.setName(userDto.getName());
    30. 		user.setEmail(userDto.getEmail());
    31. 		user.setPassword(userDto.getPassword());
    32. 		User savedUser = userService.createUser(user);
    33. 		
    34. 		// convert User entity to UserDto class
    35. 		UserDto userResponse = new UserDto();
    36. 		userResponse.setId(savedUser.getId());
    37. 		userResponse.setName(savedUser.getName());
    38. 		userResponse.setEmail(savedUser.getEmail());
    39. 		// don't provide password to client
    40. 		// userResponse.setPassword(savedUser.getPassword());
    41. 		
    42. 		return new ResponseEntity(userResponse, HttpStatus.CREATED);
    43. 	}
    44. }
    请注意，我们通过在createUser（） 方法中添加@Valid注释来启用 Spring Rest 控制器上的验证@RequestBody。

    9. 创建验证处理程序

    让我们创建一个验证处理程序来自定义验证响应。
    要自定义响应验证，我们需要扩展ResponseEntityExceptionHandler类并覆盖handleMethodArgumentNotValid（MethodArgumentNotValidException ex， HttpHeaders headers， HttpStatus status， WebRequest request）方法。
    让我们创建ValidationHandler类并向其添加以下内容： 
    1. package net.javaguides.springboot.controller;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Map;
    5.  
    6. import org.springframework.http.HttpHeaders;
    7. import org.springframework.http.HttpStatus;
    8. import org.springframework.http.ResponseEntity;
    9. import org.springframework.validation.FieldError;
    10. import org.springframework.web.bind.MethodArgumentNotValidException;
    11. import org.springframework.web.bind.annotation.ControllerAdvice;
    12. import org.springframework.web.context.request.WebRequest;
    13. import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
    14.  
    15. @ControllerAdvice
    16. public class ValidationHandler extends ResponseEntityExceptionHandler{
    17. 	
    18. 	@Override
    19. 	protected ResponseEntity handleMethodArgumentNotValid(MethodArgumentNotValidException ex,
    20. 			HttpHeaders headers, HttpStatus status, WebRequest request) {
    21. 		
    22. 		Map errors = new HashMap<>();
    23. 		ex.getBindingResult().getAllErrors().forEach((error) ->{
    24. 			
    25. 			String fieldName = ((FieldError) error).getField();
    26. 			String message = error.getDefaultMessage();
    27. 			errors.put(fieldName, message);
    28. 		});
    29. 		return new ResponseEntity(errors, HttpStatus.BAD_REQUEST);
    30. 	}
    31. }
      32.  
   
  
      10.运行弹簧启动应用程序
       
  
       
   使用主类运行 Spring 引导应用程序： 
  
       
  
       
   
      1. package net.javaguides.springboot;
      2.  
      3. import org.springframework.boot.SpringApplication;
      4. import org.springframework.boot.autoconfigure.SpringBootApplication;
      5.  
      6. @SpringBootApplication
      7. public class SpringbootValidationApplication {
      8.  
      9. 	public static void main(String[] args) {
      10. 		SpringApplication.run(SpringbootValidationApplication.class, args);
      11. 	}
      12.  
      13. }
       
  
       
  
      11. 使用邮递员客户端进行测试
       
  
       
   下面的屏幕截图显示了使用Hibernate验证器对Spring boot REST API的验证： 
  
       
  
       
   
       
    
       
   
         
   
      11. 结论
       
  
       
  
       
   
      在本教程中，我们学习了如何使用Hibernate验证器在Spring boot REST API中验证DTO对象。
       
   
       
   
       
    本教程的源代码可在我的 GitHub 存储库中找到，网址为GitHub - RameshMF/springboot-validation: Validation in Spring Boot REST API with Hibernate Validator (Java Bean Validation Annotations) 
   
       
   
       
   
      从 Boot 2.3 开始，我们需要显式添加spring-boot-starter-validation依赖项：
       
   
       
    org.springframework.boot 
    spring-boot-starter-validation 

       
   
       
       
  
       
  

                
                    
                

                
    32. 

                    相关阅读:
      
                    
浅谈ChatGPT                            
      
二叉树最大宽度 : 简单 DFS 运用题                            
      
Spring 中BeanFactory和FactoryBean有什么不同之处呢?                            
      
IDEA 配置 Maven（解决依赖下载缓慢）                            
      
必看！TMS320C6678＋Kintex-7开发板——FPGA案例开发资料（上）                            
      
redis未授权漏洞                            
      
Mysql.索引详解                            
      
Vim 使用操作                            
      
[思维]Party Codeforces1711B                            
      
【Flink伪分布式环境搭建及应用，Standlong（开发测试）】                            
      
                          
                
      33. 
                
    33. 
                    原文地址：https://blog.csdn.net/allway2/article/details/127786840
                
      34.