[Spring] BindingResult를 활용해서 검증 로직 추가하기, MessageCodesResolver 알아보기

김영한 님의 '스프링 MVC 2편 - 백엔드 웹 개발 활용 기술'을 보고 정리한 글입니다 😊

스프링 MVC 2편 - 백엔드 웹 개발 활용 기술 - 인프런 | 강의

---

- 지난 포스팅과 이어집니다 :D

[Spring] 메시지와 국제화를 통해 언어 설정 커스텀하기

---

 

| 검증 추가하기

- 지난 포스팅의 상품 관리 시스템의 각 필드에 대한 검증 요구사항이 추가되었다.

- 가격, 수량에 문자가 들어가면 오류 

- 상품명은 필수로 

- 가격은 1,000~1,000,000 이내의 값

- 수량은 최대 9999개까지

- 가격 * 수량의 값은 항상 10,000 이상이도록

 

- 만약, 검증에 실패한 경우 검증 오류 결과를 포함하여 상품 등록 폼에 전달해주자.

[SItemController.java]

@Controller
@RequestMapping("/basic/items")
@RequiredArgsConstructor
public class SItemController {
    private final SItemService service;

    @GetMapping
    public String items(Model model) {
        List<SItem> items = service.findAllItem();
        model.addAttribute("items", items);
        model.addAttribute("userName", "Spring");
        return "basic/items";
    }

    @GetMapping("/{itemId}")
    public String item(@PathVariable Long itemId, Model model) {
        SItem item = service.findByItemId(itemId);
        model.addAttribute("item", item);
        return "basic/item";
    }

    @GetMapping("/add")
    public String addForm(Model model) {
        model.addAttribute("item", new SItem());
        return "basic/addForm";
    }

    @PostMapping("/add")
    public String addItemV2 (@ModelAttribute("item") SItem item, Model model, RedirectAttributes redirectAttributes) {
        // 검증 오류 메시지 저장
        Map<String, String> errors = service.verifyItemInfo(item);

        if(!errors.isEmpty()) {
            model.addAttribute("errors", errors);
            return "basic/addForm";
        }

        SItem savedItem = service.saveItem(item);
        redirectAttributes.addAttribute("itemId", savedItem.getId());
        redirectAttributes.addAttribute("status", true);
        return "redirect:/basic/items/{itemId}";
    }

    @GetMapping("/{itemId}/edit")
    public String editForm(@PathVariable Long itemId, Model model) {
        SItem item = service.findByItemId(itemId);
        model.addAttribute("item", item);
        return "basic/editForm";
    }

    @PostMapping("/{itemId}/edit")
    public String edit(@PathVariable Long itemId, SItem item, Model model) {
        service.updateItem(itemId, item);
        model.addAttribute("item", item);
        return "redirect:/basic/items/{itemId}";
    }


    @ModelAttribute("regions")
    public Map<String, String> regions() {
        Map<String, String> regions = new LinkedHashMap<>();
        regions.put("SEOUL", "서울");
        regions.put("BUSAN", "부산");
        regions.put("JEJU", "제주");
        return regions;
    }

    @ModelAttribute("itemTypes")
    public SItemType[] itemTypes() {
        return SItemType.values();
    }

    @ModelAttribute("deliveryCodes")
    public List<DeliveryCode> deliveryCodes() {
        return CreateDeliveryCode.getCodes();
    }

    @NoArgsConstructor
    static class CreateDeliveryCode {
        private static final List<DeliveryCode> deliveryCodes
                = Arrays.asList(new DeliveryCode("FAST", "빠른 배송"),
                                new DeliveryCode("NORMAL", "일반 배송"),
                                new DeliveryCode("SLOW", "느린 배송"));


        public static List<DeliveryCode> getCodes() {
            return deliveryCodes;
        }
    }

    // 테스트 데이터 추가 (의존관계 주입 이후 실행)
    @PostConstruct
    public void init() {
        service.saveItem(new SItem("itemA", 10000, 10));
        service.saveItem(new SItem("itemB", 20000, 20));
    }
}

- 우선, 전반적으로 Controller -> Repository로 바로 접근하게 하지 않고 Service단을 추가로 두었다.

- addForm에 검증 로직이 추가되었다. 만약 오류 메시지가 존재한다면 model에 error를 담아 전달하였다.

 

[SItemService.java]

@Service
@RequiredArgsConstructor
public class SItemService {
    private final SItemRepository repository;

    public List<SItem> findAllItem() {
        return repository.findAll();
    }

    public SItem findByItemId(Long itemId) {
        return repository.findById(itemId);
    }

    public Map<String, String> verifyItemInfo(SItem item) {
        Map<String, String> errors = new ConcurrentHashMap<>();
        if(!StringUtils.hasText(item.getItemName())) {
            errors.put("itemName", "상품 이름은 필수로 입력해주세요.");
        }
        if(item.getPrice() == null || item.getPrice() < 1000 || item.getPrice() > 1000000) {
            errors.put("price", "가격은 1,000~1,000,000원까지 허용됩니다.");
        }
        if(item.getQuantity() == null || item.getQuantity() >= 10000) {
            errors.put("quantity", "수량은 최대 9,999개까지 허용됩니다.");
        }
        if(item.getPrice() != null && item.getQuantity() != null) {
            int resultPrice = item.getPrice() * item.getQuantity();
            if(resultPrice < 10000) {
                errors.put("globalError", "총액(가격*수량)은 10,000원 이상이어야 합니다. 현재 금액 = " + resultPrice + "원");
            }
        }
        return errors;
    }

    public SItem saveItem(SItem item) {
        return repository.save(item);
    }

    public void updateItem(Long itemId, SItem item) {
        repository.update(itemId, item);
    }
}

- verifyItemInfo가 바로 검증 로직이다.

- 요구사항에 맞게 각각을 검증한 다음, 에러 메시지를 Map에 담아 리턴해주었다.

 

[addForm.html]

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <link href="../css/bootstrap.min.css"
          th:href="@{/css/bootstrap.min.css}"
          rel="stylesheet">
    <title>Item Save Form</title>
    <style>
        .field-error{
            border-color:#dc3545;
            color:#dc3545;
        }
    </style>
</head>
<body>
<div class="container">
    <div class="mt-5 py-2 text-center">
        <h2 th:text="#{page.addItem}" class="font-monospace fw-bold">Item Save Form</h2>
    </div>

    <form action="item.html" th:action th:object="${item}" method="post">
        <div th:if="${errors?.containsKey('globalError')}">
            <p class="field-error text-center" th:text="${errors['globalError']}">
                전체 오류 메시지</p>
        </div>

        <div class="row fw-bold font-monospace">
            <div class="col text-center">
                <label for="itemName"
                       th:text="#{label.item.itemName}">Name</label>
                <input type="text"
                       th:field="*{itemName}"
                       th:class="${errors?.containsKey('itemName')} ? 'form-control text-center field-error' : 'text-center form-control'"
                       class="form-control text-center"
                       placeholder="Please Enter an Item Name.">
                <div class="field-error"
                     th:if="${errors?.containsKey('itemName')}"
                     th:text="${errors['itemName']}">
                    상품명 오류
                </div>
            </div>
        </div>

        <div class="row mt-2 fw-bold font-monospace">
            <div class="col text-center">
                <label for="price"
                       th:text="#{label.item.price}">Price</label>
                <input type="text"
                       th:field="*{price}"
                       th:class="${errors?.containsKey('price')} ? 'form-control text-center field-error' : 'text-center form-control'"
                       class="form-control text-center"
                       placeholder="Please Enter an Item Price.">
                <div class="field-error"
                     th:if="${errors?.containsKey('price')}"
                     th:text="${errors['price']}">
                    가격 오류
                </div>
            </div>
            <div class="col text-center">
                <label for="quantity"
                       th:text="#{label.item.quantity}">Quantity</label>
                <input type="text"
                       th:field="*{quantity}"
                       th:class="${errors?.containsKey('quantity')} ? 'form-control text-center field-error' : 'text-center form-control'"
                       class="form-control text-center"
                       placeholder="Please Enter an Item Quantity.">
                <div class="field-error"
                     th:if="${errors?.containsKey('quantity')}"
                     th:text="${errors['quantity']}">
                    수량 오류
                </div>
            </div>
        </div>
        ...
    </form>
</div>
</body>
</html>

- 변경 후 다음과 같이 메시지가 출력된다.

- 또한, 페이지가 넘어가지 않고 다시 saveForm이 나오는 것이다.

- 또한, 위의 코드에서 한 가지 발견할 수 있는 점이 있는데 errors?.containsKey('globalError')}이다.

여기서 ?을 써준 이유는 errors가 생성되지 않았을 때 내부 메서드인 .containsKey를 호출하면 NPE가 뜨기 때문!

(왜냐면 errors는 사용자가 제출을 했을 때 검증 로직을 돌면서 생기니까)

- 이를 방지하기 위해 errors가 null이라면 null을 반환하도록 처리하였다. 어차피 th:if에서 null이 들어가면 실패니까.

 

✔ 나중에 참고할 SpringEL 문법 모음

Core Technologies

 

- 기본 검증은 완료했다. 이제, 타입 오류를 처리해보자.

- 현재는 잘못된 타입을 넣으면 컨트롤러 진입 이전에 오류가 발생하기 때문에 별다른 처리가 불가능하다.

- 우리는 이를 위해 스프링에서 제공하는 검증 방법을 이용해볼 것이다.

 

[SItemController.java] - 수정

@PostMapping("/add")
public String addItemV2 (@ModelAttribute("item") SItem item, BindingResult bindingResult,
                         RedirectAttributes redirectAttributes) {

    if (!StringUtils.hasText(item.getItemName())) {
        bindingResult.addError(new FieldError("item", "itemName", "상품 이름은 필수로 입력해주세요."));
    }

    if (item.getPrice() == null || item.getPrice() < 1000 || item.getPrice() > 1000000) {
        bindingResult.addError(new FieldError("item", "price", "가격은 1,000~1,000,000원까지 허용됩니다."));
    }

    if (item.getQuantity() == null || item.getQuantity() >= 10000) {
        bindingResult.addError(new FieldError("item", "quantity", "수량은 최대 9,999개까지 허용됩니다."));
    }

    //특정 필드 예외가 아닌 전체 예외
    if (item.getPrice() != null && item.getQuantity() != null) {
        int resultPrice = item.getPrice() * item.getQuantity();
        if (resultPrice < 10000) {
            bindingResult.addError(new ObjectError("item", "총액(가격*수량)은 10,000원 이상이어야 합니다. 현재 금액 = " + resultPrice + "원"));
        }
    }

    if (bindingResult.hasErrors()) {
        return "basic/addForm";
    }

    SItem savedItem = service.saveItem(item);
    redirectAttributes.addAttribute("itemId", savedItem.getId());
    redirectAttributes.addAttribute("status", true);
    return "redirect:/basic/items/{itemId}";
}

코드를 수정해주었다.

⭐ 여기서 BindingResult는 @ModelAttribute 어노테이션이 붙은 객체 다음에 위치해야 한다!

FieldError에는 순차적으로 objectName, field, defaultMessage가 들어간다.

objectName에는 @ModelAttribute의 이름, field는 오류가 발생한 필드의 이름, defaultMessage는 오류 메시지이다.

ObjectError에는 여러 필드에 대한 오류 검증 시 사용한다. field를 생략할 수 있다. 관련해서는 뒤에서 더 설명하겠다.

 

[addForm.html]

<form action="item.html" th:action th:object="${item}" method="post">
    <div th:if="${#fields.hasGlobalErrors()}">
        <p class="field-error text-center"
           th:each="err: ${#fields.globalErrors()}"
           th:text="${err}">
            전체 오류 메시지</p>
    </div>

    <div class="row fw-bold font-monospace">
        <div class="col text-center">
            <label for="itemName"
                   th:text="#{label.item.itemName}">Name</label>
            <input type="text"
                   th:field="*{itemName}"
                   th:errorclass="field-error"
                   class="form-control text-center"
                   placeholder="Please Enter an Item Name.">
            <div class="field-error"
                 th:errors="*{itemName}">
                상품명 오류
            </div>
        </div>
    </div>

    <div class="row mt-2 fw-bold font-monospace">
        <div class="col text-center">
            <label for="price"
                   th:text="#{label.item.price}">Price</label>
            <input type="text"
                   th:field="*{price}"
                   th:errorclass="field-error"
                   class="form-control text-center"
                   placeholder="Please Enter an Item Price.">
            <div class="field-error"
                 th:errors="*{price}">
                가격 오류
            </div>
        </div>
        <div class="col text-center">
            <label for="quantity"
                   th:text="#{label.item.quantity}">Quantity</label>
            <input type="text"
                   th:field="*{quantity}"
                   th:errorclass ="field-error"
                   class="form-control text-center"
                   placeholder="Please Enter an Item Quantity.">
            <div class="field-error"
                 th:errors="*{quantity}">
                수량 오류
            </div>
        </div>
    </div>
    ...

- BIndingResult가 제공하는 오류는 #fields로 접근이 가능하다.

- th:each="err: ${#fields.globalErrors()} -> 글로벌 에러가 있는지 boolean 값으로 반환한다. 있다면 반복.

    - 여기서, 글로벌 오류란 form과 관련된 오류로, #fields를 통해 접근이 가능하다.

    - 모든 오류를 확인하고 싶다면 allErrors()를 사용해도 된다.

- th:errors를 이용해 필드 단위로 오류가 있을 경우 태그 출력을 결정할 수 있다. (th:if와 같은 느낌)

     - th:errors="*{itemName}": bindingResult에 담긴 field 값 중 'ItemName'에 error가 있는지 확인.

- th:errorclass를 통해서 th:field에서 지정한 필드에 오류가 있다면 class 정보를 추가할 수 있다.

 

---

| BindingResult

- @ModelAttribute에 바인딩 시 오류가 발생했을 때 BindingResult에 오류 정보를 저장한다.

- ⭐ 만약 BindingResult가 없다면 400 오류가 발생하고, 컨트롤러 호출 없이 바로 오류 페이지로 이동한다.

- 우리의 코드처럼 직접 작성하거나, 작성하지 않으면 스프링이 직접 FieldErro를 만든다.

- 혹은, Validator를 사용하는 방법도 있다.

 

- 참고로, BindingResult는 Errors를 상속받고 있기 때문에, Errors를 대신 사용해도 된다.

- 그러나, BindingResult가 addError 같은 부가 기능을 좀 더 제공한다.

 

- 우리가 짠 코드에서 조금 더 발전시켜, 잘못된 값을 입력하더라도 값이 남아있도록 해보자.

@PostMapping("/add")
public String addItemV2 (@ModelAttribute("item") SItem item, BindingResult bindingResult,
                         RedirectAttributes redirectAttributes) {

    if (!StringUtils.hasText(item.getItemName())) {
        bindingResult.addError(new FieldError("item", "itemName", item.getItemName(), false,
                null, null, "상품 이름은 필수로 입력해주세요."));
    }

    if (item.getPrice() == null || item.getPrice() < 1000 || item.getPrice() > 1000000) {
        bindingResult.addError(new FieldError("item", "price", item.getPrice(), false,
                null, null, "가격은 1,000~1,000,000원까지 허용됩니다."));
    }

    if (item.getQuantity() == null || item.getQuantity() > 10000) {
        bindingResult.addError(new FieldError("item", "quantity", item.getQuantity(), false,
                null, null, "수량은 최대 9,999개까지 허용됩니다."));
    }

    //특정 필드 예외가 아닌 전체 예외
    if (item.getPrice() != null && item.getQuantity() != null) {
        int resultPrice = item.getPrice() * item.getQuantity();
        if (resultPrice < 10000) {
            bindingResult.addError(new ObjectError("item", null, null,
                    "총액(가격*수량)은 10,000원 이상이어야 합니다. 현재 금액 = " + resultPrice + "원"));
        }
    }

    if (bindingResult.hasErrors()) {
        return "basic/addForm";
    }

    SItem savedItem = service.saveItem(item);
    redirectAttributes.addAttribute("itemId", savedItem.getId());
    redirectAttributes.addAttribute("status", true);
    return "redirect:/basic/items/{itemId}";
}

FieldError의 파라미터가 많아진 것을 볼 수 있다. 

objectName (오류가 발생한 객체 이름 - @ModelAttribute 이름)

field (오류 필드)

rejectedValue (사용자가 입력한 값)

bindingFailure (검증 실패 시 구분 값 - boolean으로 구분)

codes: 메시지 코드

arguments: 메시지에서 사용하는 인자

defaultMessage: 기본 오류 메시지

 

bindingFailure의 경우, 타입 오류 같은 바인딩 실패라면 true, 검증 실패면 false를 넣는다.

우리는 rejectedValue를 통해 사용자가 입력한 값을 저장해둘 수 있다!

🚩 타임리프의 th:field를 사용하면 오류 발생 시 FieldError에서 보관한 값을 사용한다!

 

errorCode는 오류 발생 시 오류 코드를 통해 메시지를 찾을 수 있다.

우리는 errors.properties라는 파일로 관리를 해보자.

 

이때, application.properties에 다음을 추가해준다.

spring.messages.basename=messages,errors

이러면 둘 다 인식이 가능하다. (디폴트는 messages)

 

[errors.properties]

required.item.itemName=Please enter the product name as required.
range.item.price=Prices range from KRW {0} to KRW {1}.
max.item.quantity=Up to {0} quantities are allowed.
totalPriceMin=The total amount (price*quantity) must be at least KRW {0}! Current amount is KRW {1}

[errors_ja.properties]

required.item.itemName=必要に応じて製品名を入力してください。
range.item.price=価格は{0}ウォン~{1}ウォンです。
max.item.quantity=最大{0}個まで許可されます
totalPriceMin=合計金額(価格*数量)が{0}ウォン以上である必要があります。現在の金額は{1}ウォンです。

 

[SItemController.java] - 수정

@PostMapping("/add")
public String addItemV2 (@ModelAttribute("item") SItem item, BindingResult bindingResult,
                         RedirectAttributes redirectAttributes) {

    if (!StringUtils.hasText(item.getItemName())) {
        bindingResult.addError(new FieldError("item", "itemName", item.getItemName(), false,
                new String[]{"required.item.itemName"}, null, null));
    }

    if (item.getPrice() == null || item.getPrice() < 1000 || item.getPrice() > 1000000) {
        bindingResult.addError(new FieldError("item", "price", item.getPrice(), false,
                new String[]{"range.item.price"}, new Object[]{1000, 1000000},null));
    }

    if (item.getQuantity() == null || item.getQuantity() > 10000) {
        bindingResult.addError(new FieldError("item", "quantity", item.getQuantity(), false,
                new String[]{"max.item.quantity"}, new Object[]{9999}, null));
    }

    //특정 필드 예외가 아닌 전체 예외
    if (item.getPrice() != null && item.getQuantity() != null) {
        int resultPrice = item.getPrice() * item.getQuantity();
        if (resultPrice < 10000) {
            bindingResult.addError(new ObjectError("item", new String[]{"totalPriceMin"}, new Object[]{10000, resultPrice}, null));
        }
    }

    if (bindingResult.hasErrors()) {
        return "basic/addForm";
    }

    SItem savedItem = service.saveItem(item);
    redirectAttributes.addAttribute("itemId", savedItem.getId());
    redirectAttributes.addAttribute("status", true);
    return "redirect:/basic/items/{itemId}";
}

- 프로퍼티에 설정한 값을 가져올 수 있도록 다음과 같이 변경한다.

- new String[]{"range.item.price"}, new Object[]{1000, 1000000}

- 순서대로 codes와 arguments 자리에 넣어주면 된다.

- 돌려보면 국제화까지 잘 적용되는 것을 볼 수 있다.

(포스팅에는 담지 않았는데, 동일한 방법으로 Item Status나 Delivery 같은 것도 국제화 처리를 진행해주었다!)

 

- 하지만, 개발자가 항상 FieldError와 ObjectError의 내부 요소를 직접 입력하는 건 상당히 귀찮다.

- bindingResult의 내부 요소 -> .getObjectName(),.getTarget()을 해보면, 이미 bindingResult는 검증해야 하는 객체를 알고 있다.

- 또한, .rejectValue(), reject()를 사용하면 더 편리하게 검증 오류를 다룰 수 있다.

 

[SItemController.java] - 수정

@PostMapping("/add")
public String addItemV2 (@ModelAttribute("item") SItem item, BindingResult bindingResult,
                         RedirectAttributes redirectAttributes) {

    if (!StringUtils.hasText(item.getItemName())) {
        bindingResult.rejectValue("itemName", "required");
    }

    if (item.getPrice() == null || item.getPrice() < 1000 || item.getPrice() > 1000000) {
        bindingResult.rejectValue("price", "range", new Object[]{1000, 1000000},null);
    }

    if (item.getQuantity() == null || item.getQuantity() >= 10000) {
        bindingResult.rejectValue("quantity", "max", new Object[]{9999}, null);
    }

    //특정 필드 예외가 아닌 전체 예외
    if (item.getPrice() != null && item.getQuantity() != null) {
        int resultPrice = item.getPrice() * item.getQuantity();
        if (resultPrice < 10000) {
            bindingResult.reject("totalPriceMin", new Object[]{10000, resultPrice}, null);
        }
    }

    if (bindingResult.hasErrors()) {
        return "basic/addForm";
    }

    SItem savedItem = service.saveItem(item);
    redirectAttributes.addAttribute("itemId", savedItem.getId());
    redirectAttributes.addAttribute("status", true);
    return "redirect:/basic/items/{itemId}";
}

bindingResult의 rejectValue를 살펴보자.

 

field : 오류 필드명

errorCode : 오류 코드 (메시지 코드 x)

errorArgs : 오류 메시지에서 매개변수 값

defaultMessage: 기본 오류 메시지

 

BindingResult는 이미 target을 알고 있기 때문에, objectName을 작성하지 않아도 된다.

 

또한, 기존에는 required.item.itemName라고 작성했던 것을 이번에는 itemName이라고 축약하여 작성하였다.

이는 MessageCodesResolver 덕분이다.

 

MessageCodesResolver는 인터페이스고, 구현체인 DefaultMessageCodesResolver를 사용할 수 있다.

 

---

| MessageCodesResolver

✔ resolveMessageCodes()

- resolveMessageCodes(errorCode, objectName)

- resolveMessageCodes(errorCode, objectName, field, fieldType)

: 파라미터로 들어온 정보롤 활용해서 메시지 코드를 생성한다.

 

메시지 생성 규칙은 다음과 같다.

 

✔ ObjectError

- errorCode + "." + objectName

- errorCode

 

ex) codesResolver.resolveMessageCodes("required", "item");

- required.item

- required

 

✔ FieldError

- errorCode + "." + objectName + "." + field

- errorCode + "." + field

- errorCode + "." + fieldType

- errorCode

 

ex) codesResolver.resolveMessageCodes("required","item", "itemName", String.class);

- required.item.itemName

- required.itemName

- required.java.lang.String

- required

 

이게 그래서 어디에 쓰이는데? 바로, .rejectValue()와 .reject()의 내부에서 사용된다.

 

[AbstractBindingResult.java]

@Override
public void reject(String errorCode, @Nullable Object[] errorArgs, @Nullable String defaultMessage) {
    addError(new ObjectError(getObjectName(), resolveMessageCodes(errorCode), errorArgs, defaultMessage));
}

@Override
public void rejectValue(@Nullable String field, String errorCode, @Nullable Object[] errorArgs,
                        @Nullable String defaultMessage) {

    if (!StringUtils.hasLength(getNestedPath()) && !StringUtils.hasLength(field)) {
        reject(errorCode, errorArgs, defaultMessage);
        return;
    }

    String fixedField = fixedField(field);
    Object newVal = getActualFieldValue(fixedField);
    FieldError fe = new FieldError(getObjectName(), fixedField, newVal, false,
            resolveMessageCodes(errorCode, field), errorArgs, defaultMessage);
    addError(fe);
}


@Override
public String[] resolveMessageCodes(String errorCode) {
    return getMessageCodesResolver().resolveMessageCodes(errorCode, getObjectName());
}

@Override
public String[] resolveMessageCodes(String errorCode, @Nullable String field) {
    return getMessageCodesResolver().resolveMessageCodes(
            errorCode, getObjectName(), fixedField(field), getFieldType(field));
}

reject()와 rejectValue() 내부에서 모두 resolveMessageCodes를 사용하는 걸 볼 수 있다!

ObjectError 생성 시에는 errorCode와 ObjectName만을, FieldError 생성 시에는 errorCode, ObjectName, Field, FieldType까지 모두 사용한다.

 

MessageCodesResolver의 경우 '구체적인 것을 먼저' 만들어주고, 덜 구체적인 것을 나중에 만든다.

ex) required.item -> required

모든 오류 코드를 생성하는 것보다는, 중요한 것만 구체적으로 두고 나머지는 덜 구체적인 걸로 사용하는 게 더 낫다.

메시지를 찾을 때도 구체적인 것부터 찾고 없으면 덜 구체적인 걸 찾는 형식이다! 

 

추가적으로, 검증 오류 로직에서 다음과 같이 수정도 가능하다.

[SItemController.java]

@PostMapping("/add")
public String addItemV2 (@ModelAttribute("item") SItem item, BindingResult bindingResult,
                         RedirectAttributes redirectAttributes) {

    ValidationUtils.rejectIfEmptyOrWhitespace(bindingResult, "itemName", "required");
//        if (!StringUtils.hasText(item.getItemName())) {
//            bindingResult.rejectValue("itemName", "required");
//        }

    ...

- 다음과 같이 간단한 공백 체크는 ValidationUtils을 활용해도 좋을 것 같다 :D

 

🚩 전체 흐름

- rejectValue() 호출 -> MessageCodesResolver를 통해 메시지 코드 생성

-> new FieldError()를 생성하면서 코드 보관 -> th:errors에서 메시지 코드를 통해 메시지 찾고 노출시키기 (없으면 디폴트 메시지)

---

 

| 스프링의 검증 오류 전략

- 우리의 상품 등록 폼 중 가격 필드에 문자를 입력하면 스프링은 타입 오류에 관한 메시지를 생성한다.

- typeMismatch.item.price

- typeMismatch.price

- typeMismatch.java.lang.Integer

- typeMismatch

 

- 이를 이용해서 에러 프로퍼티에 추가해주자.

[errors.properties]

typeMismatch.java.lang.Integer=Please enter 'Integer' Type.
typeMismatch=Type Mismatch Error. Check your field value.

- 국제화까지는 진행하지 않았다. (이러한 필드 오류는 국제화보다는 그냥 영어로 전달하는 게 나을 것 같아서)

- 다음과 같이 잘 뜨는 걸 볼 수 있다!

 

---

| Validator 분리하기

- 검증 로직을 재사용할 수 있도록 별도의 클래스로 분리하자.

[SItemValidator.java]

@Component
public class SItemValidator implements Validator {
    @Override
    public boolean supports(Class<?> clazz) {
        return SItem.class.isAssignableFrom(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
        SItem item = (SItem) target;
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "itemName", "required");

        if (item.getPrice() == null || item.getPrice() < 1000 || item.getPrice() > 1000000) {
            errors.rejectValue("price", "range", new Object[]{1000, 1000000},null);
        }

        if (item.getQuantity() == null || item.getQuantity() >= 10000) {
            errors.rejectValue("quantity", "max", new Object[]{9999}, null);
        }

        //특정 필드 예외가 아닌 전체 예외
        if (item.getPrice() != null && item.getQuantity() != null) {
            int resultPrice = item.getPrice() * item.getQuantity();
            if (resultPrice < 10000) {
                errors.reject("totalPriceMin", new Object[]{10000, resultPrice}, null);
            }
        }

    }
}

- Validator 인터페이스를 구현한다.

- supports를 통해 파라미터로 넘어온 클래스가 SItem을 지원하는지. (SItem의 자식 클래스여도 가능)

- 기존의 bindingResult가 들어가는 부분에 파라미터의 errors를 넣어준다.

    - 어차피 bindingResult는 Errors를 구현한 인터페이스이기 때문에 넣어줄 수 있다!

 

[SItemController.java] - 수정

private final SItemValidator validator;

@PostMapping("/add")
public String addItemV2 (@ModelAttribute("item") SItem item, BindingResult bindingResult,
                         RedirectAttributes redirectAttributes) {

    validator.validate(item, bindingResult);
    if (bindingResult.hasErrors()) {
        return "basic/addForm";
    }

    SItem savedItem = service.saveItem(item);
    redirectAttributes.addAttribute("itemId", savedItem.getId());
    redirectAttributes.addAttribute("status", true);
    return "redirect:/basic/items/{itemId}";
}

- 컨트롤러 코드가 정말 깔끔해졌다!

 

- 마지막으로, validator를 호출하지 않고 @Validated를 사용해보자.

@InitBinder
public void init(WebDataBinder dataBinder) {
    dataBinder.addValidators(validator);
}

@PostMapping("/add")
public String addItemV2 (@Validated @ModelAttribute("item") SItem item, BindingResult bindingResult,
                         RedirectAttributes redirectAttributes) {
    if (bindingResult.hasErrors()) {
        return "basic/addForm";
    }

    SItem savedItem = service.saveItem(item);
    redirectAttributes.addAttribute("itemId", savedItem.getId());
    redirectAttributes.addAttribute("status", true);
    return "redirect:/basic/items/{itemId}";
}

@Validated는 검증기를 실행하라는 어노테이션으로, WebDataBinder에 등록한 검증기를 찾아서 실행된다.

@Valid도 같은 의미이다. 이건 다음 포스팅에서 조금 더 알아보자!

이때, 여러 검증기가 등록되면 supports()에 통과되는 검증기가 실행된다.

 

해당 컨트롤러 단위에서 검증기를 자동으로 적용하기 위해 WebDataBinder를 사용하였다. (@InitBinder)

@InitBinder를 사용하면 해당 컨트롤러가 호출될 때마다 WebDataBinder에 우리가 커스텀한 validator를 추가하게 된다.

여기서는 단순히 '추가' 작업이고, 실제로 @Validated가 붙은 메서드에서 validate를 실행하는 것!

 

🚩 다른 분이 디버깅을 하셨다는 걸 봤는데, @Validated가 없어도 값을 매핑할 때면 @InitBinder로 등록한 Validator의 support() 메서드가 동작한다고 한다...! 그럼 SItem 외에 다른 것들도 검증할 텐데, 예측하지 못한 검증 실패 예외가 많이뜨지 않을까?

그래서 보통은 @InitBinder("name") 이렇게 이름을 지정해서 해당 객체에만 영향을 주도록 지정한다고 한다!

 

글로벌하게 사용하려면 WebMvcConfigurer를 상속받아 getValidator를 통해 오버라이딩을 해주면 된다.

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

    @Override
    public Validator getValidator() {
        return new ItemValidator();
    }
}

- 이런 식으로 하면 된다! (굳이 추가까지는 하지 말고 이런 게 있다는 것 정도만 체크하자)

 

- 다음 포스팅에서는 Bean Validation을 알아보자. (아마 실제 검증에서는 이거를 훨씬 많이 사용할 것이다!)