Spring Boot DTO 验证示例

allway2

已于 2022-11-10 13:14:39 修改

阅读量1.5k

点赞数

于 2022-11-10 13:12:05 首次发布

本文链接：https://blog.csdn.net/allway2/article/details/127786840

版权

在本教程中，我们将学习如何使用 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依赖项：

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

弹簧引导 DTO 验证示例

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

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

使用以下指南在 Eclipse STS IDE 中创建 Spring 引导项目：

=> 在 Spring 工具套件中创建 Spring 引导项目 [STS]

- 将项目名称作为弹簧启动验证。

- 将以下依赖项添加到此项目：

春网
验证
春季数据 JPA
H2 数据库

2. Maven 依赖项

创建 Spring 引导项目后，使用以下pom.xml 文件验证您的pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.3</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>net.javaguides</groupId>
	<artifactId>springboot-validation</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springboot-validation</name>
	<description>Demo project for Spring Boot and Hibernate Validator</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-validation</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>com.h2database</groupId>
			<artifactId>h2</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

3. 创建用户类

让我们创建一个新的模型包。在此模型包中，创建一个用户JPA 类并向其中添加以下内容：

package net.javaguides.springboot.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Table(name = "users")
@Entity
public class User {
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private long id;
	
	@Column(name = "name", nullable = false)
	private String name;
	
	private String email;
	
	private String password;
	
	public User() {
		
	}
	
	public User(String name, String email, String password) {
		super();
		this.name = name;
		this.email = email;
		this.password = password;
	}
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
}

4. 创建用户Dto 类

让我们创建一个dto包。在dto包中，创建UserDto类并向其中添加以下内容：

package net.javaguides.springboot.dto;

import javax.validation.constraints.Email;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Size;

public class UserDto {
	
	private long id;
	
	// user name should not be null or empty
	// user name should have at least 2 characters
	@NotEmpty
	@Size(min = 2, message = "user name should have at least 2 characters")
	private String name;
	
	// email should be a valid email format
	// email should not be null or empty
	@NotEmpty
	@Email
	private String email;
	
	// password should not be null or empty
	// password should have at least 8 characters
	@NotEmpty
	@Size(min = 8, message = "password should have at least 8 characters")
	private String password;
	
	public UserDto() {
		
	}
	
	public UserDto(String name, String email, String password) {
		super();
		this.name = name;
		this.email = email;
		this.password = password;
	}
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
}

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

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

5. 配置数据库

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

6. 创建用户存储库

让我们创建一个存储库包。在此包中，创建一个与数据库通信的UserRepository类。添加以下内容：

package net.javaguides.springboot.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import net.javaguides.springboot.model.User;

public interface UserRepository extends JpaRepository<User, Long>{

}

7. 创建用户服务类

让我们创建一个服务包。在此包中，创建一个UserService类并向其中添加以下代码：

package net.javaguides.springboot.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import net.javaguides.springboot.model.User;
import net.javaguides.springboot.repository.UserRepository;

@Service
public class UserService {
	
	@Autowired
	private UserRepository userRepository;
	
	public User createUser(User user) {
		return userRepository.save(user);
	}	
}

8. 创建用户控制器类

让我们创建一个控制器包。在此包中，创建一个UserController类并向其添加以下内容：

package net.javaguides.springboot.controller;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import net.javaguides.springboot.model.User;
import net.javaguides.springboot.dto.UserDto;
import net.javaguides.springboot.service.UserService;

@RestController
@RequestMapping("/api/")
public class UserController {
	
	@Autowired
	private UserService userService;
	
	@PostMapping("users")
	public ResponseEntity<UserDto> createUser(@Valid @RequestBody UserDto userDto){
	
		// convert UserDto to User entity
		User user = new User();
		user.setName(userDto.getName());
		user.setEmail(userDto.getEmail());
		user.setPassword(userDto.getPassword());
		User savedUser = userService.createUser(user);
		
		// convert User entity to UserDto class
		UserDto userResponse = new UserDto();
		userResponse.setId(savedUser.getId());
		userResponse.setName(savedUser.getName());
		userResponse.setEmail(savedUser.getEmail());
		// don't provide password to client
		// userResponse.setPassword(savedUser.getPassword());
		
		return new ResponseEntity<User>(userResponse, HttpStatus.CREATED);
	}
}

请注意，我们通过在createUser（） 方法中添加@Valid注释来启用 Spring Rest 控制器上的验证@RequestBody。

9. 创建验证处理程序

让我们创建一个验证处理程序来自定义验证响应。

要自定义响应验证，我们需要扩展ResponseEntityExceptionHandler类并覆盖handleMethodArgumentNotValid（MethodArgumentNotValidException ex， HttpHeaders headers， HttpStatus status， WebRequest request）方法。

让我们创建ValidationHandler类并向其添加以下内容：

package net.javaguides.springboot.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

@ControllerAdvice
public class ValidationHandler extends ResponseEntityExceptionHandler{
	
	@Override
	protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex,
			HttpHeaders headers, HttpStatus status, WebRequest request) {
		
		Map<String, String> errors = new HashMap<>();
		ex.getBindingResult().getAllErrors().forEach((error) ->{
			
			String fieldName = ((FieldError) error).getField();
			String message = error.getDefaultMessage();
			errors.put(fieldName, message);
		});
		return new ResponseEntity<Object>(errors, HttpStatus.BAD_REQUEST);
	}
}

10.运行弹簧启动应用程序

使用主类运行 Spring 引导应用程序：

package net.javaguides.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootValidationApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringbootValidationApplication.class, args);
	}

}

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依赖项：

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

allway2

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Spring Boot DTO 验证示例

我们不会将 Java Bean 验证注释添加到 JPA 实体，而是将 Java Bean 验证注释添加到 DTO，因为我们将在 REST API 的请求和响应中使用 DTO。JSR 380 是用于 Bean 验证的 Java API 规范，它使用 @NotNull、@Min 和 @Max 等注释确保 Bean 的属性满足特定条件。在本教程中，我们学习了如何使用Hibernate验证器在Spring boot REST API中验证DTO对象。只能应用于文本值，并验证属性是否为 null 或空格。
复制链接

扫一扫