Spring Vaildation#1 검증

객체를 매핑하는 컨트롤러의 중요한 역할중 하나는 HTTP 요청이 정상인지 검증하는 것이다. 어쩌면 정상 로직보다 이러한 예외, 검증 로직을 설계하는 것이 훨씬 더 어려울 수 있다.

 

해당글은 Bean Validation이 어떻게 동작하는지 알기위해 스프링에서 수동으로 직접 검증객체를 만들 것이다. @Valid와 @NotNull 등 어노테이션을 이용한 Validation 사용법만 알고 싶다면, 다음 글을 읽어보도록 하자.

 

 

# Vaildation, 검증 기능이란?

값이 올바른 형태인지 검증하는 것을 의미한다. 웹 서비스는 값에 오류가 발생하면 고객이 입력한 데이터를 유지한 상태로 어떤 오류가 발생했는지 알려주어야 한다.

• 클라이언트에서 자바스크립트, HTML은 조작할 수 있으므로 보안에 취약하다.
• 그렇다고 Only 서버로 검증하면 즉각적인 고객 사용성(UX)이 답답해진다.
• 둘을 적절히 섞어서 사용하되, 최종적으로 서버 검증은 필수
• API 방식을 사용하면 API 스펙을 잘 정의해서 검증 오류를 API 응답 결과에 잘 남겨주어야 한다.

검증 시스템의 예시

 

---

# Vaildation을 직접 처리하기

정말 간단한 페이지인데도 검증 실패를 처리하는 컨트롤러 객체가 매우 복잡해진다.

• 고객에게 어떤 값이 검증에 실패했는지 알려주기위해 Map<String, String> errors에 기록한다.
• 각각의 필드에 해당하는 검증, 여러 필드를 복합적으로 점검하는 검증이 따로 필요하다.
• 실패했을 때, 성공했을 때 전달하는 View가 달라져야 한다. (items와 errors를 전달)

@Slf4j
@Controller
@RequestMapping("/validation/v1/items")
@RequiredArgsConstructor
public class ValidationItemControllerV1 {

  private final ItemRepository itemRepository;

  @PostMapping("/add")
  public String addItem(@ModelAttribute Item item, RedirectAttributes redirectAttributes,
      Model model) {

      //검증 오류 결과를 보관
      Map<String, String> errors = new HashMap<>();
  
      //단순 검증 로직
      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() >= 9999) {
        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);
        }
      }
  
      //검증에 실패하면 다시 입력 폼으로
      if (!errors.isEmpty()) {
        log.info("errors = {} ", errors);
        model.addAttribute("errors", errors);
        return "validation/v1/addForm";
      }
  
      //성공 로직
      Item savedItem = itemRepository.save(item);
      redirectAttributes.addAttribute("itemId", savedItem.getId());
      redirectAttributes.addAttribute("status", true);
      return "redirect:/validation/v1/items/{itemId}";
  }
}

 

타임리프에서 item과 erros를 받아 아래와 같이 오류를 보여줄 수 있다.

• errors.method() 대신 errors?.method()를 사용하면 해당 객체가 null일 때 무시할 수 있다.
• map.containsKey('value')는 해당 키의 여부에 따라 true, false를 반환한다. => th:if 조건문 사용.

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

    <div>
      <label for="itemName" th:text="#{label.item.itemName}">상품명</label>
      <input class="form-control" id="itemName" placeholder="이름을 입력하세요"
             th:class="${errors?.containsKey('itemName')} ? 'form-control field-error' : 'form-control'"
             th:field="*{itemName}" type="text">
             
      <div class="field-error" th:if="${errors?.containsKey('itemName')}"
           th:text="${errors['itemName']}">
        상품명 오류 (상품이름은 필수입니다)
      </div>
    </div>
    ...
</form>

상단 에러메시지 / &lt;input class=field-error&gt; / 하단 상품에러 메시지 를 추가하였다.

 

참고로 <input class=filed-error>는 아래와 같이 th:classappend를 사용할 수도 있다.

<input type="text" 
       th:classappend="${errors?.containsKey('itemName')} ? 'field-error' : _"
       class="form-control">

 

---

@ 직접 처리했을 때 문제점

• 뷰 템플릿에서 중복이 너무 많다. input 필드마다 반복해서 처리해야 한다.
• 값이 아니라 타입 오류 처리가 불가능하다. 예를 들어 숫자 타입(Integer)에 문자('one')가 들어온다면 스프링 MVC에 진입하기도 전에 HTTP 400 에러가 발생할 수 있다.
• 타입이 다른 이상한 값이 들어오더라도 고객에게 잘못된 값임을 알려줘야 한다. 

 

---

# 스프링이 제공하는 Validation 처리

스프링 Vaildation의 핵심은 컨트롤러에서 사용할 수 있는 BindingResult 파라메타 객체이다.

Errors는 단순 오류 저장을, BindingResult는 이를 상속받아 추가적인 메서드를 제공한다.

 

• 단 BindingResult 파라메타는 @ModelAttribute Item 다음에 와야 한다.
• 기존의 errors 대신에 bindingResult를 사용한다. 그리고 객체 FieldError와 ObjectError를 담는다.
• bindingResult 객체는 자동으로 View에 넘어간다. 또한 .hasErrors() .addError(~) 같은 메서드를 제공한다.

public FieldError(String objectName, String field, String defaultMessage) {}
// 오류가 발생한     모델 객체 이름,    필드 이름,      기본 오류 메시지

public ObjectError(String objectName, String defaultMessage) {}
// 오류가 발생한     모델 객체 이름,       기본 오류 메시지

 

이제 하드코딩 하지않고, 에러를 bindingResult 객체로 관리할 수 있게 되었다.

@PostMapping("/add")
public String addItemV2(@ModelAttribute Item item, BindingResult bindingResult,
                        RedirectAttributes redirectAttributes, Model model) {
    //검증 로직
    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() >= 9999) {
        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()) {
        log.info("errors={} ", bindingResult);
        return "validation/v2/addForm";
    }

    //성공 로직
    Item savedItem = itemRepository.save(item);
    redirectAttributes.addAttribute("itemId", savedItem.getId());
    redirectAttributes.addAttribute("status", true);
    return "redirect:/validation/v2/items/{itemId}";
}

 

# 타임리프(thymeleaft) 스프링 오류 예외처리 기능

스프링의 bindingErrors를 사용하면 타임리프에서는 간결한 문법을 이용할 수 있다.

www.thymeleaf.org/doc/tutorials/3.0/thymeleafspring.html#validation-and-error-messages

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

    <div>
      <label for="itemName" th:text="#{label.item.itemName}">상품명</label>
      <input class="form-control" id="itemName" placeholder="이름을 입력하세요"
             th:errorclass="field-error" th:field="*{itemName}" type="text">
             
      <div class="field-error" th:errors="*{itemName}">
        상품명 오류
      </div>
    </div>
    ...
</form>

 

---

@ FieldError 와 ObjectError 더 알아보기

이 객체들에게 추가적인 정보를 줘서 예외가 발생하더라도 사용자 입력값을 유지시킬 수 있다.

public FieldError(String objectName, String field, String defaultMessage)

public FieldError(String objectName, String field, 
@Nullable Object rejectedValue, // 사용자가 입력한 값(거절값)
boolean bindingFailure, // 타입 바인딩 실패(true), 검증 실패(false)
@Nullable String[] codes, // 메시지 코드, 문자열
@Nullable Object[] arguments, // 메시지에서 사용하는 인자
@Nullable String defaultMessage)

//검증 로직 
if (!StringUtils.hasText(item.getItemName())) {
    bindingResult.addError(
    new FieldError("item", "itemName", 
                    item.getItemName(), false, null, null,"상품 이름은 필수 입니다."));
}

 

• codes와 arguments를 이용하면 오류 메시지도 스프링의 국제화, 메시지 기능을 사용할 수 있다.
  만약 errors.properties로 오류 프로퍼티를 분리하고 싶다면 이렇게 사용추가하면 된다.
  (application.properties 파일) spring.messages.basename= messages, errors

# errors.properties

required.item.itemName = 상품 이름은 필수입니다.
range.item.price = 가격은 {0} ~ {1} 까지 허용합니다.
max.item.quantity = 수량은 최대 {0} 까지 허용합니다.
totalPriceMin = 가격 * 수량의 합은 {0}원 이상이어야 합니다. 현재 값 = {1}

if (item.getQuantity() == null || item.getQuantity() >= 9999) {
  bindingResult.addError(new FieldError("item", "quantity", item.getQuantity(), false,
      new String[]{"max.item.quantity"}, new Object[]{9999}, null));
    // String[] codes에 있는 메시지를 순서대로 찾다가 제일 먼저 발견된 메시지를 사용한다.
}

오류코드를 배열로 받아 계층적으로 사용하는 이유는 MessageCodesResolver를 사용하기 때문이다.

 

 

@ BindingResult를 사용했을 때 달라진점

• 스프링이 제공해주는 객체를 이용해서 자바코드와 타임리프 코드가 간결해졌다.

 

• 타입 오류가 발생하더라도 BindingResult가 있어서 HTTP 400 에러가 안터지고 컨트롤러가 호출된다.

 

---

# 스프링의 오류코드 추상화

앞에서 설명한 FieldError 나 ObjectError를 매번 new로 생성해주기에는 너무 번거롭다.

조금 더 추상화해서 입력 값만 주면 알아서 동작하도록 만들 수 없을까?  → rejectValue(), reject()

 

• BindingResult에는 rejectValue(), reject() 라는 메서드를 제공한다.
  (내부에서 FieldError, ObjectError 를 대신 만들어준다.)

# errors.properties

required.item.itemName = 상품 이름은 필수입니다.
range.item.price = 가격은 {0} ~ {1} 까지 허용합니다.
max.item.quantity = 수량은 최대 {0} 까지 허용합니다.
totalPriceMin = 가격 * 수량의 합은 {0}원 이상이어야 합니다. 현재 값 = {1}

if (resultPrice < 10000) { // 기존 코드
  bindingResult.addError(
    new ObjectError("item", new String[]{"totalPriceMin"}, 
    new Object[]{10000, resultPrice}, null));
}

if (resultPrice < 10000) { // reject() 사용
    bindingResult.reject(
    "totalPriceMin", 
    new Object[]{10000, resultPrice}, null);
}

// range.item.price 가 매칭되어 메시지가 삽입된다.
bindingResult.rejectValue("price", "range", new Object[]{1000, 1000000}, null)

 

 

---

@ MessageCodeResolver

reject와 rejectValue 에 있는 오류코드(errorCode)는 MessageCodeResolver 객체를 통해 오류메시지가 생성된다.

 

메시지 리졸버를 사용해서 만든 범용적인 errors.properties 

기존의 errors.properties, 모든 오류코드를 지정해줘야 한다. (없으면 예외 발생)

required.item.itemName=상품 이름은 필수입니다.
range.item.price=가격은 {0} ~ {1} 까지 허용합니다.
max.item.quantity=수량은 최대 {0} 까지 허용합니다.
totalPriceMin=가격 * 수량의 합은 {0}원 이상이어야 합니다. 현재 값 = {1}

 

범용적인 errors.properties, 유연하게 적용되고 오류가 없더라도 대체 값을 사용한다. 

#==ObjectError==
#Level1
totalPriceMin.item=상품의 가격 * 수량의 합은 {0}원 이상이어야 합니다. 현재 값 = {1}

#Level2 - 생략
totalPriceMin=전체 가격은 {0}원 이상이어야 합니다. 현재 값 = {1}


#==FieldError==
#Level1
required.item.itemName=상품 이름은 필수입니다.
range.item.price=가격은 {0} ~ {1} 까지 허용합니다.
max.item.quantity=수량은 최대 {0} 까지 허용합니다.

#Level2 - 생략

#Level3
required.java.lang.String = 필수 문자입니다.
required.java.lang.Integer = 필수 숫자입니다.
min.java.lang.String = {0} 이상의 문자를 입력해주세요.
min.java.lang.Integer = {0} 이상의 숫자를 입력해주세요.
range.java.lang.String = {0} ~ {1} 까지의 문자를 입력해주세요.
range.java.lang.Integer = {0} ~ {1} 까지의 숫자를 입력해주세요.
max.java.lang.String = {0} 까지의 숫자를 허용합니다.
max.java.lang.Integer = {0} 까지의 숫자를 허용합니다.

#Level4
required = 필수 값 입니다.
min= {0} 이상이어야 합니다.
range= {0} ~ {1} 범위를 허용합니다.
max= {0} 까지 허용합니다

#Level1
required.item.itemName: 상품 이름은 필수 입니다.

#Level2
required: 필수 값 입니다.

public class MessageCodesResolverTest {

  MessageCodesResolver codesResolver = new DefaultMessageCodesResolver();

  @Test
  @DisplayName("(required)는 1. required.item 2. required 순으로 지정된다.")
  void messageCodesResolverObject() {
    String[] messageCodes = codesResolver.resolveMessageCodes("required", "item");
    assertThat(messageCodes).containsExactly("required.item", "required");
  }

  @Test
  void messageCodesResolverField() {
    String[] messageCodes = codesResolver.resolveMessageCodes("required", "item", "itemName",
        String.class);
    assertThat(messageCodes).containsExactly(
        "required.item.itemName", // 1순위. 완벽하게 일치
        "required.itemName", // 2순위. 필드명 일치
        "required.java.lang.String", // 3순위 타입 일치
        "required" // 4순위 에러코드 일치
        // 5순위 - reject()에 적은 defaultMessage
    );
  }

}

 

FieldError 객체가 에러코드를 왜 String[]로 받는지에 대한 이유가 여기서 나온다.

→ MessageCodeResolver가 해당 메시지를 유연하게 찾아 반환하기 때문이다. 만약 오류코드가 메시지 프로퍼티에 없는 경우, 일치도를 비교해서 다른 오류 메시지를 대신 사용하게 된다.

// DefaultMessageCodesResolver 의 동작

객체 오류의 경우 다음 순서로 2가지 생성
1. code + "." + object name
2. code

예) { errorCode: "required", object-name: "item" }
1. required.item
2. required

필드 오류의 경우 다음 순서로 4가지 메시지 코드 생성
1. code + "." + object name + "." + field
2. code + "." + field
3. code + "." + field type
4. code

예) { errorCode: "typeMismatch", object-name:"user", field:"age", field-type: int }
1. typeMismatch.user.age
2. typeMismatch.age
3. typeMismatch.int
4. typeMismatch

 

예를 들어 item 객체의 itemName 필드에서 에러가 났다면, bindingResult.reject() 내부에서는 다음과 같이 작동한다.

 

---

# ValidationUtils

나중에 사용할테지만, 앞에서 적은 조건문을 ValidationUtils를 이용하면 JUnit Test처럼 메서드로 바꿀 수 있다.

if (!StringUtils.hasText(item.getItemName())) {
 bindingResult.rejectValue("itemName", "required", "기본: 상품 이름 필수");
}

// 간단한 조건은 VaildationUtils로 똑같이 구현가능.
ValidationUtils.rejectIfEmptyOrWhitespace(bindingResult, "itemName", "required");

 

---

# 정리 - 스프링 오류 메시지 처리

스프링이 직접 FieldError() 객체를 만들어준다.

스프링에서 FieldError 객체를 만들면 다음과 같이 메시지를 작성해버린다.

• 범용적인 메시지(error.properties)를 적고 MessageCodeResolver를 사용하면 아래와 같은 일을 방지할 수 있다.

스프링이 생성한 기본메시지가 클라이언트에 전송되면 좀 난감하다.

@PostMapping("/add")
public String addItem(@Validated @ModelAttribute("item") ItemSaveForm form,
    BindingResult bindingResult, RedirectAttributes redirectAttributes) {

  //특정 필드가 아닌 복합 룰 검증
  if (form.getPrice() != null && form.getQuantity() != null) {
    int resultPrice = form.getPrice() * form.getQuantity();
    if (resultPrice < 10000) {
      bindingResult.reject("totalPriceMin", new Object[]{10000, resultPrice}, null);
    }
  }

  //검증에 실패하면 다시 입력 폼으로
  if (bindingResult.hasErrors()) {
    return "validation/v4/addForm";
  }

  //성공 로직
  Item item = new Item();
  item.setItemName(form.getItemName());
  item.setPrice(form.getPrice());
  item.setQuantity(form.getQuantity());

  Item savedItem = itemRepository.save(item);
  redirectAttributes.addAttribute("itemId", savedItem.getId());
  redirectAttributes.addAttribute("status", true);
  return "redirect:/validation/v4/items/{itemId}";
}

 

---

# 한걸음 더, Validator 분리

하지만 여전히 컨트롤러가 너무 많은 로직을 담당하고 있다. 한 객체가 두가지 책임을 지고 있으니 (OCP) 복잡한 검증 로직을 Vaildator 객체로 만들어 책임을 분리하자.

• 스프링에서는 Validator 인터페이스를 제공해준다. 이를 이용해 검증 객체를 쉽게 분리할 수 있다.
  그런데 사실 Validator를 사용하지 않고, 그냥 아무 객체나 스프링빈으로 등록해 사용해도 된다. 이를 사용하는 이유는 아래에서 알아보자.

@Component
public class ItemValidator implements Validator {

  @Override
  public boolean supports(Class<?> clazz) {
  // return (item == clazz) 와 같은 코드지만, 이렇게 쓰면 자식 객체도 true.
    return Item.class.isAssignableFrom(clazz);
  }

  @Override
  public void validate(Object target, Errors errors) {
    Item item = (Item) target;

    if (!StringUtils.hasText(item.getItemName())) {
      errors.rejectValue("itemName", "required");
    }
    if (item.getPrice() == null || item.getPrice() < 1000 || item.getPrice() > 1000000) {
      errors.rejectValue("price", "range", new Object[]{1000, 10000000}, null);
    }
    if (item.getQuantity() == null || item.getQuantity() >= 9999) {
      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);
      }
    }
  }
}

 

이렇게 만든 스프링 빈을 Controller에 사용하면 된다.

• Controller에서는 사용된 검증 코드를 itemValidator로 분리하였다.

public class ValidationItemControllerV2 {

  private final ItemRepository itemRepository;
  private final ItemValidator itemValidator;
  
  ...
  
  @PostMapping("/add")
  public String addItemV5(@ModelAttribute Item item, BindingResult bindingResult,
      RedirectAttributes redirectAttributes, Model model) {

    itemValidator.validate(item, bindingResult);

    //검증에 실패하면 다시 입력 폼으로
    if (bindingResult.hasErrors()) {
      log.info("errors={} ", bindingResult);
      return "validation/v2/addForm";
    }

    //성공 로직
    Item savedItem = itemRepository.save(item);
    redirectAttributes.addAttribute("itemId", savedItem.getId());
    redirectAttributes.addAttribute("status", true);
    return "redirect:/validation/v2/items/{itemId}";
  }
}

 

---

# Validator 인터페이스를 사용하는 이유

스프링의 Vaildator 인터페이스를 사용하면 스프링의 추가적인 기능을 사용할 수 있다.

 

@ WebDataBinder 통해서 사용하기

이는 각 @RequsetMapping이 시작될 때 바인딩 파라미터(BinderingResult)를 전달하는 역할을 해주고, 검증 객체를 등록하여 사용할 수 있다. 

// 각 메서드에서 itemValidator.validate(item, bindingResult); 를 호출해주는 역할.

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

참고로 @InitBinder는 해당 컨트롤러에만 검증 객체를 만든다. 모든 컨트롤러에 전역으로 하는방법은 있긴한데, 스프링에서 빈 검증을 할때 등록되는 글로벌 Validator(LocalValidatorFactoryBean)가 있어서 직접 사용할 일은 없다.

*주의 이렇게 코드를 작성하면, BeanVaildaton이 해당 코드로 오버라이딩되며 더 이상 동작하지 않음

 

itemValidator.validate(item, bindingResult)를 호출하는 대신에 @Validated를 붙이면 작동한다.

• 또는 javax.validation.@Vaild를 사용해도 되는데, 스프링의 @Validated가 사용법이 더 다양하다.
  @Valid는 자바 표준 어노테이션이므로 사용하려면 아래의 의존성을 추가해주어야 한다.
  implementation 'org.springframework.boot:spring-boot-starter-validation'

 @PostMapping("/add")
  public String addItemV6(@Validated @ModelAttribute Item item, BindingResult bindingResult,
      RedirectAttributes redirectAttributes, Model model) {...}

 

그러면 @Validated가 붙은 객체를 dataBinder에 등록된 검증기(Validator)들의 support(~)에 다 넣어보며 담당 검증 객체를 찾는다. 찾았다면 validate() 를 실행시켜 검증하게된다.

if ( validator.support(Item.class) == true ) { validator.validate() }

@Component
public class ItemValidator implements Validator {

  @Override
  public boolean supports(Class<?> clazz) {
  // return (item == clazz) 와 같은 코드지만, 이렇게 쓰면 자식 객체도 true.
    return Item.class.isAssignableFrom(clazz);
  }

  @Override
  public void validate(Object target, Errors errors) {
    Item item = (Item) target;

    if (!StringUtils.hasText(item.getItemName())) {
      errors.rejectValue("itemName", "required");
    }
    if (item.getPrice() == null || item.getPrice() < 1000 || item.getPrice() > 1000000) {
      errors.rejectValue("price", "range", new Object[]{1000, 10000000}, null);
    }
    if (item.getQuantity() == null || item.getQuantity() >= 9999) {
      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);
      }
    }
  }
}