0Pricing
Spring Boot 4 Microservices & REST APIs · 课时

请求与响应验证

为传入请求实现数据验证，并统一错误响应的格式。

请求与响应验证 是 CoddyKit 上的免费 Spring Boot 4 Microservices & REST APIs 课时。 这是第 1 节课，共 3 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Spring Boot 4 Microservices & REST APIs 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Spring Boot 4 Microservices & REST APIs 课程共包含 3 节课。

本课时的部分内容尚未翻译，以英文显示。

Why Validate Requests?

When building REST APIs, clients send data to your server. This data often needs to meet certain rules, like a field not being empty, or a number being within a specific range.

  • Data Integrity: Ensures your database stores only valid information.
  • Security: Prevents malicious or malformed data from causing issues.
  • User Experience: Provides clear, immediate feedback to clients when their input is incorrect.

Validation is crucial for robust and reliable APIs.

Spring's Validation Tools

Spring Boot makes data validation easy by integrating with the Jakarta Bean Validation API (JSR 380). You'll primarily use the @Valid annotation in your controller methods.

Common validation annotations include:

  • @NotNull: Field must not be null.
  • @NotBlank: String must not be null and must contain at least one non-whitespace character.
  • @Size(min=X, max=Y): String or collection size must be within range.
  • @Min(X), @Max(Y): Numeric value must be within range.
  • @Email: String must be a valid email format.

Data Transfer Objects (DTOs)

For incoming request bodies, it's best practice to use a Data Transfer Object (DTO). A DTO is a simple Java class that mirrors the structure of the data you expect from the client.

You apply validation annotations directly to the fields within your DTO. This keeps your controller clean and separates validation logic from business logic.

Implementing Basic Validation

Let's create a ProductRequest DTO with some validation rules and use it in a Spring Boot controller. The @Valid annotation triggers the validation.

Try sending a request with an empty name or a price less than 1.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Min;

// DTO for product creation request
class ProductRequest {
    @NotBlank
    private String name;
    @Min(1)
    private double price;

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
}

@RestController
@RequestMapping("/api/products")
class ProductController {

    @PostMapping
    public String createProduct(@Valid @RequestBody ProductRequest productRequest) {
        // If validation passes, process the product request
        return "Product '" + productRequest.getName() + 
               "' with price " + productRequest.getPrice() + 
               " created successfully!";
    }
}

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

Customizing Error Messages

The default validation error messages can sometimes be generic. You can provide your own custom messages for each annotation to make them more user-friendly and specific to your application.

Just add the message attribute to the validation annotation, like this: @NotBlank(message="Product name is required").

Custom Message Example

Let's update our ProductRequest DTO to include custom error messages. This helps clients understand exactly what went wrong with their input.

Run this and try the previous invalid inputs again. You should see your custom messages.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Min;

// DTO for product creation request with custom messages
class ProductRequest {
    @NotBlank(message = "Product name cannot be empty")
    private String name;
    @Min(value = 1, message = "Product price must be at least 1")
    private double price;

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
}

@RestController
@RequestMapping("/api/products")
class ProductController {

    @PostMapping
    public String createProduct(@Valid @RequestBody ProductRequest productRequest) {
        return "Product '" + productRequest.getName() + 
               "' with price " + productRequest.getPrice() + 
               " created successfully!";
    }
}

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

Handling Validation Exceptions

When validation fails, Spring automatically throws a MethodArgumentNotValidException. By default, Spring handles this by returning an HTTP 400 Bad Request status with a simple error body.

However, for a consistent API, you'll want to customize this error response. This means catching the exception and formatting the response in a structured way, often with specific error codes or details.

Global Error Handler

To provide a uniform error response across your entire API, you can use a Global Error Handler. This is typically a class annotated with @ControllerAdvice.

Inside this class, you define methods annotated with @ExceptionHandler to catch specific exception types, like MethodArgumentNotValidException, and return a custom ResponseEntity.

Error Handling in Action

Here's how to create a global error handler that catches validation exceptions and returns a structured JSON error response. This improves API consistency and makes error handling easier for clients.

Run this code and try sending an invalid product request. Observe the structured error response.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.*;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Min;
import org.springframework.validation.FieldError;

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

// DTO for product creation request
class ProductRequest {
    @NotBlank(message = "Product name cannot be empty")
    private String name;
    @Min(value = 1, message = "Product price must be at least 1")
    private double price;

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
}

// Custom Error Response DTO
class ErrorResponse {
    private int status;
    private String message;
    private Map<String, String> errors;

    public ErrorResponse(int status, String message, Map<String, String> errors) {
        this.status = status;
        this.message = message;
        this.errors = errors;
    }

    // Getters
    public int getStatus() { return status; }
    public String getMessage() { return message; }
    public Map<String, String> getErrors() { return errors; }
}

@RestController
@RequestMapping("/api/products")
class ProductController {

    @PostMapping
    public String createProduct(@Valid @RequestBody ProductRequest productRequest) {
        return "Product '" + productRequest.getName() + 
               "' with price " + productRequest.getPrice() + 
               " created successfully!";
    }
}

@ControllerAdvice
class GlobalExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public ResponseEntity<ErrorResponse> handleValidationExceptions(
            MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getAllErrors().forEach((error) -> {
            String fieldName = ((FieldError) error).getField();
            String errorMessage = error.getDefaultMessage();
            errors.put(fieldName, errorMessage);
        });
        ErrorResponse errorResponse = new ErrorResponse(
            HttpStatus.BAD_REQUEST.value(), 
            "Validation failed", 
            errors
        );
        return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
    }
}

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

Validation Quick Check

Consider a DTO field: @Size(min = 5, max = 10, message = "Length must be between 5 and 10") String code;

Which input for code would cause a validation error?

Recap: Validation & Errors

In this lesson, you learned how to implement robust request validation in Spring Boot and provide consistent error responses.

  • We used @Valid and standard bean validation annotations like @NotBlank and @Min with DTOs.
  • You saw how to customize validation error messages.
  • We implemented a @ControllerAdvice global error handler to catch MethodArgumentNotValidException and return structured, user-friendly error responses.

Well done! Consistent validation and error handling are key for a professional API.

常见问题解答

「请求与响应验证」课时是免费的吗？

是的 — 「请求与响应验证」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Spring Boot 4 Microservices & REST APIs 课程的其余内容，请升级到 CoddyKit PRO。 Spring Boot 4 Microservices & REST APIs 课程共包含 3 节课。

「请求与响应验证」这节课中我会学到什么？

为传入请求实现数据验证，并统一错误响应的格式。 你通过在浏览器中直接运行的动手代码来练习 Spring Boot 4 Microservices & REST APIs，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Spring Boot 4 Microservices & REST APIs 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Spring Boot 4 Microservices & REST APIs 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 1 节课，共 3 节。

「请求与响应验证」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Spring Boot 4 Microservices & REST APIs 课中编写并运行代码吗？

能。每节 Spring Boot 4 Microservices & REST APIs 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 请求与响应验证
  2. 分页与排序
  3. REST 的 HATEOAS 原则
← 返回 Spring Boot 4 Microservices & REST APIs