Spring 폼 바인딩

package board.formbinding;

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

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

package board.formbinding;

import java.time.LocalDate;

import org.springframework.format.annotation.DateTimeFormat;

public final class CreatePostForm {
    private String title = "";
    private String content = "";

    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
    private LocalDate publishedOn;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public LocalDate getPublishedOn() {
        return publishedOn;
    }

    public void setPublishedOn(LocalDate publishedOn) {
        this.publishedOn = publishedOn;
    }
}

package board.formbinding;

import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;

@Component
public final class CreatePostFormValidator implements Validator {
    @Override
    public boolean supports(Class<?> type) {
        return CreatePostForm.class.isAssignableFrom(type);
    }

    @Override
    public void validate(Object target, Errors errors) {
        var form = (CreatePostForm) target;

        if (form.getTitle() == null || form.getTitle().isBlank()) {
            errors.rejectValue(
                    "title", "title.required", "제목을 입력하세요.");
        }
        if (form.getContent() == null || form.getContent().isBlank()) {
            errors.rejectValue(
                    "content", "content.required", "본문을 입력하세요.");
        }
        if (!errors.hasFieldErrors("publishedOn")
                && form.getPublishedOn() == null) {
            errors.rejectValue(
                    "publishedOn",
                    "publishedOn.required",
                    "작성일을 입력하세요.");
        }
    }
}

package board.formbinding;

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

public record CreatePostCommand(
        String title,
        String content,
        LocalDate publishedOn
) {
    public CreatePostCommand {
        Objects.requireNonNull(title, "title");
        Objects.requireNonNull(content, "content");
        Objects.requireNonNull(publishedOn, "publishedOn");
        if (title.isBlank() || content.isBlank()) {
            throw new IllegalArgumentException(
                    "validated command must not be blank");
        }
    }
}

package board.formbinding;

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

public record PostDetail(
        long id,
        String title,
        String content,
        LocalDate publishedOn
) {
    public PostDetail {
        if (id < 1) {
            throw new IllegalArgumentException("id must be positive");
        }
        Objects.requireNonNull(title, "title");
        Objects.requireNonNull(content, "content");
        Objects.requireNonNull(publishedOn, "publishedOn");
    }
}

package board.formbinding;

public interface PostApplicationService {
    long register(CreatePostCommand command);

    PostDetail findDetail(long id);
}

package board.formbinding;

import java.util.Arrays;

import jakarta.validation.Valid;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import org.springframework.web.servlet.support.ExtendedServletRequestDataBinder;

@Controller
public final class PostFormController {
    private final PostApplicationService service;
    private final CreatePostFormValidator validator;

    public PostFormController(
            PostApplicationService service,
            CreatePostFormValidator validator
    ) {
        this.service = service;
        this.validator = validator;
    }

    @InitBinder("form")
    void restrictFields(WebDataBinder binder) {
        binder.setAllowedFields("title", "content", "publishedOn");
        if (binder instanceof ExtendedServletRequestDataBinder servletBinder) {
            servletBinder.setHeaderPredicate(name -> false);
        }
        binder.addValidators(validator);
    }

    @GetMapping("/formbinding/posts/new")
    String createForm(Model model) {
        model.addAttribute("form", new CreatePostForm());
        return "formbinding/posts/new";
    }

    @GetMapping("/formbinding/posts/{id}")
    String detail(@PathVariable long id, Model model) {
        model.addAttribute("post", service.findDetail(id));
        return "formbinding/posts/detail";
    }

    @PostMapping("/formbinding/posts")
    String create(
            @Valid @ModelAttribute("form") CreatePostForm form,
            BindingResult bindingResult,
            RedirectAttributes redirectAttributes
    ) {
        rejectSuppressedFields(bindingResult);
        if (bindingResult.hasErrors()) {
            return "formbinding/posts/new";
        }

        long id = service.register(new CreatePostCommand(
                form.getTitle().strip(),
                form.getContent(),
                form.getPublishedOn()));
        redirectAttributes.addAttribute("id", id);
        redirectAttributes.addFlashAttribute(
                "notice", "게시글을 저장했습니다.");
        return "redirect:/formbinding/posts/{id}";
    }

    private static void rejectSuppressedFields(
            BindingResult bindingResult
    ) {
        var fields = bindingResult.getSuppressedFields();
        if (fields.length == 0) {
            return;
        }

        Arrays.sort(fields);
        bindingResult.reject(
                "binding.suppressed",
                "허용하지 않은 입력 필드: " + String.join(", ", fields));
    }
}

<!doctype html>
<html lang="ko" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="utf-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <title>게시글 등록</title>
</head>
<body>
  <main>
    <h1>게시글 등록</h1>

    <form th:action="@{/formbinding/posts}"
          th:object="${form}"
          method="post"
          novalidate>
      <div id="form-errors"
           role="alert"
           th:if="${#fields.hasGlobalErrors()}">
        <p th:each="error : ${#fields.globalErrors()}"
           th:text="${error}">폼 오류</p>
      </div>

      <div>
        <label for="title">제목</label>
        <input th:field="*{title}"
               th:attr="aria-invalid=${#fields.hasErrors('title')
                   ? 'true' : null},
                   aria-describedby=${#fields.hasErrors('title')
                   ? 'title-error' : null}" />
        <p id="title-error"
           role="alert"
           th:if="${#fields.hasErrors('title')}"
           th:errors="*{title}">제목 오류</p>
      </div>

      <div>
        <label for="content">본문</label>
        <textarea th:field="*{content}"
                  th:attr="aria-invalid=${#fields.hasErrors('content')
                      ? 'true' : null},
                      aria-describedby=${#fields.hasErrors('content')
                      ? 'content-error' : null}"></textarea>
        <p id="content-error"
           role="alert"
           th:if="${#fields.hasErrors('content')}"
           th:errors="*{content}">본문 오류</p>
      </div>

      <div>
        <label for="publishedOn">작성일</label>
        <input type="date"
               th:field="*{publishedOn}"
               th:attr="aria-invalid=${#fields.hasErrors('publishedOn')
                   ? 'true' : null},
                   aria-describedby=${#fields.hasErrors('publishedOn')
                   ? 'publishedOn-error' : null}" />
        <p id="publishedOn-error"
           role="alert"
           th:if="${#fields.hasErrors('publishedOn')}"
           th:errors="*{publishedOn}">작성일 오류</p>
      </div>

      <button type="submit">저장</button>
    </form>
  </main>
</body>
</html>

<!doctype html>
<html lang="ko" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="utf-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <title>게시글 상세</title>
</head>
<body>
  <main th:attr="data-post-id=${post.id}">
    <p role="status" th:if="${notice}"
       th:text="${notice}">저장 알림</p>
    <article>
      <h1 th:text="${post.title}">게시글 제목</h1>
      <p th:text="${post.content}">게시글 본문</p>
      <time th:attr="datetime=${post.publishedOn}"
            th:text="${post.publishedOn}">2026-08-20</time>
    </article>
    <a th:href="@{/formbinding/posts/new}">새 게시글</a>
  </main>
</body>
</html>

package board.formbinding;

import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.flash;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.model;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.redirectedUrl;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.view;

import java.nio.charset.StandardCharsets;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.context.annotation.Bean;
import org.springframework.test.web.servlet.MockMvc;

@SpringBootTest(classes = {
        FormBindingApplication.class,
        PostFormBindingTest.FixtureConfiguration.class
})
@AutoConfigureMockMvc
class PostFormBindingTest {
    @Autowired
    MockMvc mvc;

    @Autowired
    RecordingPostApplicationService service;

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

    @Test
    void GET_폼은_존재하지_않는_오류_id를_참조하지_않는다()
            throws Exception {
        var result = mvc.perform(get("/formbinding/posts/new"))
                .andExpect(status().isOk())
                .andExpect(view().name("formbinding/posts/new"))
                .andReturn();
        var document = parse(result.getResponse()
                .getContentAsString(StandardCharsets.UTF_8));

        assertThat(document.select("[aria-invalid=true], [aria-describedby]"))
                .isEmpty();
        assertThat(document.select("label[for]").stream()
                .allMatch(label -> document.getElementById(
                        label.attr("for")) != null))
                .isTrue();
    }

    @Test
    void 잘못된_날짜는_거부값과_접근가능한_field_error를_보존한다()
            throws Exception {
        var result = mvc.perform(post("/formbinding/posts")
                        .param("title", "Spring MVC")
                        .param("content", "바인딩 과정을 기록합니다.")
                        .param("publishedOn", "날짜아님"))
                .andExpect(status().isOk())
                .andExpect(view().name("formbinding/posts/new"))
                .andExpect(model().attributeHasFieldErrors(
                        "form", "publishedOn"))
                .andReturn();
        var document = parse(result.getResponse()
                .getContentAsString(StandardCharsets.UTF_8));
        var input = document.selectFirst("#publishedOn");

        assertThat(input.attr("value")).isEqualTo("날짜아님");
        assertThat(input.attr("aria-invalid")).isEqualTo("true");
        assertThat(input.attr("aria-describedby"))
                .isEqualTo("publishedOn-error");
        assertThat(document.selectFirst("#publishedOn-error").text())
                .isNotBlank();
        assertThat(service.commands()).isEmpty();
    }

    @Test
    void 억제된_필드는_객체_오류가_되어_service를_막는다()
            throws Exception {
        var result = mvc.perform(post("/formbinding/posts")
                        .param("title", "Spring MVC")
                        .param("content", "허용 필드만 저장합니다.")
                        .param("publishedOn", "2026-08-20")
                        .param("approved", "true"))
                .andExpect(status().isOk())
                .andExpect(view().name("formbinding/posts/new"))
                .andExpect(model().attributeHasErrors("form"))
                .andReturn();
        var document = parse(result.getResponse()
                .getContentAsString(StandardCharsets.UTF_8));

        assertThat(document.selectFirst("#form-errors").text())
                .contains("approved");
        assertThat(service.commands()).isEmpty();
    }

    @Test
    void 실제_custom_validator가_공백_제목을_거부한다()
            throws Exception {
        mvc.perform(post("/formbinding/posts")
                        .param("title", "   ")
                        .param("content", "본문")
                        .param("publishedOn", "2026-08-20"))
                .andExpect(status().isOk())
                .andExpect(model().attributeHasFieldErrors(
                        "form", "title"));

        assertThat(service.commands()).isEmpty();
    }

    @Test
    void 유효한_요청은_redirect를_follow해_상세_HTML을_렌더링한다()
            throws Exception {
        var redirect = mvc.perform(post("/formbinding/posts")
                        .param("title", "  Spring MVC  ")
                        .param("content", "검증 뒤 명령을 만듭니다.")
                        .param("publishedOn", "2026-08-20"))
                .andExpect(status().is3xxRedirection())
                .andExpect(redirectedUrl("/formbinding/posts/41"))
                .andExpect(flash().attribute(
                        "notice", "게시글을 저장했습니다."))
                .andReturn();

        assertThat(service.commands()).containsExactly(
                new CreatePostCommand(
                        "Spring MVC",
                        "검증 뒤 명령을 만듭니다.",
                        LocalDate.of(2026, 8, 20)));

        var detail = mvc.perform(get(redirect.getResponse()
                        .getRedirectedUrl())
                        .flashAttrs(redirect.getFlashMap()))
                .andExpect(status().isOk())
                .andExpect(view().name("formbinding/posts/detail"))
                .andExpect(model().attribute("post", new PostDetail(
                        41L,
                        "Spring MVC",
                        "검증 뒤 명령을 만듭니다.",
                        LocalDate.of(2026, 8, 20))))
                .andReturn();
        var document = parse(detail.getResponse()
                .getContentAsString(StandardCharsets.UTF_8));

        assertThat(document.selectFirst("main").attr("data-post-id"))
                .isEqualTo("41");
        assertThat(document.selectFirst("h1").text())
                .isEqualTo("Spring MVC");
        assertThat(document.selectFirst("[role=status]").text())
                .isEqualTo("게시글을 저장했습니다.");
        assertThat(document.selectFirst("time").attr("datetime"))
                .isEqualTo("2026-08-20");
    }

    private static Document parse(String html) {
        return Jsoup.parse(html);
    }

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

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

        @Override
        public PostDetail findDetail(long id) {
            if (id != 41L || commands.isEmpty()) {
                throw new IllegalArgumentException("post not found: " + id);
            }
            var command = commands.get(commands.size() - 1);
            return new PostDetail(
                    id,
                    command.title(),
                    command.content(),
                    command.publishedOn());
        }

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

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

    @TestConfiguration(proxyBeanMethods = false)
    static class FixtureConfiguration {
        @Bean
        RecordingPostApplicationService postApplicationService() {
            return new RecordingPostApplicationService();
        }
    }
}