脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Spring Boot 数据验证与异常处理

Spring Boot 数据验证与异常处理问题小结

 更新时间：2026年03月30日 10:21:04   作者：星辰徐哥  
本文给大家介绍Spring Boot数据验证与异常处理,包括数据验证的定义与特点、异常处理的定义与特点、Spring Boot与数据验证的集成、Spring Boot与异常处理的集成、Spring Boot的实际应用场景,学会了在实际开发中处理数据验证与异常处理问题,感兴趣的朋友跟随小编一起看看吧

Spring Boot 数据验证与异常处理

34.1 学习目标与重点提示

学习目标：掌握Spring Boot数据验证与异常处理的核心概念与使用方法，包括数据验证的定义与特点、异常处理的定义与特点、Spring Boot与数据验证的集成、Spring Boot与异常处理的集成、Spring Boot的实际应用场景，学会在实际开发中处理数据验证与异常处理问题。
重点：数据验证的定义与特点、异常处理的定义与特点、Spring Boot与数据验证的集成、Spring Boot与异常处理的集成、Spring Boot的实际应用场景。

34.2 数据验证与异常处理概述

数据验证与异常处理是Java开发中的重要组件，用于确保数据的正确性和处理系统的异常。

34.2.1 数据验证的定义

定义：数据验证是指对输入数据进行验证，确保数据的正确性和完整性。
作用：

  • 确保输入数据的正确性。
  • 防止恶意数据的输入。
  • 提高系统的可靠性。

常见的数据验证：

  • 非空验证。
  • 长度验证。
  • 格式验证。
  • 范围验证。

✅ 结论：数据验证是指对输入数据进行验证，作用是确保输入数据的正确性、防止恶意数据的输入、提高系统的可靠性。

34.2.2 异常处理的定义

定义：异常处理是指对系统运行过程中出现的异常进行处理，确保系统的正常运行。
作用：

  • 提高系统的可靠性。
  • 提高用户体验。
  • 便于系统的维护。

常见的异常处理：

  • 异常捕获。
  • 异常转换。
  • 异常抛出。
  • 异常记录。

✅ 结论：异常处理是指对系统运行过程中出现的异常进行处理，作用是提高系统的可靠性、提高用户体验、便于系统的维护。

34.3 Spring Boot与数据验证的集成

Spring Boot与数据验证的集成是Java开发中的重要内容。

34.3.1 集成Spring Validation的步骤

定义：集成Spring Validation的步骤是指使用Spring Boot与Spring Validation集成的方法。
步骤：

  1. 创建Spring Boot项目。
  2. 添加所需的依赖。
  3. 配置数据验证。
  4. 创建实体类。
  5. 创建业务层。
  6. 创建控制器类。
  7. 测试应用。

示例：
pom.xml文件中的依赖：

<dependencies>
    <!-- Web依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</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-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

application.properties文件中的配置：

# 服务器端口
server.port=8080

实体类：

import javax.validation.constraints.*;
public class Product {
    private Long id;
    @NotBlank(message = "产品ID不能为空")
    @Size(min = 3, max = 10, message = "产品ID长度必须在3到10个字符之间")
    private String productId;
    @NotBlank(message = "产品名称不能为空")
    @Size(min = 2, max = 50, message = "产品名称长度必须在2到50个字符之间")
    private String productName;
    @Min(value = 0, message = "价格必须大于等于0")
    @Max(value = 10000, message = "价格必须小于等于10000")
    private double price;
    @Min(value = 0, message = "库存必须大于等于0")
    private int stock;
    public Product() {
    }
    public Product(Long id, String productId, String productName, double price, int stock) {
        this.id = id;
        this.productId = productId;
        this.productName = productName;
        this.price = price;
        this.stock = stock;
    }
    // Getter和Setter方法
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getProductId() {
        return productId;
    }
    public void setProductId(String productId) {
        this.productId = productId;
    }
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public int getStock() {
        return stock;
    }
    public void setStock(int stock) {
        this.stock = stock;
    }
    @Override
    public String toString() {
        return "Product{" +
                "id=" + id +
                ", productId='" + productId + '\'' +
                ", productName='" + productName + '\'' +
                ", price=" + price +
                ", stock=" + stock +
                '}';
    }
}

Repository接口：

import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Repository
public class ProductRepository {
    private List<Product> products = new ArrayList<>();
    public ProductRepository() {
        products.add(new Product(1L, "P001", "手机", 1000.0, 100));
        products.add(new Product(2L, "P002", "电脑", 5000.0, 50));
        products.add(new Product(3L, "P003", "电视", 3000.0, 80));
        products.add(new Product(4L, "P004", "手表", 500.0, 200));
        products.add(new Product(5L, "P005", "耳机", 300.0, 150));
    }
    public List<Product> getAllProducts() {
        return products;
    }
    public Product getProductById(Long id) {
        return products.stream().filter(product -> product.getId().equals(id)).findFirst().orElse(null);
    }
    public void addProduct(Product product) {
        product.setId((long) (products.size() + 1));
        products.add(product);
    }
    public void updateProduct(Product product) {
        Product existingProduct = getProductById(product.getId());
        if (existingProduct != null) {
            existingProduct.setProductId(product.getProductId());
            existingProduct.setProductName(product.getProductName());
            existingProduct.setPrice(product.getPrice());
            existingProduct.setStock(product.getStock());
        }
    }
    public void deleteProduct(Long id) {
        products.removeIf(product -> product.getId().equals(id));
    }
}

Service类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;
    public List<Product> getAllProducts() {
        return productRepository.getAllProducts();
    }
    public Product getProductById(Long id) {
        return productRepository.getProductById(id);
    }
    public void addProduct(Product product) {
        productRepository.addProduct(product);
    }
    public void updateProduct(Product product) {
        productRepository.updateProduct(product);
    }
    public void deleteProduct(Long id) {
        productRepository.deleteProduct(id);
    }
}

控制器类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("/api/products")
public class ProductController {
    @Autowired
    private ProductService productService;
    @GetMapping("/")
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }
    @GetMapping("/{id}")
    public Product getProductById(@PathVariable Long id) {
        return productService.getProductById(id);
    }
    @PostMapping("/add")
    public Map<String, Object> addProduct(@Valid @RequestBody Product product, BindingResult bindingResult) {
        Map<String, Object> result = new HashMap<>();
        if (bindingResult.hasErrors()) {
            Map<String, String> errors = new HashMap<>();
            for (FieldError error : bindingResult.getFieldErrors()) {
                errors.put(error.getField(), error.getDefaultMessage());
            }
            result.put("success", false);
            result.put("errors", errors);
            return result;
        }
        productService.addProduct(product);
        result.put("success", true);
        result.put("message", "产品添加成功");
        return result;
    }
    @PutMapping("/edit/{id}")
    public Map<String, Object> editProduct(@PathVariable Long id, @Valid @RequestBody Product product, BindingResult bindingResult) {
        Map<String, Object> result = new HashMap<>();
        if (bindingResult.hasErrors()) {
            Map<String, String> errors = new HashMap<>();
            for (FieldError error : bindingResult.getFieldErrors()) {
                errors.put(error.getField(), error.getDefaultMessage());
            }
            result.put("success", false);
            result.put("errors", errors);
            return result;
        }
        product.setId(id);
        productService.updateProduct(product);
        result.put("success", true);
        result.put("message", "产品更新成功");
        return result;
    }
    @DeleteMapping("/delete/{id}")
    public Map<String, Object> deleteProduct(@PathVariable Long id) {
        Map<String, Object> result = new HashMap<>();
        productService.deleteProduct(id);
        result.put("success", true);
        result.put("message", "产品删除成功");
        return result;
    }
}

应用启动类：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ValidationApplication {
    public static void main(String[] args) {
        SpringApplication.run(ValidationApplication.class, args);
    }
}

测试类：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.http.*;
import java.util.HashMap;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ValidationApplicationTests {
    @LocalServerPort
    private int port;
    @Autowired
    private TestRestTemplate restTemplate;
    @Test
    void contextLoads() {
    }
    @Test
    void testAddProduct() {
        Map<String, Object> product = new HashMap<>();
        product.put("productId", "P006");
        product.put("productName", "耳机");
        product.put("price", 300.0);
        product.put("stock", 150);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Map<String, Object>> request = new HttpEntity<>(product, headers);
        ResponseEntity<Map> response = restTemplate.exchange(
                "http://localhost:" + port + "/api/products/add",
                HttpMethod.POST,
                request,
                Map.class
        );
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(response.getBody().get("success")).isEqualTo(true);
    }
    @Test
    void testAddProductWithInvalidData() {
        Map<String, Object> product = new HashMap<>();
        product.put("productId", "P");
        product.put("productName", "");
        product.put("price", -100.0);
        product.put("stock", -10);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Map<String, Object>> request = new HttpEntity<>(product, headers);
        ResponseEntity<Map> response = restTemplate.exchange(
                "http://localhost:" + port + "/api/products/add",
                HttpMethod.POST,
                request,
                Map.class
        );
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(response.getBody().get("success")).isEqualTo(false);
        assertThat(response.getBody().get("errors")).isNotNull();
    }
}

✅ 结论：集成Spring Validation的步骤包括创建Spring Boot项目、添加所需的依赖、配置数据验证、创建实体类、创建业务层、创建控制器类、测试应用。

34.4 Spring Boot与异常处理的集成

Spring Boot与异常处理的集成是Java开发中的重要内容。

34.4.1 集成Spring Boot异常处理的步骤

定义：集成Spring Boot异常处理的步骤是指使用Spring Boot与异常处理集成的方法。
步骤：

  1. 创建Spring Boot项目。
  2. 添加所需的依赖。
  3. 配置异常处理。
  4. 创建异常类。
  5. 创建异常处理器类。
  6. 测试应用。

示例：
pom.xml文件中的依赖：

<dependencies>
    <!-- Web依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</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-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

application.properties文件中的配置：

# 服务器端口
server.port=8080

实体类：

import javax.validation.constraints.*;
public class Product {
    private Long id;
    @NotBlank(message = "产品ID不能为空")
    @Size(min = 3, max = 10, message = "产品ID长度必须在3到10个字符之间")
    private String productId;
    @NotBlank(message = "产品名称不能为空")
    @Size(min = 2, max = 50, message = "产品名称长度必须在2到50个字符之间")
    private String productName;
    @Min(value = 0, message = "价格必须大于等于0")
    @Max(value = 10000, message = "价格必须小于等于10000")
    private double price;
    @Min(value = 0, message = "库存必须大于等于0")
    private int stock;
    public Product() {
    }
    public Product(Long id, String productId, String productName, double price, int stock) {
        this.id = id;
        this.productId = productId;
        this.productName = productName;
        this.price = price;
        this.stock = stock;
    }
    // Getter和Setter方法
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getProductId() {
        return productId;
    }
    public void setProductId(String productId) {
        this.productId = productId;
    }
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public int getStock() {
        return stock;
    }
    public void setStock(int stock) {
        this.stock = stock;
    }
    @Override
    public String toString() {
        return "Product{" +
                "id=" + id +
                ", productId='" + productId + '\'' +
                ", productName='" + productName + '\'' +
                ", price=" + price +
                ", stock=" + stock +
                '}';
    }
}

Repository接口：

import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Repository
public class ProductRepository {
    private List<Product> products = new ArrayList<>();
    public ProductRepository() {
        products.add(new Product(1L, "P001", "手机", 1000.0, 100));
        products.add(new Product(2L, "P002", "电脑", 5000.0, 50));
        products.add(new Product(3L, "P003", "电视", 3000.0, 80));
        products.add(new Product(4L, "P004", "手表", 500.0, 200));
        products.add(new Product(5L, "P005", "耳机", 300.0, 150));
    }
    public List<Product> getAllProducts() {
        return products;
    }
    public Product getProductById(Long id) {
        return products.stream().filter(product -> product.getId().equals(id)).findFirst().orElse(null);
    }
    public void addProduct(Product product) {
        product.setId((long) (products.size() + 1));
        products.add(product);
    }
    public void updateProduct(Product product) {
        Product existingProduct = getProductById(product.getId());
        if (existingProduct != null) {
            existingProduct.setProductId(product.getProductId());
            existingProduct.setProductName(product.getProductName());
            existingProduct.setPrice(product.getPrice());
            existingProduct.setStock(product.getStock());
        }
    }
    public void deleteProduct(Long id) {
        products.removeIf(product -> product.getId().equals(id));
    }
}

Service类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;
    public List<Product> getAllProducts() {
        return productRepository.getAllProducts();
    }
    public Product getProductById(Long id) {
        return productRepository.getProductById(id);
    }
    public void addProduct(Product product) {
        productRepository.addProduct(product);
    }
    public void updateProduct(Product product) {
        productRepository.updateProduct(product);
    }
    public void deleteProduct(Long id) {
        productRepository.deleteProduct(id);
    }
}

异常类：

public class ProductNotFoundException extends RuntimeException {
    public ProductNotFoundException(String message) {
        super(message);
    }
    public ProductNotFoundException(String message, Throwable cause) {
        super(message, cause);
    }
}
public class ProductExistsException extends RuntimeException {
    public ProductExistsException(String message) {
        super(message);
    }
    public ProductExistsException(String message, Throwable cause) {
        super(message, cause);
    }
}

异常处理器类：

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import java.util.HashMap;
import java.util.Map;
@ControllerAdvice
public class ProductExceptionHandler {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<Map<String, Object>> handleValidationExceptions(MethodArgumentNotValidException ex) {
        Map<String, Object> result = new HashMap<>();
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getFieldErrors().forEach(error -> {
            errors.put(error.getField(), error.getDefaultMessage());
        });
        result.put("success", false);
        result.put("errors", errors);
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(result);
    }
    @ExceptionHandler(ProductNotFoundException.class)
    public ResponseEntity<Map<String, Object>> handleProductNotFoundException(ProductNotFoundException ex) {
        Map<String, Object> result = new HashMap<>();
        result.put("success", false);
        result.put("message", ex.getMessage());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(result);
    }
    @ExceptionHandler(ProductExistsException.class)
    public ResponseEntity<Map<String, Object>> handleProductExistsException(ProductExistsException ex) {
        Map<String, Object> result = new HashMap<>();
        result.put("success", false);
        result.put("message", ex.getMessage());
        return ResponseEntity.status(HttpStatus.CONFLICT).body(result);
    }
    @ExceptionHandler(Exception.class)
    public ResponseEntity<Map<String, Object>> handleAllExceptions(Exception ex) {
        Map<String, Object> result = new HashMap<>();
        result.put("success", false);
        result.put("message", "系统错误：" + ex.getMessage());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(result);
    }
}

控制器类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("/api/products")
public class ProductController {
    @Autowired
    private ProductService productService;
    @GetMapping("/")
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }
    @GetMapping("/{id}")
    public Product getProductById(@PathVariable Long id) {
        Product product = productService.getProductById(id);
        if (product == null) {
            throw new ProductNotFoundException("产品不存在：" + id);
        }
        return product;
    }
    @PostMapping("/add")
    public Map<String, Object> addProduct(@Valid @RequestBody Product product, BindingResult bindingResult) {
        Map<String, Object> result = new HashMap<>();
        if (bindingResult.hasErrors()) {
            Map<String, String> errors = new HashMap<>();
            for (FieldError error : bindingResult.getFieldErrors()) {
                errors.put(error.getField(), error.getDefaultMessage());
            }
            result.put("success", false);
            result.put("errors", errors);
            return result;
        }
        productService.addProduct(product);
        result.put("success", true);
        result.put("message", "产品添加成功");
        return result;
    }
    @PutMapping("/edit/{id}")
    public Map<String, Object> editProduct(@PathVariable Long id, @Valid @RequestBody Product product, BindingResult bindingResult) {
        Map<String, Object> result = new HashMap<>();
        if (bindingResult.hasErrors()) {
            Map<String, String> errors = new HashMap<>();
            for (FieldError error : bindingResult.getFieldErrors()) {
                errors.put(error.getField(), error.getDefaultMessage());
            }
            result.put("success", false);
            result.put("errors", errors);
            return result;
        }
        product.setId(id);
        productService.updateProduct(product);
        result.put("success", true);
        result.put("message", "产品更新成功");
        return result;
    }
    @DeleteMapping("/delete/{id}")
    public Map<String, Object> deleteProduct(@PathVariable Long id) {
        Map<String, Object> result = new HashMap<>();
        productService.deleteProduct(id);
        result.put("success", true);
        result.put("message", "产品删除成功");
        return result;
    }
}

应用启动类：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ValidationAndExceptionApplication {
    public static void main(String[] args) {
        SpringApplication.run(ValidationAndExceptionApplication.class, args);
    }
}

测试类：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.http.*;
import java.util.HashMap;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ValidationAndExceptionApplicationTests {
    @LocalServerPort
    private int port;
    @Autowired
    private TestRestTemplate restTemplate;
    @Test
    void contextLoads() {
    }
    @Test
    void testAddProduct() {
        Map<String, Object> product = new HashMap<>();
        product.put("productId", "P006");
        product.put("productName", "耳机");
        product.put("price", 300.0);
        product.put("stock", 150);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Map<String, Object>> request = new HttpEntity<>(product, headers);
        ResponseEntity<Map> response = restTemplate.exchange(
                "http://localhost:" + port + "/api/products/add",
                HttpMethod.POST,
                request,
                Map.class
        );
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(response.getBody().get("success")).isEqualTo(true);
    }
    @Test
    void testAddProductWithInvalidData() {
        Map<String, Object> product = new HashMap<>();
        product.put("productId", "P");
        product.put("productName", "");
        product.put("price", -100.0);
        product.put("stock", -10);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Map<String, Object>> request = new HttpEntity<>(product, headers);
        ResponseEntity<Map> response = restTemplate.exchange(
                "http://localhost:" + port + "/api/products/add",
                HttpMethod.POST,
                request,
                Map.class
        );
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
        assertThat(response.getBody().get("success")).isEqualTo(false);
        assertThat(response.getBody().get("errors")).isNotNull();
    }
    @Test
    void testGetProductById() {
        ResponseEntity<Product> response = restTemplate.getForEntity("http://localhost:" + port + "/api/products/1", Product.class);
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(response.getBody()).isNotNull();
    }
    @Test
    void testGetProductByIdNotFound() {
        ResponseEntity<Map> response = restTemplate.getForEntity("http://localhost:" + port + "/api/products/10", Map.class);
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
        assertThat(response.getBody().get("success")).isEqualTo(false);
        assertThat(response.getBody().get("message")).isNotNull();
    }
}

✅ 结论：集成Spring Boot异常处理的步骤包括创建Spring Boot项目、添加所需的依赖、配置异常处理、创建异常类、创建异常处理器类、测试应用。

34.5 Spring Boot的实际应用场景

在实际开发中，Spring Boot数据验证与异常处理的应用场景非常广泛，如：

  • 实现用户注册的数据验证。
  • 实现用户登录的数据验证。
  • 实现产品信息的数据验证。
  • 实现订单信息的数据验证。

示例：

import javax.validation.constraints.*;
class Product {
    private Long id;
    @NotBlank(message = "产品ID不能为空")
    @Size(min = 3, max = 10, message = "产品ID长度必须在3到10个字符之间")
    private String productId;
    @NotBlank(message = "产品名称不能为空")
    @Size(min = 2, max = 50, message = "产品名称长度必须在2到50个字符之间")
    private String productName;
    @Min(value = 0, message = "价格必须大于等于0")
    @Max(value = 10000, message = "价格必须小于等于10000")
    private double price;
    @Min(value = 0, message = "库存必须大于等于0")
    private int stock;
    public Product() {
    }
    public Product(Long id, String productId, String productName, double price, int stock) {
        this.id = id;
        this.productId = productId;
        this.productName = productName;
        this.price = price;
        this.stock = stock;
    }
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getProductId() {
        return productId;
    }
    public void setProductId(String productId) {
        this.productId = productId;
    }
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public int getStock() {
        return stock;
    }
    public void setStock(int stock) {
        this.stock = stock;
    }
    @Override
    public String toString() {
        return "Product{" +
                "id=" + id +
                ", productId='" + productId + '\'' +
                ", productName='" + productName + '\'' +
                ", price=" + price +
                ", stock=" + stock +
                '}';
    }
}
import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Repository
class ProductRepository {
    private List<Product> products = new ArrayList<>();
    public ProductRepository() {
        products.add(new Product(1L, "P001", "手机", 1000.0, 100));
        products.add(new Product(2L, "P002", "电脑", 5000.0, 50));
        products.add(new Product(3L, "P003", "电视", 3000.0, 80));
        products.add(new Product(4L, "P004", "手表", 500.0, 200));
        products.add(new Product(5L, "P005", "耳机", 300.0, 150));
    }
    public List<Product> getAllProducts() {
        return products;
    }
    public Product getProductById(Long id) {
        return products.stream().filter(product -> product.getId().equals(id)).findFirst().orElse(null);
    }
    public void addProduct(Product product) {
        product.setId((long) (products.size() + 1));
        products.add(product);
    }
    public void updateProduct(Product product) {
        Product existingProduct = getProductById(product.getId());
        if (existingProduct != null) {
            existingProduct.setProductId(product.getProductId());
            existingProduct.setProductName(product.getProductName());
            existingProduct.setPrice(product.getPrice());
            existingProduct.setStock(product.getStock());
        }
    }
    public void deleteProduct(Long id) {
        products.removeIf(product -> product.getId().equals(id));
    }
}
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
class ProductService {
    @Autowired
    private ProductRepository productRepository;
    public List<Product> getAllProducts() {
        return productRepository.getAllProducts();
    }
    public Product getProductById(Long id) {
        return productRepository.getProductById(id);
    }
    public void addProduct(Product product) {
        productRepository.addProduct(product);
    }
    public void updateProduct(Product product) {
        productRepository.updateProduct(product);
    }
    public void deleteProduct(Long id) {
        productRepository.deleteProduct(id);
    }
}
class ProductNotFoundException extends RuntimeException {
    public ProductNotFoundException(String message) {
        super(message);
    }
    public ProductNotFoundException(String message, Throwable cause) {
        super(message, cause);
    }
}
class ProductExistsException extends RuntimeException {
    public ProductExistsException(String message) {
        super(message);
    }
    public ProductExistsException(String message, Throwable cause) {
        super(message, cause);
    }
}
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import java.util.HashMap;
import java.util.Map;
@ControllerAdvice
class ProductExceptionHandler {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<Map<String, Object>> handleValidationExceptions(MethodArgumentNotValidException ex) {
        Map<String, Object> result = new HashMap<>();
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getFieldErrors().forEach(error -> {
            errors.put(error.getField(), error.getDefaultMessage());
        });
        result.put("success", false);
        result.put("errors", errors);
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(result);
    }
    @ExceptionHandler(ProductNotFoundException.class)
    public ResponseEntity<Map<String, Object>> handleProductNotFoundException(ProductNotFoundException ex) {
        Map<String, Object> result = new HashMap<>();
        result.put("success", false);
        result.put("message", ex.getMessage());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(result);
    }
    @ExceptionHandler(ProductExistsException.class)
    public ResponseEntity<Map<String, Object>> handleProductExistsException(ProductExistsException ex) {
        Map<String, Object> result = new HashMap<>();
        result.put("success", false);
        result.put("message", ex.getMessage());
        return ResponseEntity.status(HttpStatus.CONFLICT).body(result);
    }
    @ExceptionHandler(Exception.class)
    public ResponseEntity<Map<String, Object>> handleAllExceptions(Exception ex) {
        Map<String, Object> result = new HashMap<>();
        result.put("success", false);
        result.put("message", "系统错误：" + ex.getMessage());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(result);
    }
}
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("/api/products")
class ProductController {
    @Autowired
    private ProductService productService;
    @GetMapping("/")
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }
    @GetMapping("/{id}")
    public Product getProductById(@PathVariable Long id) {
        Product product = productService.getProductById(id);
        if (product == null) {
            throw new ProductNotFoundException("产品不存在：" + id);
        }
        return product;
    }
    @PostMapping("/add")
    public Map<String, Object> addProduct(@Valid @RequestBody Product product, BindingResult bindingResult) {
        Map<String, Object> result = new HashMap<>();
        if (bindingResult.hasErrors()) {
            Map<String, String> errors = new HashMap<>();
            for (FieldError error : bindingResult.getFieldErrors()) {
                errors.put(error.getField(), error.getDefaultMessage());
            }
            result.put("success", false);
            result.put("errors", errors);
            return result;
        }
        productService.addProduct(product);
        result.put("success", true);
        result.put("message", "产品添加成功");
        return result;
    }
    @PutMapping("/edit/{id}")
    public Map<String, Object> editProduct(@PathVariable Long id, @Valid @RequestBody Product product, BindingResult bindingResult) {
        Map<String, Object> result = new HashMap<>();
        if (bindingResult.hasErrors()) {
            Map<String, String> errors = new HashMap<>();
            for (FieldError error : bindingResult.getFieldErrors()) {
                errors.put(error.getField(), error.getDefaultMessage());
            }
            result.put("success", false);
            result.put("errors", errors);
            return result;
        }
        product.setId(id);
        productService.updateProduct(product);
        result.put("success", true);
        result.put("message", "产品更新成功");
        return result;
    }
    @DeleteMapping("/delete/{id}")
    public Map<String, Object> deleteProduct(@PathVariable Long id) {
        Map<String, Object> result = new HashMap<>();
        productService.deleteProduct(id);
        result.put("success", true);
        result.put("message", "产品删除成功");
        return result;
    }
}
@SpringBootApplication
public class ValidationAndExceptionApplication {
    public static void main(String[] args) {
        SpringApplication.run(ValidationAndExceptionApplication.class, args);
    }
}
// 测试类
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ValidationAndExceptionApplicationTests {
    @LocalServerPort
    private int port;
    @Autowired
    private TestRestTemplate restTemplate;
    @Test
    void contextLoads() {
    }
    @Test
    void testAddProduct() {
        Map<String, Object> product = new HashMap<>();
        product.put("productId", "P006");
        product.put("productName", "耳机");
        product.put("price", 300.0);
        product.put("stock", 150);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Map<String, Object>> request = new HttpEntity<>(product, headers);
        ResponseEntity<Map> response = restTemplate.exchange(
                "http://localhost:" + port + "/api/products/add",
                HttpMethod.POST,
                request,
                Map.class
        );
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(response.getBody().get("success")).isEqualTo(true);
    }
    @Test
    void testAddProductWithInvalidData() {
        Map<String, Object> product = new HashMap<>();
        product.put("productId", "P");
        product.put("productName", "");
        product.put("price", -100.0);
        product.put("stock", -10);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Map<String, Object>> request = new HttpEntity<>(product, headers);
        ResponseEntity<Map> response = restTemplate.exchange(
                "http://localhost:" + port + "/api/products/add",
                HttpMethod.POST,
                request,
                Map.class
        );
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
        assertThat(response.getBody().get("success")).isEqualTo(false);
        assertThat(response.getBody().get("errors")).isNotNull();
    }
    @Test
    void testGetProductById() {
        ResponseEntity<Product> response = restTemplate.getForEntity("http://localhost:" + port + "/api/products/1", Product.class);
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(response.getBody()).isNotNull();
    }
    @Test
    void testGetProductByIdNotFound() {
        ResponseEntity<Map> response = restTemplate.getForEntity("http://localhost:" + port + "/api/products/10", Map.class);
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
        assertThat(response.getBody().get("success")).isEqualTo(false);
        assertThat(response.getBody().get("message")).isNotNull();
    }
}

输出结果：

  • 访问http://localhost:8080/api/products/add：返回“产品添加成功”。
  • 访问http://localhost:8080/api/products/10：返回“产品不存在”。

✅ 结论：在实际开发中，Spring Boot数据验证与异常处理的应用场景非常广泛，需要根据实际问题选择合适的数据验证和异常处理方法。

总结

本章我们学习了Spring Boot数据验证与异常处理，包括数据验证的定义与特点、异常处理的定义与特点、Spring Boot与数据验证的集成、Spring Boot与异常处理的集成、Spring Boot的实际应用场景，学会了在实际开发中处理数据验证与异常处理问题。其中，数据验证的定义与特点、异常处理的定义与特点、Spring Boot与数据验证的集成、Spring Boot与异常处理的集成、Spring Boot的实际应用场景是本章的重点内容。从下一章开始，我们将学习Spring Boot的其他组件、微服务等内容。

到此这篇关于Spring Boot 数据验证与异常处理问题小结的文章就介绍到这了,更多相关Spring Boot 数据验证与异常处理内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Java冒泡排序简单实现

    Java冒泡排序简单实现

    这篇文章主要介绍了Java冒泡排序简单实现，具有一定借鉴价值，需要的朋友可以参考下。
    2017-12-12
  • SpringBoot接入轻量级分布式日志框架(GrayLog)的操作方法

    SpringBoot接入轻量级分布式日志框架(GrayLog)的操作方法

    这篇文章主要介绍了SpringBoot接入轻量级分布式日志框架（GrayLog）的方法，本文通过图文实例相结合给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2022-03-03
  • IntelliJ IDEA语法报错

    IntelliJ IDEA语法报错"Usage of API documented as @since 1.6+"的解决

    今天小编就为大家分享一篇关于IntelliJ IDEA语法报错"Usage of API documented as @since 1.6+"的解决办法，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
    2018-10-10
  • 详解Java编程规约（命名风格、常量定义、代码格式）

    详解Java编程规约（命名风格、常量定义、代码格式）

    这篇文章主要介绍了详解Java编程规约（命名风格、常量定义、代码格式），小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2019-10-10
  • JetCache的配置和注解属性的使用说明

    JetCache的配置和注解属性的使用说明

    本文详细介绍了JetCache的配置方法及各种注解的使用技巧,从YML配置文件入手,解析不同属性的作用与意义,并对@Cached、@CacheUpdate、@CacheInvalidate等注解进行了解,感兴趣的可以了解一下
    2025-10-10
  • 基于mybatis中test条件中单引号双引号的问题

    基于mybatis中test条件中单引号双引号的问题

    这篇文章主要介绍了基于mybatis中test条件中单引号双引号的问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-01-01
  • MyBatis 和 MyBatis-Plus从语法详解和优劣对比

    MyBatis 和 MyBatis-Plus从语法详解和优劣对比

    MyBatis和MyBatis-Plus是Java生态中常用的持久层框架,其中 MyBatis-Plus是在 MyBatis 基础上的增强工具,下面从语法详解和优劣对比两部分展开说明,感兴趣的朋友一起看看吧
    2025-07-07
  • java中的transient关键字解读

    java中的transient关键字解读

    这篇文章主要介绍了java中的transient关键字解读,transient关键字的主要作用就是让某些被transient关键字修饰的成员属性变量不被序列化,实际上也正是因此,在学习过程中很少用得上序列化操作,一般都是在实际开发中,需要的朋友可以参考下
    2023-09-09
  • 详解Spring中使用xml配置bean的细节

    详解Spring中使用xml配置bean的细节

    本篇文章主要介绍了Spring中使用xml配置bean的细节，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2017-06-06
  • Java中的Timer与TimerTask原理详解

    Java中的Timer与TimerTask原理详解

    这篇文章主要介绍了Java中的Timer与TimerTask原理详解,timerTask本身没什么意义，只是和timer集合操作的一个对象，实现它就必然有对应的run方法，以被调用，他甚至于根本不需要实现Runnable,需要的朋友可以参考下
    2023-07-07

最新评论