java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Spring Boot 数据验证与异常处理

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

作者：星辰徐哥

本文给大家介绍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();
    }
}

输出结果：

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

总结

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

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

您可能感兴趣的文章:
阅读全文