Spring Boot 4 Complete Guide · 강의

입력 검증 및 오류 처리

들어오는 요청의 데이터를 검증하고 견고한 오류 관리를 위한 전역 예외 처리기를 만듭니다.

입력 검증 및 오류 처리은(는) CoddyKit의 무료 Spring Boot 4 Complete Guide 강의입니다. 이것은 4개 중 3번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 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 not null.
@NotBlank: For strings, ensures it's not null and not just whitespace.
@NotEmpty: For strings, collections, or arrays, ensures it's not null and 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 @ControllerAdvice and @ExceptionHandler to create consistent, user-friendly error responses, especially for MethodArgumentNotValidException.

Next, explore how to handle other types of exceptions in your API!

자주 묻는 질문

“입력 검증 및 오류 처리” 강의는 무료인가요?

네 — “입력 검증 및 오류 처리” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Spring Boot 4 Complete Guide 강의 전체를 잠금 해제할 수 있습니다. Spring Boot 4 Complete Guide 강의에는 총 4개의 강의가 포함되어 있습니다.

“입력 검증 및 오류 처리”에서 뭘 배우나요?

들어오는 요청의 데이터를 검증하고 견고한 오류 관리를 위한 전역 예외 처리기를 만듭니다. 브라우저에서 직접 실행하는 실습 코드로 Spring Boot 4 Complete Guide을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Spring Boot 4 Complete Guide을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Spring Boot 4 Complete Guide은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 3번째 강의입니다.

“입력 검증 및 오류 처리” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 Spring Boot 4 Complete Guide 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 Spring Boot 4 Complete Guide 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← Spring Boot 4 Complete Guide(으)로 돌아가기