요청 본문·JSON 변환

rootProject.name = 'json-request-body'

plugins { id 'java' }

java { toolchain { languageVersion = JavaLanguageVersion.of(25) } }

repositories { mavenCentral() }

dependencies {
    implementation platform('org.springframework.boot:spring-boot-dependencies:4.1.2')
    implementation 'org.springframework.boot:spring-boot-starter-webmvc'
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    testImplementation platform('org.springframework.boot:spring-boot-dependencies:4.1.2')
    testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
    options.release = 25
    options.compilerArgs += ['-parameters']
}

tasks.named('test') { useJUnitPlatform() }

spring.jackson.deserialization.fail-on-unknown-properties=true
spring.jackson.factory.constraints.read.max-document-length=8192
spring.jackson.factory.constraints.read.max-nesting-depth=20
spring.jackson.factory.constraints.read.max-string-length=1000

package board;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

package board.post;

import java.time.LocalDate;
import java.util.Objects;

public record CreatePostCommand(String title, String content, LocalDate publishedOn) {
    public CreatePostCommand {
        requireText(title, 120, "title");
        requireText(content, 720, "content");
        Objects.requireNonNull(publishedOn, "publishedOn");
    }

    private static void requireText(String value, int maxLength, String name) {
        Objects.requireNonNull(value, name);
        if (value.isBlank() || value.length() > maxLength) {
            throw new IllegalArgumentException(name + " is invalid");
        }
    }
}

package board.post;

@FunctionalInterface
public interface PostService {
    long register(CreatePostCommand command);
}

package board.web;

import board.post.CreatePostCommand;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.PastOrPresent;
import jakarta.validation.constraints.Size;
import java.time.LocalDate;

public record CreatePostRequest(
        @NotBlank @Size(max = 120) String title,
        @NotBlank @Size(max = 720) String content,
        @NotNull @PastOrPresent LocalDate publishedOn) {

    public CreatePostCommand toCommand() {
        return new CreatePostCommand(title, content, publishedOn);
    }
}

package board.web;

import board.post.PostService;
import jakarta.validation.Valid;
import java.net.URI;
import org.springframework.http.MediaType;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/posts")
public final class PostRegistrationController {
    private final PostService service;

    public PostRegistrationController(PostService service) {
        this.service = service;
    }

    @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Void> register(@Valid @RequestBody CreatePostRequest request) {
        var postId = service.register(request.toCommand());
        return ResponseEntity.created(URI.create("/api/posts/" + postId)).build();
    }
}

package board.web;

public record FieldProblem(String field, String code) {}

package board.web;

import java.util.Comparator;
import java.util.Objects;
import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.validation.FieldError;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import tools.jackson.core.exc.StreamConstraintsException;
import tools.jackson.databind.exc.InvalidFormatException;
import tools.jackson.databind.exc.UnrecognizedPropertyException;

@RestControllerAdvice
public final class ApiInputExceptionHandler {
    @ExceptionHandler(HttpMessageNotReadableException.class)
    public ResponseEntity<ProblemDetail> unreadable(HttpMessageNotReadableException failure) {
        var code = unreadableCode(failure);
        var problem = problem(HttpStatus.BAD_REQUEST, "Request JSON could not be read", code);
        return ResponseEntity.badRequest().body(problem);
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ProblemDetail> invalidFields(
            MethodArgumentNotValidException failure) {
        var fields = failure.getBindingResult().getFieldErrors().stream()
                .sorted(Comparator.comparing(FieldError::getField)
                        .thenComparing(error -> Objects.requireNonNullElse(error.getCode(), "")))
                .map(error -> new FieldProblem(
                        error.getField(), Objects.requireNonNullElse(error.getCode(), "Invalid")))
                .toList();
        var problem = problem(
                HttpStatus.BAD_REQUEST, "Request fields are invalid", "REQUEST_INVALID");
        problem.setProperty("fields", fields);
        return ResponseEntity.badRequest().body(problem);
    }

    @ExceptionHandler(HttpMediaTypeNotSupportedException.class)
    public ResponseEntity<ProblemDetail> unsupportedMediaType(
            HttpMediaTypeNotSupportedException failure) {
        var problem = problem(
                failure.getStatusCode(), "Content-Type is not supported", "MEDIA_TYPE_UNSUPPORTED");
        return ResponseEntity.status(failure.getStatusCode())
                .headers(failure.getHeaders())
                .body(problem);
    }

    private static String unreadableCode(HttpMessageNotReadableException failure) {
        if (failure.contains(StreamConstraintsException.class)) {
            return "JSON_LIMIT_EXCEEDED";
        }
        if (failure.contains(UnrecognizedPropertyException.class)) {
            return "JSON_PROPERTY_UNKNOWN";
        }
        if (failure.contains(InvalidFormatException.class)) {
            return "JSON_VALUE_INVALID";
        }
        return "JSON_NOT_READABLE";
    }

    private static ProblemDetail problem(
            org.springframework.http.HttpStatusCode status, String detail, String code) {
        var problem = ProblemDetail.forStatusAndDetail(status, detail);
        problem.setProperty("code", code);
        return problem;
    }
}

package board.web;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE;

import board.post.CreatePostCommand;
import board.post.PostService;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.resttestclient.autoconfigure.AutoConfigureRestTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.JacksonJsonHttpMessageConverter;
import org.springframework.test.web.servlet.client.RestTestClient;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import tools.jackson.core.exc.StreamConstraintsException;
import tools.jackson.databind.DeserializationFeature;
import tools.jackson.databind.json.JsonMapper;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureRestTestClient
@Import(JsonRequestBodyTest.TestBeans.class)
class JsonRequestBodyTest {
    @Autowired
    private RestTestClient client;

    @Autowired
    private JsonMapper mapper;

    @Autowired
    private RequestMappingHandlerAdapter handlerAdapter;

    @Autowired
    private RecordingPostService service;

    @BeforeEach
    void resetService() {
        service.reset();
    }

    @Test
    void boot_매퍼와_MVC_컨버터가_같은_읽기_설정을_사용한다() {
        var converters = handlerAdapter.getMessageConverters().stream()
                .filter(JacksonJsonHttpMessageConverter.class::isInstance)
                .map(JacksonJsonHttpMessageConverter.class::cast)
                .toList();
        assertThat(converters).hasSize(1);
        assertThat(converters.getFirst().getMapper()).isSameAs(mapper);

        var constraints = mapper.tokenStreamFactory().streamReadConstraints();
        assertThat(constraints.getMaxDocumentLength()).isEqualTo(8192L);
        assertThat(constraints.getMaxNestingDepth()).isEqualTo(20);
        assertThat(constraints.getMaxStringLength()).isEqualTo(1000);
        assertThat(mapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)).isTrue();
        assertThatThrownBy(() -> mapper.readTree(nestedObject(21)))
                .isInstanceOf(StreamConstraintsException.class);
    }

    @Test
    void valid_JSON은_명령으로_한_번_매핑된다() {
        client.post()
                .uri("/api/posts")
                .contentType(APPLICATION_JSON)
                .body(requestJson("Jackson이 JSON 본문을 DTO로 변환합니다."))
                .exchange()
                .expectStatus().isCreated()
                .expectHeader().valueEquals(HttpHeaders.LOCATION, "/api/posts/42");

        assertThat(service.commands()).containsExactly(new CreatePostCommand(
                "JSON binding", "Jackson이 JSON 본문을 DTO로 변환합니다.",
                LocalDate.of(2025, 5, 1)));
    }

    @Test
    void malformed_JSON과_본문_부재는_읽기_오류다() {
        expectBadRequest("{\"title\":\"broken\"", "JSON_NOT_READABLE");

        client.post()
                .uri("/api/posts")
                .contentType(APPLICATION_JSON)
                .exchange()
                .expectStatus().isBadRequest()
                .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
                .expectBody()
                .jsonPath("$.code").isEqualTo("JSON_NOT_READABLE");
        assertThat(service.commands()).isEmpty();
    }

    @Test
    void invalid_date는_값_변환_오류다() {
        expectBadRequest("""
                {
                  "title": "JSON binding",
                  "content": "date",
                  "publishedOn": "not-a-date"
                }
                """, "JSON_VALUE_INVALID");
    }

    @Test
    void content_누락_null_빈값_공백은_필드_검증_오류다() {
        var requests = List.of(
                """
                {"title":"JSON binding","publishedOn":"2025-05-01"}
                """,
                """
                {"title":"JSON binding","content":null,"publishedOn":"2025-05-01"}
                """,
                requestJson(""),
                requestJson("   "));

        for (var request : requests) {
            expectInvalidContent(request);
        }
    }

    @Test
    void content_720은_통과하고_721은_거부된다() {
        client.post()
                .uri("/api/posts")
                .contentType(APPLICATION_JSON)
                .body(requestJson("x".repeat(720)))
                .exchange()
                .expectStatus().isCreated();
        assertThat(service.commands()).hasSize(1);

        service.reset();
        expectInvalidContent(requestJson("x".repeat(721)));
    }

    @Test
    void 미래_날짜는_필드_검증_오류다() {
        expectBadRequest("""
                {
                  "title": "JSON binding",
                  "content": "future",
                  "publishedOn": "2999-01-01"
                }
                """, "REQUEST_INVALID");
    }

    @Test
    void unknown_field는_엄격하게_거부된다() {
        var requests = List.of(
                """
                {
                  "title": "JSON binding",
                  "content": "strict",
                  "publishedOn": "2025-05-01",
                  "contents": "typo"
                }
                """,
                """
                {
                  "title": "JSON binding",
                  "content": "strict",
                  "publishedOn": "2025-05-01",
                  "admin": true
                }
                """);

        for (var request : requests) {
            expectBadRequest(request, "JSON_PROPERTY_UNKNOWN");
        }
    }

    @Test
    void text_plain은_415이고_지원_Content_Type을_알린다() {
        client.post()
                .uri("/api/posts")
                .contentType(MediaType.TEXT_PLAIN)
                .body("title=wrong-format")
                .exchange()
                .expectStatus().isEqualTo(415)
                .expectHeader().valueEquals(HttpHeaders.ACCEPT, APPLICATION_JSON_VALUE)
                .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
                .expectBody()
                .jsonPath("$.code").isEqualTo("MEDIA_TYPE_UNSUPPORTED");
        assertThat(service.commands()).isEmpty();
    }

    @Test
    void 긴_JSON_문자열은_파서_읽기_한계에서_거부된다() {
        expectBadRequest(requestJson("x".repeat(4096)), "JSON_LIMIT_EXCEEDED");
    }

    @Test
    void 애플리케이션_명령도_핵심_불변식을_지킨다() {
        assertThatThrownBy(() -> new CreatePostCommand(
                "JSON binding", "   ", LocalDate.of(2025, 5, 1)))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("content is invalid");
    }

    private void expectInvalidContent(String json) {
        client.post()
                .uri("/api/posts")
                .contentType(APPLICATION_JSON)
                .body(json)
                .exchange()
                .expectStatus().isBadRequest()
                .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
                .expectBody()
                .jsonPath("$.code").isEqualTo("REQUEST_INVALID")
                .jsonPath("$.fields[0].field").isEqualTo("content");
        assertThat(service.commands()).isEmpty();
    }

    private void expectBadRequest(String json, String code) {
        client.post()
                .uri("/api/posts")
                .contentType(APPLICATION_JSON)
                .body(json)
                .exchange()
                .expectStatus().isBadRequest()
                .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
                .expectBody()
                .jsonPath("$.code").isEqualTo(code);
        assertThat(service.commands()).isEmpty();
    }

    private static String requestJson(String content) {
        return """
                {
                  "title": "JSON binding",
                  "content": "%s",
                  "publishedOn": "2025-05-01"
                }
                """.formatted(content);
    }

    private static String nestedObject(int depth) {
        return "{\"value\":".repeat(depth) + "0" + "}".repeat(depth);
    }

    @TestConfiguration(proxyBeanMethods = false)
    static class TestBeans {
        @Bean
        RecordingPostService postService() {
            return new RecordingPostService();
        }
    }

    static final class RecordingPostService implements PostService {
        private final List<CreatePostCommand> commands = new ArrayList<>();

        @Override
        public long register(CreatePostCommand command) {
            commands.add(command);
            return 42L;
        }

        List<CreatePostCommand> commands() {
            return List.copyOf(commands);
        }

        void reset() {
            commands.clear();
        }
    }
}