入力検証とエラーハンドリング
受信リクエストのデータ検証を実装し、堅牢なエラー管理のためのグローバル例外ハンドラーを作成します。
「入力検証とエラーハンドリング」はCoddyKit上の無料Spring Boot 4 Complete Guideレッスンです。 これはレッスン3/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはSpring Boot 4 Complete Guide学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Spring Boot 4 Complete Guideコースには全4レッスンが含まれています。
このレッスンの一部はまだ翻訳されておらず、英語で表示されています。
Why Validate API Inputs?
When building RESTful APIs, receiving data from clients is common. But what if that data isn't quite right?
Input validation is the process of ensuring that the data your API receives conforms to expected rules and formats before it's processed. It's crucial for:
- Data Integrity: Ensuring only valid data enters your system.
- Security: Preventing malicious inputs (like SQL injection or XSS).
- Reliability: Avoiding unexpected errors and crashes in your application.
Bean Validation Basics
Spring Boot makes validation easy by integrating with the Jakarta Bean Validation API (JSR 380). This standard provides a set of annotations you can use to define validation rules directly on your data objects.
When Spring processes a request with a validated object, it automatically checks these rules. If any rule is violated, it flags an error.
Common Validation Annotations
Here are some essential Bean Validation annotations you'll often use:
@NotNull: Ensures the field is notnull.@NotBlank: For strings, ensures it's notnulland not just whitespace.@NotEmpty: For strings, collections, or arrays, ensures it's notnulland has at least one element/character.@Size(min=X, max=Y): Checks if a string or collection's size is within a range.@Min(value)/@Max(value): Checks if a numeric value is within a range.@Email: Validates if a string is a well-formed email address.@Pattern(regexp): Validates a string against a regular expression.
Creating a Validated DTO
Let's define a simple ProductRequest Data Transfer Object (DTO) that an API might receive. We'll add several validation annotations to its fields.
This DTO represents the expected structure and rules for creating a new product.
package com.coddykit.dto;
import jakarta.validation.constraints.DecimalMin;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
public class ProductRequest {
@NotBlank(message = "Name cannot be empty")
@Size(min = 3, max = 50, message = "Name must be between 3 and 50 characters")
private String name;
@NotNull(message = "Price cannot be null")
@DecimalMin(value = "0.01", message = "Price must be greater than 0")
private Double price;
@NotBlank(message = "Description cannot be empty")
@Size(max = 200, message = "Description cannot exceed 200 characters")
private String description;
// Getters and Setters (omitted for brevity in snippet)
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; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
}Seeing Validation in Action
While Spring handles validation automatically in controllers, you can manually test the Bean Validation API. This program creates a ProductRequest and uses a Validator to check its rules.
Notice how violations are collected!
import com.coddykit.dto.ProductRequest;
import jakarta.validation.ConstraintViolation;
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;
import java.util.Set;
public class Main {
public static void main(String[] args) {
ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();
ProductRequest invalidProduct = new ProductRequest();
invalidProduct.setName(" "); // Too short, blank
invalidProduct.setPrice(-5.0); // Less than 0.01
invalidProduct.setDescription("Short");
Set<ConstraintViolation<ProductRequest>> violations =
validator.validate(invalidProduct);
if (!violations.isEmpty()) {
System.out.println("Validation Errors:");
for (ConstraintViolation<ProductRequest> violation : violations) {
System.out.println("- " + violation.getMessage());
}
} else {
System.out.println("Product is valid!");
}
}
}Spring Boot's @Valid Integration
In a Spring Boot controller, you activate validation by simply adding the @Valid (or @Validated) annotation to the request body parameter. Spring automatically applies the rules defined in your DTO.
If validation fails, Spring throws a MethodArgumentNotValidException.
package com.coddykit.controller;
import com.coddykit.dto.ProductRequest;
import jakarta.validation.Valid;
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.RestController;
@RestController
public class ProductController {
@PostMapping("/products")
public ResponseEntity<String> createProduct(@Valid @RequestBody ProductRequest productRequest) {
// If validation passes, this code executes
System.out.println("Received valid product: " + productRequest.getName());
return new ResponseEntity<>("Product created successfully!", HttpStatus.CREATED);
}
}Understanding Default Error Handling
When @Valid fails in a controller, Spring Boot's default error handling kicks in. It catches the MethodArgumentNotValidException and returns a 400 Bad Request HTTP status.
The default error response typically includes a detailed (and often verbose) JSON object with error messages, field names, and other technical details. While functional, it might not be the most user-friendly or consistent for your API consumers.
Customizing Error Responses
For a better API experience, you'll want to customize error responses. This means:
- Consistent Format: All errors look similar.
- Clear Messages: Easy for clients to understand.
- Relevant Details: Only provide necessary information.
Spring provides the @ControllerAdvice and @ExceptionHandler annotations to centralize and customize error handling across your entire application.
Building a Global Error Handler
The @ControllerAdvice annotation marks a class that can handle exceptions from any controller. Inside it, @ExceptionHandler methods specify which exceptions to catch and how to respond.
Here's how to create a simple global handler for validation errors, returning a list of specific field errors.
package com.coddykit.exception;
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.bind.annotation.ExceptionHandler;
import java.util.HashMap;
import java.util.Map;
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<Map<String, String>> 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);
});
return new ResponseEntity<>(errors, HttpStatus.BAD_REQUEST);
}
}Quick Check: Validation & Errors
Which of the following annotations are used to define validation rules for a string field in a DTO, ensuring it's not null, not empty, and has a minimum length?
Recap: Validation & Error Handling
You've learned how to make your Spring Boot APIs robust!
- Input Validation: Essential for data integrity and security, using the Jakarta Bean Validation API.
- Validation Annotations: Use
@NotBlank,@Size,@Min,@Max, etc., to define rules on your DTOs. @Valid: Triggers validation automatically in your controller methods.- Custom Error Handling: Use
@ControllerAdviceand@ExceptionHandlerto create consistent, user-friendly error responses, especially forMethodArgumentNotValidException.
Next, explore how to handle other types of exceptions in your API!
よくある質問
「入力検証とエラーハンドリング」レッスンは無料ですか？
はい。「入力検証とエラーハンドリング」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Spring Boot 4 Complete Guideコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Spring Boot 4 Complete Guideコースには全4レッスンが含まれています。
「入力検証とエラーハンドリング」で何を学びますか？
受信リクエストのデータ検証を実装し、堅牢なエラー管理のためのグローバル例外ハンドラーを作成します。 ブラウザで直接実行するハンズオンコードでSpring Boot 4 Complete Guideを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。
Spring Boot 4 Complete Guideを始めるのに経験は必要ですか？
事前経験は必要ありません。CoddyKitのSpring Boot 4 Complete Guideは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン3/4です。
「入力検証とエラーハンドリング」レッスンにはどのくらい時間がかかりますか？
ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。
このSpring Boot 4 Complete Guideレッスンでコードを書いて実行できますか？
はい。すべてのSpring Boot 4 Complete Guideレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。