게시판 웹 등록·조회

implementation 'org.springframework.boot:spring-boot-starter-validation'

package board.web;

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

public record CreatePostRequest(
        @NotBlank @Size(max = 50) String authorId,
        @NotBlank @Size(max = 80) String title,
        @NotBlank @Size(max = 720) String content,
        @NotNull LocalDate publishedOn
) {
    public CreatePostRequest {
        authorId = stripIfPresent(authorId);
        title = stripIfPresent(title);
        content = stripIfPresent(content);
    }

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

    private static String stripIfPresent(String value) {
        return value == null ? null : value.strip();
    }
}

package board.web;

import java.time.LocalDate;
import board.domain.Post;

public record PostResponse(
        long id,
        String authorId,
        String title,
        String content,
        LocalDate publishedOn
) {
    static PostResponse from(Post post) {
        return new PostResponse(
                post.id(),
                post.authorId(),
                post.title(),
                post.content(),
                post.publishedOn());
    }
}

package board.web;

import jakarta.validation.Valid;
import java.net.URI;
import java.util.List;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
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;
import board.application.PostService;

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

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

    @PostMapping
    public ResponseEntity<PostResponse> register(
            @Valid @RequestBody CreatePostRequest request
    ) {
        var saved = service.register(request.toCommand());
        var location = URI.create("/api/posts/" + saved.id());
        return ResponseEntity.created(location)
                .body(PostResponse.from(saved));
    }

    @GetMapping("/{id}")
    public PostResponse find(@PathVariable("id") long id) {
        return PostResponse.from(service.find(id));
    }

    @GetMapping
    public List<PostResponse> findAll() {
        return service.findAll().stream()
                .map(PostResponse::from)
                .toList();
    }
}

curl -i -X POST http://localhost:8080/api/posts \
  -H "Content-Type: application/json" \
  -d '{"authorId":"member-1","title":"Spring MVC","content":"DispatcherServlet이 요청을 컨트롤러에 연결합니다.","publishedOn":"2026-07-13"}'

HTTP/1.1 201
Location: /api/posts/1
Content-Type: application/json

{"id":1,"authorId":"member-1","title":"Spring MVC","content":"DispatcherServlet이 요청을 컨트롤러에 연결합니다.","publishedOn":"2026-07-13"}

package board.web;

import java.net.URI;
import java.util.Locale;
import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import board.application.DuplicatePostException;
import board.application.PostNotFoundException;

@RestControllerAdvice
public final class ApiExceptionHandler {
    @ExceptionHandler(PostNotFoundException.class)
    ProblemDetail notFound(PostNotFoundException exception) {
        return problem(HttpStatus.NOT_FOUND, "POST_NOT_FOUND",
                exception.getMessage());
    }

    @ExceptionHandler(DuplicatePostException.class)
    ProblemDetail duplicate(DuplicatePostException exception) {
        return problem(HttpStatus.CONFLICT, "POST_DUPLICATE",
                exception.getMessage());
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    ProblemDetail invalidRequest(
            MethodArgumentNotValidException exception
    ) {
        return problem(HttpStatus.BAD_REQUEST, "INVALID_POST",
                "request validation failed");
    }

    @ExceptionHandler(IllegalArgumentException.class)
    ProblemDetail invalidPost(IllegalArgumentException exception) {
        return problem(HttpStatus.BAD_REQUEST, "INVALID_POST",
                exception.getMessage());
    }

    private ProblemDetail problem(
            HttpStatus status,
            String code,
            String detail
    ) {
        var problem = ProblemDetail.forStatusAndDetail(status, detail);
        problem.setType(URI.create(
                "https://andongmin.com/problems/"
                        + code.toLowerCase(Locale.ROOT)
                        .replace('_', '-')));
        problem.setTitle(status.getReasonPhrase());
        problem.setProperty("code", code);
        return problem;
    }
}

HTTP/1.1 404
Content-Type: application/problem+json

{
  "detail": "post not found: 999",
  "instance": "/api/posts/999",
  "status": 404,
  "title": "Not Found",
  "type": "https://andongmin.com/problems/post-not-found",
  "code": "POST_NOT_FOUND"
}

package board.web;

import java.time.Clock;
import java.time.Instant;
import java.time.ZoneOffset;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.client.RestTestClient;
import board.application.PostService;
import board.infrastructure.MemoryPostRepository;

class PostControllerTest {
    private RestTestClient client;

    @BeforeEach
    void setUp() {
        var clock = Clock.fixed(
                Instant.parse("2026-07-13T09:00:00Z"),
                ZoneOffset.UTC);
        var service = new PostService(
                new MemoryPostRepository(), clock);
        var controller = new PostController(service);

        client = RestTestClient.bindToController(controller)
                .configureServer(builder ->
                        builder.setControllerAdvice(
                                new ApiExceptionHandler()))
                .build();
    }

    @Test
    void 등록하고_Location으로_조회한다() {
        client.post()
                .uri("/api/posts")
                .contentType(MediaType.APPLICATION_JSON)
                .body("""
                        {
                          "authorId": "member-1",
                          "title": "Spring MVC",
                          "content": "DispatcherServlet이 요청을 컨트롤러에 연결합니다.",
                          "publishedOn": "2026-07-13"
                        }
                        """)
                .exchange()
                .expectStatus().isCreated()
                .expectHeader().valueEquals(
                        "Location", "/api/posts/1")
                .expectBody()
                .jsonPath("$.id").isEqualTo(1)
                .jsonPath("$.title").isEqualTo("Spring MVC");

        client.get()
                .uri("/api/posts/1")
                .exchange()
                .expectStatus().isOk()
                .expectBody()
                .jsonPath("$.content").isEqualTo(
                        "DispatcherServlet이 요청을 컨트롤러에 연결합니다.");
    }

    @Test
    void 없는_게시글은_404_problem_detail을_반환한다() {
        client.get()
                .uri("/api/posts/999")
                .exchange()
                .expectStatus().isNotFound()
                .expectHeader().contentType(
                        MediaType.APPLICATION_PROBLEM_JSON)
                .expectBody()
                .jsonPath("$.code").isEqualTo("POST_NOT_FOUND");
    }

    @Test
    void 공백_content는_400_problem_detail을_반환한다() {
        client.post()
                .uri("/api/posts")
                .contentType(MediaType.APPLICATION_JSON)
                .body("""
                        {
                          "authorId": "member-1",
                          "title": "Spring MVC",
                          "content": "   ",
                          "publishedOn": "2026-07-13"
                        }
                        """)
                .exchange()
                .expectStatus().isBadRequest()
                .expectHeader().contentType(
                        MediaType.APPLICATION_PROBLEM_JSON)
                .expectBody()
                .jsonPath("$.code").isEqualTo("INVALID_POST")
                .jsonPath("$.detail").isEqualTo(
                        "request validation failed")
                .jsonPath("$.instance").isEqualTo("/api/posts");
    }
}