바인딩 오류 처리

package board.bindingerrors;

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;
    private boolean publicVisible;

    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;
    }

    public boolean isPublicVisible() {
        return publicVisible;
    }

    public void setPublicVisible(boolean publicVisible) {
        this.publicVisible = publicVisible;
    }
}

package board.bindingerrors;

import java.time.LocalDate;

public record CreatePostCommand(
        String title,
        String content,
        LocalDate publishedOn,
        boolean publicVisible
) {}

package board.bindingerrors;

public interface PostApplicationService {
    void register(CreatePostCommand command);
}

package board.bindingerrors;

import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;

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

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

    @InitBinder("form")
    void configureFormBinder(WebDataBinder binder) {
        binder.setAllowedFields(
                "title", "content", "publishedOn", "publicVisible");
        binder.addValidators(validator);
    }

    @PostMapping("/b88/binding-errors/posts")
    String register(
            @Validated @ModelAttribute("form") CreatePostForm form,
            BindingResult result
    ) {
        if (result.hasErrors()) {
            return "binding-errors/new";
        }
        service.register(new CreatePostCommand(
                form.getTitle().strip(),
                form.getContent(),
                form.getPublishedOn(),
                form.isPublicVisible()));
        return "redirect:/b88/binding-errors/posts";
    }
}

package board.bindingerrors;

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",
                    "post.title.required",
                    "제목을 입력하세요.");
        } else if (characterCount(form.getTitle()) > 80) {
            errors.rejectValue(
                    "title",
                    "post.title.length",
                    new Object[]{80},
                    "제목은 80자 이하여야 합니다.");
        }

        if (!errors.hasFieldErrors("content")) {
            String content = form.getContent();
            if (content == null || content.isBlank()) {
                errors.rejectValue(
                        "content",
                        "post.content.required",
                        "본문을 입력하세요.");
            } else if (characterCount(content) > 720) {
                errors.rejectValue(
                        "content",
                        "post.content.length",
                        new Object[]{720},
                        "본문은 720자 이하여야 합니다.");
            }
        }

        if (!errors.hasFieldErrors("content")
                && form.getContent() != null
                && form.isPublicVisible()
                && characterCount(form.getContent()) < 25) {
            errors.reject(
                    "post.publicVisible.minimum",
                    new Object[]{25},
                    "공개 게시글의 본문은 25자 이상이어야 합니다.");
        }
    }

    private int characterCount(String value) {
        String stripped = value.strip();
        return stripped.codePointCount(0, stripped.length());
    }
}

<!doctype html>
<html lang="ko" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="utf-8" />
  <title>게시글 등록</title>
</head>
<body>
  <main>
    <h1>게시글 등록</h1>
    <form th:action="@{/b88/binding-errors/posts}"
          th:object="${form}" method="post"
          th:attr="aria-describedby=${#fields.hasGlobalErrors()} ? 'global-error-detail' : null">
      <section id="error-summary"
               th:if="${#fields.hasAnyErrors()}"
               role="alert"
               aria-labelledby="error-summary-title"
               aria-describedby="error-summary-count"
               tabindex="-1">
        <h2 id="error-summary-title">입력 내용을 확인하세요</h2>
        <p id="error-summary-count"
           th:text="|${#fields.allErrors().size()}개의 오류가 있습니다.|">
          오류가 있습니다.
        </p>
        <ul id="global-error-detail"
            th:if="${#fields.hasGlobalErrors()}">
          <li th:each="error : ${#fields.globalErrors()}"
              th:text="${error}">오류 내용</li>
        </ul>
      </section>

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

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

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

      <label>
        <input type="checkbox" th:field="*{publicVisible}" />
        다른 회원에게 공개
      </label>
      <button type="submit">등록</button>
    </form>
  </main>
</body>
</html>

package board.bindingerrors;

import static org.assertj.core.api.Assertions.assertThat;

import org.junit.jupiter.api.Test;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.format.support.DefaultFormattingConversionService;
import org.springframework.validation.DataBinder;

class CreatePostFormValidatorTest {
    @Test
    void 제목과_본문_field_error를_함께_보존한다() {
        var form = new CreatePostForm();
        var binder = binderFor(form);
        var values = new MutablePropertyValues();
        values.add("title", "   ");
        values.add("content", "a".repeat(721));
        values.add("publishedOn", "2026-08-28");

        binder.bind(values);
        binder.validate();
        var result = binder.getBindingResult();

        assertThat(result.getFieldError("content").getCode())
                .isEqualTo("post.content.length");
        assertThat(result.getFieldError("title").getCode())
                .isEqualTo("post.title.required");
        assertThat(result.getErrorCount()).isEqualTo(2);
    }

    @Test
    void 공개_본문의_최소_길이는_object_error로_남는다() {
        var form = new CreatePostForm();
        var binder = binderFor(form);
        var values = new MutablePropertyValues();
        values.add("title", "Spring MVC");
        values.add("content", "짧지만 비어 있지 않은 본문");
        values.add("publicVisible", "true");

        binder.bind(values);
        binder.validate();
        var result = binder.getBindingResult();

        assertThat(result.hasFieldErrors()).isFalse();
        assertThat(result.getGlobalError().getCode())
                .isEqualTo("post.publicVisible.minimum");
    }

    @Test
    void 날짜_conversion_실패는_원문과_typeMismatch를_보존한다() {
        var form = new CreatePostForm();
        var binder = binderFor(form);
        var values = new MutablePropertyValues();
        values.add("title", "Spring MVC");
        values.add("content", "공개하지 않는 정상 길이의 게시글 본문입니다.");
        values.add("publishedOn", "날짜아님");

        binder.bind(values);
        binder.validate();
        var error = binder.getBindingResult()
                .getFieldError("publishedOn");

        assertThat(error.getCode()).isEqualTo("typeMismatch");
        assertThat(error.getRejectedValue()).isEqualTo("날짜아님");
    }

    @Test
    void 길이_규칙은_보조_평면_문자를_code_point_하나로_센다() {
        var accepted = new CreatePostForm();
        accepted.setTitle("😀".repeat(80));
        accepted.setContent("😀".repeat(25));
        accepted.setPublicVisible(true);
        var acceptedBinder = binderFor(accepted);

        acceptedBinder.validate();

        assertThat(acceptedBinder.getBindingResult().hasErrors()).isFalse();

        var rejected = new CreatePostForm();
        rejected.setTitle("😀".repeat(81));
        rejected.setContent("정상 본문");
        var rejectedBinder = binderFor(rejected);

        rejectedBinder.validate();

        assertThat(rejectedBinder.getBindingResult()
                .getFieldError("title").getCode())
                .isEqualTo("post.title.length");
    }

    @Test
    void field_error가_있으면_object_error를_중복하지_않는다() {
        var form = new CreatePostForm();
        form.setContent(" ");
        form.setPublicVisible(true);
        var binder = binderFor(form);
        binder.validate();
        var result = binder.getBindingResult();

        assertThat(result.getFieldError("content").getCode())
                .isEqualTo("post.content.required");
        assertThat(result.hasGlobalErrors()).isFalse();
    }

    @Test
    void validator는_form_type만_지원한다() {
        var validator = new CreatePostFormValidator();

        assertThat(validator.supports(CreatePostForm.class)).isTrue();
        assertThat(validator.supports(String.class)).isFalse();
    }

    private DataBinder binderFor(CreatePostForm form) {
        var binder = new DataBinder(form, "form");
        binder.setConversionService(new DefaultFormattingConversionService());
        binder.addValidators(new CreatePostFormValidator());
        return binder;
    }
}

package board.bindingerrors;

import java.util.ArrayList;
import java.util.List;

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

    @Override
    public void register(CreatePostCommand command) {
        commands.add(command);
    }

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

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

package board.bindingerrors;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;

@SpringBootConfiguration(proxyBeanMethods = false)
@EnableAutoConfiguration
@Import({
        ValidatedPostController.class,
        CreatePostFormValidator.class
})
public class BindingErrorsTestApplication {
    @Bean
    MvcRecordingPostApplicationService postApplicationService() {
        return new MvcRecordingPostApplicationService();
    }
}

package board.bindingerrors;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
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 org.jsoup.Jsoup;
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.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.validation.BindingResult;

@SpringBootTest(classes = BindingErrorsTestApplication.class)
@AutoConfigureMockMvc
class ValidatedPostMvcTest {
    private static final String ROUTE = "/b88/binding-errors/posts";

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private MvcRecordingPostApplicationService service;

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

    @Test
    void 실제_MVC는_binder_validation_오류를_렌더하고_service를_건너뛴다()
            throws Exception {
        var result = mockMvc.perform(post(ROUTE)
                        .param("title", " ")
                        .param("content", "짧은 본문")
                        .param("publishedOn", "28-08-2026")
                        .param("publicVisible", "true")
                        .param("admin", "true"))
                .andExpect(status().isOk())
                .andExpect(view().name("binding-errors/new"))
                .andReturn();
        var modelAndView = result.getModelAndView();
        assertThat(modelAndView).isNotNull();
        var binding = (BindingResult) modelAndView.getModel().get(
                BindingResult.MODEL_KEY_PREFIX + "form");
        var document = Jsoup.parse(
                result.getResponse().getContentAsString(UTF_8));

        assertThat(binding).isNotNull();
        assertThat(binding.getFieldError("title").getCode())
                .isEqualTo("post.title.required");
        assertThat(binding.getFieldError("publishedOn").getCode())
                .isEqualTo("typeMismatch");
        assertThat(binding.getGlobalError().getCode())
                .isEqualTo("post.publicVisible.minimum");
        assertThat(binding.getSuppressedFields()).containsExactly("admin");
        assertThat(service.commands()).isEmpty();
        assertThat(document.select(
                "#error-summary[role=alert][tabindex=-1]"
                        + "[aria-describedby=error-summary-count]"))
                .hasSize(1);
        assertThat(document.select(
                "form[aria-describedby=global-error-detail]"))
                .hasSize(1);
        assertThat(document.select("#global-error-detail li").eachText())
                .containsExactly(
                        "공개 게시글의 본문은 25자 이상이어야 합니다.");
        assertThat(document.select("#title-error")).hasSize(1);
        assertThat(document.select("#publishedOn-error")).hasSize(1);
        assertThat(document.select(
                "#publishedOn[value=28-08-2026]"))
                .hasSize(1);
    }

    @Test
    void ISO_날짜와_code_point_최소_길이는_검증된_command로_전달된다()
            throws Exception {
        String content = "😀".repeat(25);

        mockMvc.perform(post(ROUTE)
                        .param("title", " Spring MVC ")
                        .param("content", content)
                        .param("publishedOn", "2026-08-28")
                        .param("publicVisible", "true"))
                .andExpect(status().is3xxRedirection())
                .andExpect(redirectedUrl(ROUTE));

        assertThat(service.commands()).containsExactly(new CreatePostCommand(
                "Spring MVC",
                content,
                java.time.LocalDate.of(2026, 8, 28),
                true));
    }
}