스프링 MVC 2편 - 백엔드 웹 개발 활용 기술 정리(2)

Jim·2023년 7월 20일
loginspringMVCvalidation
0

스프링

목록 보기
4/10
post-thumbnail

4. 검증 1. Validation

1. 검증 요구사항

상품 관리 시스템에 검증 로직 추가

  • 타입 검증
    • 가격, 수량에 문자가 들어가면 검증 오류 처리
  • 필드 검증
    • 상품명: 필수, 공백X
    • 가격: 1000원 이상, 1백만원 이하
    • 수량: 최대 9999
  • 특정 필드의 범위를 넘어서는 검증
    • 가격 * 수량의 합은 10,000원 이상

클라이언트 검증, 서버 검증

  • 클라이언트 검증은 조작할 수 있으므로 보안에 취약.
  • 서버만으로 검증하면, 즉각적인 고객 사용성이 부족.
  • 둘을 적절히 섞어서 사용하되, 최종적으로 서버 검증은 필수.
  • API 방식을 사용하면 API 스펙을 잘 정의해서 검증 오류를 API 응답 결과에 잘 남겨주어야 함.

2. 검증 직접 처리

검증 오류 보관

  • Map<String, String> errors = new HashMap<>();

검증 로직

// import org.springframework.util.StringUtils; 추가
if (!StringUtils.hasText(item.getItemName())) {
	errors.put("itemName", "상품 이름은 필수입니다.");
}
  • 오류가 발생한 필드명을 key로 사용.
  • 특정 필드를 넘어서는 오류는 globalError라는 key 사용.
if (!errors.isEmpty()) {
	model.addAttribute("errors", errors);
 	return "validation/v1/addForm";
}
  • 검증에서 오류 메시지가 하나라도 있으면 model에 errors를 담고, 입력 폼이 있는 뷰 템플릿으로 보낸다.

addForm.html

.field-error {
	border-color: #dc3545;
 	color: #dc3545;
}
  • 오류 메시지를 빨간색으로 강조하기 위해 css 추가
<!-- 글로벌 오류 메시지 -->
<div th:if="${errors?.containsKey('globalError')}">
	<p class="field-error" th:text="${errors['globalError']}">전체 오류 메시지</p>
</div>
  • 등록폼에 진입한 시점에는 errors가 없다. 따라서 errors.containsKey()를 호출하는 순간 NullPointerException이 발생한다. errors?.은 errors가 null일때 NullPointerException이 발생하는 대신, null을 반환하는 문법이다. th:if에서 null은 실패로 처리되므로 오류 메시지가 출력되지 않는다.
  • 이것은 Safe Navigation Operator, SpringEL이 제공하는 문법 이다.
<!-- 필드 오류 처리, 둘 다 가능 -->
<input type="text" id="itemName" th:field="*{itemName}"
                   th:class="${errors?.containsKey('itemName')} ? 
                             'form-control field-error' : 'form-control'"
                   class="form-control" placeholder="이름을 입력하세요">

<input type="text" th:classappend="${errors?.containsKey('itemName')} ? 
                                   'field-error' : _" class="form-control">
  • 오류가 없으면 _(No-Operation)을 사용해서 아무것도 하지 않는다.
<!-- 필드 오류 메시지 -->
<div class="field-error" 
     th:if="${errors?.containsKey('itemName')}" 
     th:text="${errors['itemName']}">
	상품명 오류
</div>

3. BindingResult1

addItemV1()

@PostMapping("/add")
public String addItemV1(@ModelAttribute Item 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() >= 9999) {
    	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()) {
    	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}";
}
  • BindingResult bindingResult 파리미터의 위치는 @ModelAttribute Item item 다음에 와야 한다.
  • FieldError 생성자 요약
    -> public FieldError(String objectName, String field, String defaultMessage) {}
    • 필드에 오류가 있으면 FieldError객체를 생성해서 bindingResult에 담아두면 된다.
    • objectName: @ModelAttribute이름
    • field: 오류가 발생한 필드 이름
    • defulatMessage: 오류 기본 메시지
  • ObjectError 생성자 요약
    -> public ObjectError(String objectName, String defaultMessage) {}
    • 특정 필드를 넘어서는 오류가 있으면 ObjectError객체를 생성해서 bindingResult에 담아두면 된다.
    • objectName: @ModelAttribute의 이름
    • defaultMessage: 오류 기본 메시지

addForm.html 수정

<form action="item.html" th:action th:object="${item}" method="post">

    <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 type="text" id="itemName" th:field="*{itemName}"
               th:errorclass="field-error" class="form-control" placeholder="이름을 입력하세요">
        <div class="field-error" th:errors="*{itemName}">
            상품명 오류
        </div>
    </div>
    <div>
        <label for="price" th:text="#{label.item.price}">가격</label>
        <input type="text" id="price" th:field="*{price}"
               th:errorclass="field-error" class="form-control" placeholder="가격을 입력하세요">
        <div class="field-error" th:errors="*{price}">
            가격 오류
        </div>
    </div>
    <div>
        <label for="quantity" th:text="#{label.item.quantity}">수량</label>
        <input type="text" id="quantity" th:field="*{quantity}"
               th:errorclass="field-error" class="form-control" placeholder="수량을 입력하세요">
        <div class="field-error" th:errors="*{quantity}">
            수량 오류
        </div>
    </div>

    <hr class="my-4">

    <div class="row">
        <div class="col">
            <button class="w-100 btn btn-primary btn-lg" type="submit" th:text="#{button.save}">상품 등록</button>
        </div>
        <div class="col">
            <button class="w-100 btn btn-secondary btn-lg"
                    onclick="location.href='items.html'"
                    th:onclick="|location.href='@{/validation/v2/items}'|"
                    type="button" th:text="#{button.cancel}">취소</button>
        </div>
    </div>

</form>
  • 타임리프 스프링 검증 오류 통합 기능
    • #fields: #fields로 BindingResult가 제공하는 검증 오류에 접근할 수 있다.
    • th:errors: 해당 필드에 오류가 있는 경우에 태그를 출력한다. th:if의 편의 버전.
    • th:errorclass: th:field에서 지정한 필드에 오류가 있으면 class정보를 추가한다.
    • 검증과 오류 메시지 공식 메뉴얼

4. BindingResult2

  • 스프링이 제공하는 검증 오류를 보관하는 객체이다. 검증 오류가 발생하면 여기에 보관하면 된다.
  • BindingResult가 있으면 @ModelAttribute에 데이터 바인딩 시 오류가 발생해도 컨트롤러가 호출된다!
  • 예) @ModelAttriute에 바인딩 시 타입 오류가 발생하면?
    • BindingResult가 없으면 -> 400 오류가 발생하면서 컨트롤러가 호출되지 않고, 오류 페이지로 이동.
    • BindingResult가 있으면 -> 오류 정보(FieldError)를 BindingResult에 담아서 컨트롤러를 정상 호출.
  • BindingResult는 Model에 자동으로 포함된다.

BindingResult에 검증 오류를 적용하는 3가지 방법

  • @ModelAttribute의 객체에 타입 오류 등으로 바인딩이 실패하는 경우 스프링이 FieldError 생성해서 BindingResult에 넣어준다.
  • 개발자가 직접 넣어준다.
  • Validator사용

BindingResult와 Errors

  • org.springframework.validation.Errors
  • org.springframework.validation.BindingResult
  • BindingResult는 인터페이스이고, Errors 인터페이스를 상속받고 있다. 실제 넘어오는 구현체는 BeanPropertyBindingResult라는 것인데, 둘다 구현하고 있으므로 BindingResult대신에 Errors를 사용해도 된다. Errors인터페이스는 단순한 오류 저장과 조회 기능을 제공한다. BindingResult는 여기에 더해서 추가적인 기능들을 제공한다. addError()도 BindingResult가 제공하므로 여기서는 BindingResult를 사용하자. 주로 관례상 BindingResult를 많이 사용한다.

addItemV2()

@PostMapping("/add")
public String addItemV2(@ModelAttribute Item 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() >= 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}";
}
// FieldError 생성자
public FieldError(String objectName, String field, String defaultMessage);
public FieldError(String objectName, String field, 
					@Nullable Object rejectedValue, boolean bindingFailure, 
                    @Nullable String[] codes, @Nullable Object[] arguments, 
                    @Nullable String defaultMessage)
  • FieldError 생성자 파라미터 목록
    • objectName: 오류가 발생한 객체 이름
    • field: 오류 필드
    • rejectedValue: 사용자가 입력한 값(거절된 값)
    • bindingFailure: 타입 오류 같은 바인딩 실패인지, 검증 실패인지 구분 값. 여기서는 바인딩이 실패한 것은 아니기 때문에 false.
    • codes: 메시지 코드
    • arguments: 메시지에서 사용하는 인자
    • defaultMessage: 기본 오류 메시지
  • ObjectError도 유사하게 두 가지 생성자를 제공(코드 참고).
  • 오류 발생시 사용자 입력 값 유지
    • 사용자의 입력 데이터가 컨트롤러의 @ModelAttribute에 바인딩되는 시점에 오류가 발생하면 모델 객체에 사용자 입력 값을 유지하기 어렵다. 예를 들어서 가격에 숫자가 아닌 문자가 입력된다면 가격은 Integer타입이므로 문자를 보관할 수 있는 방법이 없다. FieldError는 오류 발생시 사용자 입력 값을 저장하는 기능을 제공한다.
    • rejectedValue가 오류 발생시 사용자 입력 값을 저장하는 필드.

타임리프의 사용자 입력 값 유지

  • 타임리프의 th:field는 매우 똑똑하게 동작하는데, 정상 상황에는 모델 객체의 값을 사용하지만, 오류가 발생하면 FieldError에서 보관한 값을 사용해서 값을 출력.
    예) th:field="*{price}"

스프링의 바인딩 오류 처리

  • 타입 오류로 바인딩에 실패하면 스프링은 FieldError를 생성하면서 사용자가 입력한 값을 넣어둔다. 그리고 해당 오류를 BindingResult에 담아서 컨트롤러를 호출한다. 따라서 타입 오류 같은 바인딩 실패시에도 사용자의 오류 메시지를 정상 출력할 수 있다.

5. 오류 코드와 메시지 처리1

FieldError, ObjectError의 생성자는 codes, arguments를 제공한다. 이것은 오류 발생시 오류 코드로 메시지를 찾기 위해 사용된다.

errors 메시지 파일 생성

spring.messages.basename=messages,errors
  • application.properties에 스프링 부트 메시지 설정 추가
required.item.itemName=상품 이름은 필수입니다.
range.item.price=가격은 {0} ~ {1} 까지 허용합니다.
max.item.quantity=수량은 최대 {0} 까지 허용합니다.
totalPriceMin=가격 * 수량의 합은 {0}원 이상이어야 합니다. 현재 값 = {1}
  • src/main/resources/errors.properties 추가
  • errors_en.properties파일을 생성하면 오류 메시지도 국제화 처리를 할 수 있다.

additemV3()

@PostMapping("/add")
public String addItemV3(@ModelAttribute Item 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() >= 9999) {
    	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()) {
    	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}";
}
  • codes: 메시지 코드는 하나가 아니라 배열로 여러 값을 전달할 수 있는데, 순서대로 매칭해서 처음 매칭되는 메시지가 사용된다.
  • arguments: Object[]{1000, 1000000}를 사용해서 코드의 {0},{1}로 치환할 값을 전달한다.
  • 실행해보면 MessageSource를 찾아서 메시지를 조회하는 것을 확인할 수 있다.

6. 오류 코드와 메시지 처리2

로그 출력

log.info("objectName={}", bindingResult.getObjectName());
log.info("target={}", bindingResult.getTarget());
objectName=item //@ModelAttribute name
target=Item(id=null, itemName=상품, price=100, quantity=1234)
  • BindingResult는 이미 본인이 검증해야 할 객체인 target을 알고 있다.

rejectValue(), reject()

  • BindingResult가 제공하는 rejectValue(), reject()를 사용하면 FieldError, ObjectError를 직접 생성하지 않고, 깔끔하게 검증 오류를 다룰 수 있다.

addItemV4()

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

	if (bindingResult.hasErrors()) {
		log.info("errors = {}", bindingResult);
        return "validation/v2/addForm";
    }

    log.info("objectName={}", bindingResult.getObjectName());
    log.info("target={}", bindingResult.getTarget());

    //검증 로직
    //ValidationUtils.rejectIfEmptyOrWhitespace(bindingResult, "itemName", "required");

    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() >= 9999) {
    	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()) {
    	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}";
}
  • 오류 메시지가 정상 출력된다.
void rejectValue(@Nullable String field, String errorCode, 
		@Nullable Object[] errorArgs, @Nullable String defaultMessage);

void reject(String errorCode, @Nullable Object[] errorArgs, 
									@Nullable String defaultMessage);
  • rejectValue()
    • field: 오류 필드명
    • errorCode: 오류 코드(이 오류 코드는 메시지에 등록된 코드가 아니다. 뒤에서 설명할 messageResolver를 위한 오류 코드이다.)
    • errorArgs: 오류 메시지에서 {0}을 치환하기 위한 값
    • defaultMessage: 오류 메시지를 찾을 수 없을 때 사용하는 기본 메시지

7. 오류 코드와 메시지 처리3

MessageCodesResolverTest

public class MessageCodesResolverTest {

    MessageCodesResolver codesResolver = new DefaultMessageCodesResolver();

    @Test
    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",
                "required.itemName",
                "required.java.lang.String",
                "required"
        );
    }
}
  • MessageCodesResolver
    • 검증 오류 코드로 메시지 코드들을 생성한다.
    • MessageCodesResolver는 인터페이스이고 DefaultMessageCodesResolver는 기본 구현체이다.
    • 주로 ObjectError, FieldError과 함께 사용

DefaultMessageCodesResolver의 기본 메시지 생성 규칙

  • 객체 오류
    • 객체 오류의 경우 다음 순서로 2가지 생성
      • code + "." + object name
      • code
    • 예) 오류 코드: required, object name: item
      • required.item
      • required
  • 필드 오류
    • 필드 오류의 경우 다음 순서로 4가지 메시지 코드 생성
      • code + "." + object name + "." + field
      • code + "." + field
      • code + "." + field type
      • code
    • 예) 오류 코드: typeMismatch, object name "user", field "age", field type: int
      • "typeMismatch.user.age"
      • "typeMismatch.age"
      • "typeMismatch.int"
      • "typeMismatch"
  • 동작 방식
    • rejectValue(), reject()는 내부에서 MessageCodesResolver를 사용한다. 여기에서 메시지 코드들을 생성한다.
    • FieldError, ObjectError의 생성자를 보면, 오류 코드를 하나가 아니라 여러 오류 코드를 가질 수 있다. MessageCodesResolver를 통해서 생성된 순서대로 오류 코드를 보관한다.
    • 이 부분을 BindingResult의 로그를 통해서 확인해보면
      codes [range.item.price, range.price, range.java.lang.Integer, range]
  • FieldErrorrejectValue("itemName", "required")
    다음 4가지 오류 코드를 자동으로 생성
    • required.item.itemName
    • required.itemName
    • required.java.lang.String
    • required
  • ObjectErrorreject("totalPriceMin")
    다음 2가지 오류 코드를 자동으로 생성
    • totalPriceMin.item
    • totalPriceMin
  • 오류 메시지 출력
    • 타임리프 화면을 렌더링 할 때 th:errors가 실행된다. 만약 이때 오류가 있다면 생성된 오류 메시지 코드를 순서대로 돌아가면서 메시지를 찾는다. 그리고 없으면 디폴트 메시지를 출력한다.

8. 오류 코드와 메시지 처리4

errors.properties

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

#==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} 까지 허용합니다.

9. 오류 코드와 메시지 처리5

검증 오류 코드는 다음과 같이 2가지로 나눌 수 있다.

  • 개발자가 직접 설정한 오류 코드 -> rejectValue()를 직접 호출
  • 스프링이 직접 검증 오류에 추가한 경우(주로 타입 정보가 맞지 않음)

error.properties

#추가
typeMismatch.java.lang.Integer=숫자를 입력해주세요.
typeMismatch=타입 오류입니다.
  • 스프링은 타입 오류가 발생하면 typeMismatch라는 오류 코드를 사용한다. 이 오류 코드가 MessageCodesResolver를 통하면서 4가지 메시지 코드가 생성된다.
  • errors.properties에 메시지 코드를 추가 하지 않으면 스프링이 생성한 기본 메시지가 출력된다.

10. Validator 분리1

@Component
public class ItemValidator implements Validator {

    @Override
    public boolean supports(Class<?> clazz) {
        return Item.class.isAssignableFrom(clazz);
        //item == clazz
        //item == subItem
    }

    @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, 1000000}, 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);
            }
        }
    }
}

Validator

public interface Validator {
	boolean supports(Class<?> clazz);
	void validate(Object target, Errors errors);
}
  • supports() {}: 해당 검증기를 지원하는지 여부 확인
  • validate(Object target, Errors errors): 검증 대상 객체와 BindingResult

addItemV5()

  • ItemValidator를 의존성 주입 받고 직접 호출한다.
    itemValidator.validate(item, bindingResult);

11. Validator 분리2

WebDataBinder를 통해서 사용하기

@InitBinder
public void init(WebDataBinder dataBinder) {
	log.info("init binder {}", dataBinder);
 	dataBinder.addValidators(itemValidator);
}
  • WebDataBinder는 스프링의 파라미터 바인딩의 역할을 해주고 검증 기능도 내부에 포함한다.
  • 위처럼 WebDataBinder에 검증기를 추가하면 해당 컨트롤러에서는 검증기를 자동으로 적용할 수 있다.
  • @InitBinder -> 해당 컨틀롤러에만 영향을 준다.

addItemV6()

  • validator를 직접 호출하는 부분이 없고, 대신에 검증 대상 앞(@ModelAttribute 앞)에 @Validated를 붙인다.
  • @Validated는 검증기를 실행하라는 애노테이션이다. 이 애노테이션이 붙으면 앞서 WebDataBinder에 등록한 검증기를 찾아서 실행한다. 여러 검증기를 등록한다면 그 중에 어떤 검증기가 실행되어야 할지 구분이 필요하다. 이때 supports()가 사용된다.
  • 여기서는 supports(Item.class)가 호출되고, 결과가 true이므로 ItemValidator의 validate()가 호출된다.

글로벌 설정 - 모든 컨트롤러에 다 적용

@SpringBootApplication
public class ItemServiceApplication implements WebMvcConfigurer {

	public static void main(String[] args) {
 		SpringApplication.run(ItemServiceApplication.class, args);
 	}
 
 	@Override
 	public Validator getValidator() {
 		return new ItemValidator();
 	}
}
  • 기존 컨트롤러의 @InitBinder를 제거해도 글로벌 설정으로 정상 동작.
  • 글로벌 설정을 하면 다음에 설명할 BeanValidator가 자동 등록되지 않는다.
  • 검증시 @Validated, @Valid 둘다 사용가능하다. javax.validation.@Valid를 사용하려면 build.gradle에 의존관계 추가가 필요하다.
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    @Validated는 스프링 전용 검증 애노테이션이고, @Valid는 자바 표준 검증 애노테이션이다.

5. 검증2 - Bean Validation

1. Bean Validation 이란?

  • Bean Validation은 특정한 구현체가 아니라 Bean Validation 2.0(JSR-380)이라는 기술 표준이다. 쉽게 이야기해서 검증 애노테이션과 여러 인터페이스의 모음이다. 마치 JPA가 표준 기술이고 그 구현체로 하이버네이트가 있는 것과 같다.
  • Bean Validation을 구현한 기술중에 일반적으로 사용하는 구현체는 하이버네이트 Validator이다.(ORM과는 관련 없다.)
  • 하이버네이트 Validator 관련 링크

2. Bean Validation - 시작

의존관계 추가

implementation 'org.springframework.boot:spring-boot-starter-validation'
  • build.gradle에 spring-boot-starter-validation 의존관계를 추가하면 라이브러리가 추가 된다.
  • Jakarta Bean Validation
    • jakarta.validation-api: Bean Validation 인터페이스
    • hibernate-validator: 구현체

테스트 코드

//Item - Bean Validation 애노테이션 적용
@Data
public class Item {
	
    private Long id;
 
 	@NotBlank
 	private String itemName;
 	
    @NotNull
 	@Range(min = 1000, max = 1000000)
 	private Integer price;
 
 	@NotNull
 	@Max(9999)
 	private Integer quantity;
 
 	public Item() {
 	}
 
 	public Item(String itemName, Integer price, Integer quantity) {
 		this.itemName = itemName;
 		this.price = price;
 		this.quantity = quantity;
 	}
}
  • 검증 애노테이션
    • @NotBlank: 빈값 + 공백만 있는 경우를 허용하지 않는다.
    • @NotNull: null을 허용하지 않는다.
    • @Range(min = 1000, max = 1000000): 범위 안의 값이어야 한다.
    • @Max(9999): 최대 9999까지만 허용한다.
  • 참고
    • javax.validation으로 시작하면 특정 구현에 관계없이 제공되는 표준 인터페이스
      -> 예) javax.validation.constraints.NotNull
    • org.hibernate.validator로 시작하면 하이버네이트 validator 구현체를 사용할 때만 제공되는 검증 기능.
      -> 예) org.hibernate.validator.constraints.Range
//Bean Validation 테스트 코드 작성
public class BeanValidationTest {

    @Test
    void beanValidation() {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();

        Item item = new Item();
        item.setItemName(" "); //공백
        item.setPrice(0);
        item.setQuantity(10000);

        Set<ConstraintViolation<Item>> violations = validator.validate(item);
        for (ConstraintViolation<Item> violation : violations) {
            System.out.println("violation = " + violation);
            System.out.println("violation.getMessage() = " 
            							+ violation.getMessage());
        }
    }
}
//검증기 생성
ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();
  • 위 코드와 같이 검증기를 생성한다. 이후 스프링과 통합하면 직접 이런 코드를 작성하지는 않는다.
//검증 실행
Set<ConstraintViolation<Item>> violations = validator.validate(item);
  • 검증 대상(item)을 직접 검증기에 넣고 그 결과를 받는다. Set에는 ConstraintViolation이라는 검증 오류가 담긴다. 결과가 비어있으면 검증 오류가 없는 것이다.
//실행 결과(일부 생략)
violation={interpolatedMessage='공백일 수 없습니다', propertyPath=itemName, 
rootBeanClass=class hello.itemservice.domain.item.Item, 
messageTemplate='{javax.validation.constraints.NotBlank.message}'}
violation.message=공백일 수 없습니다

violation={interpolatedMessage='9999 이하여야 합니다', propertyPath=quantity, 
rootBeanClass=class hello.itemservice.domain.item.Item, 
messageTemplate='{javax.validation.constraints.Max.message}'}
violation.message=9999 이하여야 합니다

violation={interpolatedMessage='1000에서 1000000 사이여야 합니다', 
propertyPath=price, rootBeanClass=class hello.itemservice.domain.item.Item, 
messageTemplate='{org.hibernate.validator.constraints.Range.message}'}
violation.message=1000에서 1000000 사이여야 합니다
  • ConstraintViolation 출력 결과를 보면, 검증 오류가 발생한 객체, 필드, 메시지 정보등 다양한 정보를 확인할 수 있다.

3. Bean Validation - 스프링 적용

addItem()

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

	//특정 필드가 아닌 복합 룰 검증
    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()) {
    	log.info("errors = {}", bindingResult);
        return "validation/v3/addForm";
    }

    //성공 로직
    Item savedItem = itemRepository.save(item);
    redirectAttributes.addAttribute("itemId", savedItem.getId());
    redirectAttributes.addAttribute("status", true);
    return "redirect:/validation/v3/items/{itemId}";
}
//기존에 등록한 ItemValidator는 제거 한다. 오류 검증기가 중복 적용된다.
/*
@InitBinder
public void init(WebDataBinder dataBinder) {
	log.info("init binder {}", dataBinder);
 	dataBinder.addValidators(itemValidator);
}
*/
  • 스프링 부트가 spring-boot-starter-validation 라이브러리를 넣으면 자동으로 Bean Validator를 인지하고 스프링에 통합한다.
  • LocalValidatorFactoryBean을 글로벌 Validator로 등록한다. 이 Validator는 @NotNull같은 애노테이션을 보고 검증을 수행한다. 이렇게 글로벌 Validator가 적용되어 있기 때문에, @Valid,@Validated만 적용하면 된다. 검증 오류가 발생하면, FieldError, ObjectError를 생성해서 BindingResult에 담아준다.
  • 글로벌 Validator를 직접 등록하면 스프링 부트는 Bean Validator를 글로벌 Validator로 등록하지 않는다. 따라서 애노테이션 기반의 빈 검증기가 동작하지 않는다.
  • @Validated, @Valid 둘 중 아무거나 사용해도 동일하게 작동하지만, @Validated는 내부에 groups라는 기능을 포함하고 있다.

검증 순서

  • 1.@ModelAttribute 각각의 필드에 타입 변환 시도
      1. 성공하면 다음으로
      1. 실패하면 typeMismatch로 FieldError 추가
    1. Validator 적용
  • 바인딩에 성공한 필드만 Bean Validation 적용
    • BeanValidator는 바인딩에 실패한 필드는 BeanValidation을 적용하지 않는다. 생각해보면 타입 변환에 성공해서 바인딩에 성공한 필드여야 BeanValidation 적용이 의미 있다. (일단 모델 객체에 바인딩 받는 값이 정상으로 들어와야 검증도 의미가 있다.)
    • @ModelAttribute -> 각각의 필드 타입 변환 시도 -> 변환에 성공한 필드만 BeanValidation 적용
      • 예) itemName에 문자 "A"입력 -> 타입 변환 성공 -> itemName필드에 BeanValidation적용
      • 예) price에 문자 "A"입력 -> "A"를 숫자 타입 변환 시도 실패 -> typeMismatch FieldError 추가 -> price필드는 BeanValidation 적용X

4. Bean Validation - 에러 코드

errors.properties

#Bean Validation 추가
NotBlank={0} 공백X 
Range={0}, {2} ~ {1} 허용
Max={0}, 최대 {1}
  • Bean Validation을 적용하고 bindingResult에 등록된 검증 오류 코드를 보면 오류 코드가 애노테이션 이름으로 등록된다. 마치 typeMismatch와 유사하다. NotBlank라는 오류 코드를 기반으로 MessageCodesResolver를 통해 다양한 메시지 코드가 순서대로 생성된다.
    • NotBlank.item.itemName
    • NotBlank.itemName
    • NotBlank.java.lang.String
    • NotBlank
  • errors.properties에 메시지를 등록하면 Bean Validation이 기본으로 제공하는 오류 메시지를 변경할 수 있다.
  • {0}은 필드명, {1}, {2} ...은 각 애노테이션 마다 다르다.
  • BeanValidation 메시지 찾는 순서
    1. 생성된 메시지 코드 순서대로 messageSource에서 메시지 찾기
    2. 애노테이션의 message속성 사용 -> @NotBlank(message = "공백! {0}")
    3. 라이브러리가 제공하는 기본 값 사용 -> 공백일 수 없습니다.

5. Bean Validation - 오브젝트 오류

@ScriptAssert()

@Data
@ScriptAssert(lang = "javascript", script = "_this.price * _this.quantity >= 10000")
public class Item {
	//...
}
  • Bean Validation에서 특정 필드(FieldError)가 아닌 해당 오브젝트 관련 오류(ObjectError)는 @ScriptAssert()를 사용할 수 있다.
  • 메시지 코드
    • ScriptAssert.item
    • ScriptAssert
  • 실제 사용해보면 제약이 많고 복잡하다. 그리고 실무에서는 검증 기능이 해당 객체의 범위를 넘어서는 경우들도 종종 등장하는데, 그런 경우 대응이 어렵다. 따라서 오브젝트 오류(글로벌 오류)의 경우 직접 자바 코드로 작성하는 것을 권장한다. (위의 addItem() 코드에 있다.)

6. Bean Validation - 수정에 적용

edit()

@PostMapping("/{itemId}/edit")
public String edit(@PathVariable Long itemId, 
			@Validated @ModelAttribute Item item, BindingResult bindingResult) {

	//특정 필드가 아닌 복합 룰 검증
    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()) {
    	log.info("errors = {}", bindingResult);
        return "validation/v3/editForm";
    }

    itemRepository.update(itemId, item);
    return "redirect:/validation/v3/items/{itemId}";
}

editForm.html

  • .field-error css 추가
  • 글로벌 오류 메시지
  • 상품명, 가격, 수량 필드에 검증 기능 추가

7. Bean Validation - 한계

수정시 검증 요구사항

  • 등록시에는 quantity 수량을 최대 9999까지 등록할 수 있지만 수정시에는 수량을 무제한으로 변경할 수 있다.
  • 등록시에는 id에 값이 없어도 되지만, 수정시에는 id 값이 필수이다.
    • 현재 구조에서는 수정시 item의 id값은 항상 들어있도록 로직이 구성되어 있다. 그래서 검증하지 않아도 된다고 생각할 수 있다. 그런데 HTTP 요청은 언제든지 악의적으로 변경해서 요청할 수 있으므로 서버에서 항상 검증해야 한다.
  • item은 등록과 수정에서 검증 조건의 충돌이 발생하고, 등록과 수정은 같은 BeanValidation을 적용할 수 없다.

8. Bean Validation - groups

groups 적용

//저장용 groups 생성
public interface SaveCheck {
}
//수정용 groups 생성
public interface UpdateCheck {
}
//Item - groups 적용
@Data
public class Item {
	
    @NotNull(groups = UpdateCheck.class) //수정시에만 적용
 	private Long id;
 
 	@NotBlank(groups = {SaveCheck.class, UpdateCheck.class})
 	private String itemName;
 
 	@NotNull(groups = {SaveCheck.class, UpdateCheck.class})
 	@Range(min = 1000, max = 1000000, groups = {SaveCheck.class, 
    												UpdateCheck.class})
 	private Integer price;
 
 	@NotNull(groups = {SaveCheck.class, UpdateCheck.class})
 	@Max(value = 9999, groups = SaveCheck.class) //등록시에만 적용
 	private Integer quantity;
 
 	public Item() {
 	}
 
 	public Item(String itemName, Integer price, Integer quantity) {
 		this.itemName = itemName;
 		this.price = price;
 		this.quantity = quantity;
	}
}
//저장 로직 - groups 적용
@PostMapping("/add")
public String addItemV2(@Validated(SaveCheck.class) @ModelAttribute Item item,
		BindingResult bindingResult, RedirectAttributes redirectAttributes) {
	//...
}
//수정 로직 - groups 적용
@PostMapping("/{itemId}/edit")
public String editV2(@PathVariable Long itemId, @Validated(UpdateCheck.class) 
					@ModelAttribute Item item, BindingResult bindingResult) {
	//...
}
  • @Valid에는 groups를 적용할 수 있는 기능이 없다.
  • groups기능을 사용하니 Item은 물론이고, 전반적으로 복잡도가 올라갔다. 실무에서는 주로 다음에 소개하는 등록용 폼 객체와 수정용 폼 객체를 분리해서 사용한다.

9. Form 전송 객체 분리

ItemSaveForm

@Data
public class ItemSaveForm {
	
    @NotBlank
 	private String itemName;
 	
    @NotNull
 	@Range(min = 1000, max = 1000000)
 	private Integer price;
 	
    @NotNull
 	@Max(value = 9999)
 	private Integer quantity;

}

ItemUpdateForm

@Data
public class ItemUpdateForm {
	
    @NotNull
 	private Long id;
 	
    @NotBlank
 	private String itemName;
 
 	@NotNull
 	@Range(min = 1000, max = 1000000)
 	private Integer price;
 
 	//수정에서는 수량은 자유롭게 변경할 수 있다.
 	private Integer quantity;

}

addItem()

@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()) {
    	log.info("errors = {}", bindingResult);
        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}";
}
  • Item대신에 ItemSaveForm을 전달 받는다. 그리고 @Validated로 검증도 수행하고, BindingResult로 검증 결과도 받는다.
  • @ModelAttribute("item")에 item을 넣지 않으면 ItemSaveForm이라는 이름으로 MVC Model에 담기게 된다. 이렇게 되면 뷰 템플릿에서 접근하는 th:object이름도 함께 변경해주어야 한다.
  • 폼 객체의 데이터를 기반으로 Item 객체를 생성한다. 이렇게 변환하는 과정이 추가된다.

edit()

@PostMapping("/{itemId}/edit")
public String edit(@PathVariable Long itemId, 
					@Validated @ModelAttribute("item") ItemUpdateForm form, 
                    BindingResult bindingResult) {

	//특정 필드가 아닌 복합 룰 검증
    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()) {
    	log.info("errors = {}", bindingResult);
        return "validation/v4/editForm";
    }

    Item itemParam = new Item();
    itemParam.setItemName(form.getItemName());
    itemParam.setPrice(form.getPrice());
    itemParam.setQuantity(form.getQuantity());

    itemRepository.update(itemId, itemParam);
    return "redirect:/validation/v4/items/{itemId}";
}
  • 수정의 경우도 등록과 같다. 그리고 폼 객체를 Item 객체로 변환하는 과정을 거친다.

10. Bean Validation - HTTP 메시지 컨버터

  • @Valid, @Validated는 HttpMessageConverter(@RequestBody)에도 적용할 수 있다.
  • API의 경우 3가지를 나누어 생각해야 한다.
    • 성공 요청: 성공
    • 실패 요청: JSON을 객체로 생성하는 것 자체가 실패함
    • 검증 오류 요청: JSON을 객체로 생성하는 것은 성공했고, 검증에서 실패함

ValidationItemApiController

@Slf4j
@RestController
@RequestMapping("/validation/api/items")
public class ValidationItemApiController {

    @PostMapping("/add")
    public Object addItem(@RequestBody @Validated ItemSaveForm form, BindingResult bindingResult) {

        log.info("API 컨트롤러 호출");

        if (bindingResult.hasErrors()) {
            log.info("검증 오류 발생 error={}", bindingResult);
            return bindingResult.getAllErrors();
        }

        log.info("성공 로직 실행");
        return form;
    }
}
//성공 요청
POST http://localhost:8080/validation/api/items/add
{"itemName":"hello", "price":1000, "quantity": 10}
//실패 요청
POST http://localhost:8080/validation/api/items/add
{"itemName":"hello", "price":"A", "quantity": 10}
//실패 요청 결과
{
	"timestamp": "2021-04-20T00:00:00.000+00:00",
 	"status": 400,
 	"error": "Bad Request",
 	"message": "",
 	"path": "/validation/api/items/add"
}
//실패 요청 로그
.w.s.m.s.DefaultHandlerExceptionResolver : Resolved 
[org.springframework.http.converter.HttpMessageNotReadableException: JSON parse 
error: Cannot deserialize value of type `java.lang.Integer` from String "A": 
not a valid Integer value; nested exception is 
com.fasterxml.jackson.databind.exc.InvalidFormatException: Cannot deserialize 
value of type `java.lang.Integer` from String "A": not a valid Integer value
 at [Source: (PushbackInputStream); line: 1, column: 30] (through reference 
chain: hello.itemservice.domain.item.Item["price"])]
  • HttpMessageConverter에서 요청 JSON을 itemSaveForm객체로 생성하는데 실패한다. 이 경우는 ItemSaveForm객체를 만들지 못하기 때문에 컨트롤러 자체가 호출되지 않고 그 전에 예외가 발생한다. 물론 Validator도 실행되지 않는다.
//검증 오류 요청
POST http://localhost:8080/validation/api/items/add
{"itemName":"hello", "price":1000, "quantity": 10000}
  • HttpMessageConverter는 성공하지만 검증(Validator)에서 오류가 발생 한다. 수량(quantity)이 10000이면 BeanValidation @Max(9999)에서 걸린다.
//검증 오류 결과
[
	{
 		"codes": [
 			"Max.itemSaveForm.quantity",
 			"Max.quantity",
 			"Max.java.lang.Integer",
 			"Max"
 		],
 		"arguments": [
 			{
 				"codes": [
 					"itemSaveForm.quantity",
 					"quantity"
				 ],
 				"arguments": null,
 				"defaultMessage": "quantity",
 				"code": "quantity"
 			},
 			9999
 		],
 		"defaultMessage": "9999 이하여야 합니다",
 		"objectName": "itemSaveForm",
 		"field": "quantity",
 		"rejectedValue": 10000,
 		"bindingFailure": false,
 		"code": "Max"
	}
]
  • return bindingResult.getAllErrors();는 ObjectError와 FieldError를 반환한다. 스프링이 이 객체를 JSON으로 변환해서 클라이언트에 전달했다. 여기서는 예시로 보여주기 위해서 검증 오류 객체들을 그대로 반환했다. 실제 개발할 때는 이 객체들을 그대로 사용하지 말고, 필요한 데이터만 뽑아서 별도의 API 스펙을 정의하고 그에 맞는 객체를 만들어서 반환해야 한다.
//검증 오류 요청 로그
API 컨트롤러 호출
검증 오류 발생, errors=org.springframework.validation.BeanPropertyBindingResult: 1 
errors
Field error in object 'itemSaveForm' on field 'quantity': rejected value 
[99999]; codes 
[Max.itemSaveForm.quantity,Max.quantity,Max.java.lang.Integer,Max]; arguments 
[org.springframework.context.support.DefaultMessageSourceResolvable: codes 
[itemSaveForm.quantity,quantity]; arguments []; default message 
[quantity],9999]; default message [9999 이하여야 합니다]

@ModelAttribute vs RequestBody

  • HTTP 요청 파라미터를 처리하는 @ModelAttribute는 각각의 필드 단위로 세밀하게 적용된다. 그래서 특정 필드에 타입이 맞지 않는 오류가 발생해도 나머지 필드는 정상 처리할 수 있었다. HttpMessageConverter는 @ModelAttribute와 다르게 각각의 필드 단위로 적용되는 것이 아니라, 전체 객체 단위로 적용된다. 따라서 메시지 컨버터의 작동이 성공해서 ItemSaveForm객체를 만들어야 @Valid, @Validated가 적용된다.
  • @ModelAttribute는 필드 단위로 정교하게 바인딩이 적용된다. 특정 필드가 바인딩 되지 않아도 나머지 필드는 정상 바인딩 되고, Validator를 사용한 검증도 적용할 수 있다.
  • @RequestBody는 HttpMessageConverter 단계에서 JSON 데이터를 객체로 변경하지 못하면 이후 단계 자체가 진행되지 않고 예외가 발생한다. 컨트롤러도 호출되지 않고, Validator도 적용할 수 없다.
  • HttpMessageConverter 단계에서 실패하면 예외가 발생한다. 예외 발생시 원하는 모양으로 예외를 처리하는 방법은 예외 처리 부분에서 다룬다.

6. 로그인 처리1 - 쿠키, 세션

1. 로그인 요구사항

  • 홈 화면 - 로그인 전
    • 회원 가입
    • 로그인
  • 홈 화면 - 로그인 후
    • 본인 이름(누구님 환영합니다.)
    • 상품 관리
    • 로그 아웃
  • 보안 요구사항
    • 로그인 사용자만 상품에 접근하고, 관리할 수 있음
    • 로그인 하지 않은 사용자가 상품 관리에 접근하면 로그인 화면으로 이동
  • 회원 가입, 상품 관리

2. package 구조

도메인이 가장 중요하다.

  • hello.login
    • domain
      • item
      • login
      • member
    • web
      • item
      • login
      • member
  • 도메인 = 화면, UI, 기술 인프라 등등의 영역은 제외한 시스템이 구현해야 하는 핵심 비즈니스 업무 영역을 말함.
  • 향후 web을 다른 기술로 바꾸어도 도메인은 그대로 유지할 수 있어야 한다. 이렇게 하려면 web은 domain을 알고있지만 domain은 web을 모르도록 설계해야 한다. 이것을 web은 domain을 의존하지만, domain은 web을 의존하지 않는다고 표현한다. 예를 들어 web 패키지를 모두 삭제해도 domain에는 전혀 영향이 없도록 의존관계를 설계하는 것이 중요하다. 반대로 이야기하면 domain은 web을 참조하면 안된다.

3. 홈 화면

HomeController

@GetMapping("/")
public String home() {
	return "home";
}

templates/home.html

  • 회원가입, 로그인 버튼 개발

4. 회원 가입

Member

@Data
public class Member {

    private Long id;

    @NotEmpty
    private String loginId; //로그인 ID
    @NotEmpty
    private String name; //사용자 이름
    @NotEmpty
    private String password;

}

MemberRepository

/**
 * 동시성 문제가 고려되어 있지 않음, 실무에서는 ConcurrentHashMap, AtomicLong 사용 고려
 */
@Slf4j
@Repository
public class MemberRepository {

    private static Map<Long, Member> store = new HashMap<>(); //static 사용
    private static long sequence = 0L; //static 사용

    public Member save(Member member) {
        member.setId(++sequence);
        log.info("save: member={}", member);
        store.put(member.getId(), member);
        return member;
    }

    public Member findById(Long id) {
        return store.get(id);
    }

    public Optional<Member> findByLoginId(String loginId) {
        /*List<Member> all = findAll();
        for (Member m : all) {
            if (m.getLoginId().equals(loginId)) {
                return Optional.of(m);
            }
        }
        return Optional.empty();*/

        return findAll().stream()
                .filter(m -> m.getLoginId().equals(loginId))
                .findFirst();
    }

    public List<Member> findAll() {
        return new ArrayList<>(store.values());
    }

    public void clearStore() {
        store.clear();
    }
}

MemberController

@Controller
@RequiredArgsConstructor
@RequestMapping("/members")
public class MemberController {

    private final MemberRepository memberRepository;

    @GetMapping("/add")
    public String addForm(@ModelAttribute("member") Member member) {
        return "members/addMemberForm";
    }

    @PostMapping("/add")
    public String save(@Valid @ModelAttribute Member member,
    								BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            return "members/addMemberForm";
        }

        memberRepository.save(member);
        return "redirect:/";
    }
}

addMemberForm.html

  • 로그인ID, 비밀번호, 이름 입력란
  • 회원 가입, 취소 버튼

회원용 테스트 데이터 추가

@Component
@RequiredArgsConstructor
public class TestDataInit {

    private final ItemRepository itemRepository;
    private final MemberRepository memberRepository;

    /**
     * 테스트용 데이터 추가
     */
    @PostConstruct
    public void init() {
        itemRepository.save(new Item("itemA", 10000, 10));
        itemRepository.save(new Item("itemB", 20000, 20));

        Member member = new Member();
        member.setLoginId("test");
        member.setPassword("test!");
        member.setName("테스터");

        memberRepository.save(member);

    }

}

5. 로그인 기능

LoginService

@Service
@RequiredArgsConstructor
public class LoginService {

    private final MemberRepository memberRepository;

    /**
     * @return null 로그인 실패
     */
    public Member login(String loginId, String password) {
        /*Optional<Member> findMemberOptional 
        				= memberRepository.findByLoginId(loginId);
        Member member = findMemberOptional.get();
        if (member.getPassword().equals(password)) {
            return member;
        } else {
            return null;
        }*/

        return memberRepository.findByLoginId(loginId)
                .filter(m -> m.getPassword().equals(password))
                .orElse(null);
    }
}

LoginForm

@Data
public class LoginForm {

    @NotEmpty
    private String loginId;

    @NotEmpty
    private String password;
}

LoginController

@Slf4j
@Controller
@RequiredArgsConstructor
public class LoginController {
	
    private final LoginService loginService;
 	
    @GetMapping("/login")
 	public String loginForm(@ModelAttribute("loginForm") LoginForm form) {
 		return "login/loginForm";
 	}
 
 	@PostMapping("/login")
 	public String login(@Valid @ModelAttribute LoginForm form,
    										BindingResult bindingResult) {
 		if (bindingResult.hasErrors()) {
 			return "login/loginForm";
 		}
 
 		Member loginMember 
        		= loginService.login(form.getLoginId(), form.getPassword());
 
 		if (loginMember == null) {
 			bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
 			return "login/loginForm";
 		}
 
 		//로그인 성공 처리 TODO
 		
        return "redirect:/";
	}
    
}

loginForm.html

  • 로그인 ID, 비밀번호 입력란
  • 로그인, 취소 버튼
  • loginId, password가 틀리면 글로벌 오류가 나타난다.

6. 로그인 처리하기 - 쿠키 사용

쿠키

  • 서버에서 로그인에 성공하면 HTTP 응답에 쿠키를 담아서 브라우저에 전달하자. 그러면 브라우저는 앞으로 해당 쿠키를 지속해서 보내준다.
  • 영속 쿠키: 만료 날짜를 입력하면 해당 날짜까지 유지
  • 세션 쿠키: 만료 날짜를 생략하면 브라우저 종료시 까지만 유지

LoginController - login()

//코드 추가
//쿠키에 시간 정보를 주지 않으면 세션 쿠키(브라우저 종료시 모두 종료)
Cookie idCookie = new Cookie("memberId", String.valueOf(loginMember.getId()));
response.addCookie(idCookie);
  • 로그인에 성공하면 쿠키를 생성하고 HttpServletResponse에 담는다. 쿠키 이름은 memberId이고, 값은 회원의 id를 담아둔다. 웹 브라우저는 종료 전까지 회원의id를 서버에 계속 보내줄 것이다.
  • 크롬 브라우저를 통해 HTTP 응답 헤더에 쿠키가 추가된 것을 확인할 수 있다.

HomeController

@GetMapping("/")
public String homeLogin(@CookieValue(name = "memberId", required = false) 
						Long memberId, Model model) {

	if (memberId == null) {
    	return "home";
    }

    //로그인
    Member loginMember = memberRepository.findById(memberId);
    if (loginMember == null) {
    	return "home";
    }

    model.addAttribute("member", loginMember);
    return "loginHome";
}
  • @CookieValue를 사용하면 편리하게 쿠키를 조회할 수 있다.
  • 로그인 하지 않은 사용자도 홈에 접근할 수 있기 때문에 required = false를 사용한다.
  • 로그인 쿠키(memberId)가 없는 사용자는 기존 home으로 보낸다. 추가로 로그인 쿠키가 있어도 회원이 없으면 home으로 보낸다.
  • 로그인 쿠키(memberId)가 있는 사용자는 로그인 사용자 전용 홈 화면인 loginHome으로 보낸다. 추가로 홈 화면에 회원 관련 정보도 출력해야 해서 member데이터도 모델에 담아서 전달한다.

loginHome.html

  • th:text="|로그인: ${member.name}|": 로그인에 성공한 사용자 이름을 출력한다.
  • 상품 관리, 로그아웃 버튼
  • 로그인에 성공시 세션 쿠키가 지속해서 유지되고, 웹 브라우저에서 서버에 요청시 memberId쿠키를 계속 보내준다.

7. 로그아웃 기능

LoginController

//logout 기능 추가
@PostMapping("/logout")
public String logout(HttpServletResponse response) {
	expireCookie(response, "memberId");
 	return "redirect:/";
}

private void expireCookie(HttpServletResponse response, String cookieName) {
	Cookie cookie = new Cookie(cookieName, null);
 	cookie.setMaxAge(0);
 	response.addCookie(cookie);
}
  • 로그아웃도 응답 쿠키를 생성하는데 Max-Age=0을 확인할 수 있다. 해당 쿠키는 즉시 종료된다.

8. 쿠키와 보안 문제

보안 문제

  • 쿠키 값은 임으로 변경할 수 있다.
    • 클라이언트가 쿠키를 강제로 변경하면 다른 사용자가 된다.
    • 실제 웹브라우저 개발자모드 -> Application -> Cookie 변경으로 확인
  • 쿠키에 보관된 정보는 훔쳐갈 수 있다.
    • 쿠키에 개인정보가 있다면 이 정보는 웹 브라우저에도 보관되고, 네트워크 요청마다 계속 클라이언트에서 서버로 전달된다.
    • 쿠키의 정보가 나의 로컬 PC에서 털릴 수도 있고, 네트워크 전송 구간에서 털릴 수도 있다.
  • 해커가 쿠키를 한번 훔쳐가면 평생 사용할 수 있다.

대안

  • 쿠키에 중요한 값을 노출하지 않고, 사용자 별로 예측 불가능한 임의의 토큰(랜덤 값)을 노출하고, 서버에서 토큰과 사용자 id를 매핑해서 인식한다. 그리고 서버에서 토큰을 관리한다.
  • 해커가 토큰을 털어가도 시간이 지나면 사용할 수 없도록 서버에서 해당 토큰의 만료시간을 짧게(예:30분) 유지한다. 또는 해킹이 의심되는 경우 서버에서 해당 토큰을 강제로 제거하면 된다.

9. 로그인 처리하기 - 세션 동작 방식

목표
앞서 쿠키에 중요한 정보를 보관하는 방법은 여러가지 보안 이슈가 있었다. 이 문제를 해결하려면 결국 중요한 정보를 모두 서버에 저장해야 한다. 그리고 클라이언트와 서버는 추정 불가능한 임의의 식별자 값으로 연결해야 한다. 이렇게 서버에 중요한 정보를 보관하고 연결을 유지하는 방법을 세션이라 한다.

로그인

  • 사용자가 loginId, password 정보를 전달하면 서버에서 해당 사용자가 맞는지 확인한다.

세션 생성

  • 세션 ID를 생성하는데, 추정 불가능해야 한다. -> UUID
  • 생성된 세션 ID와 세션에 보관할 값(memberA)을 서버의 세션 저장소에 보관한다.

세션ID를 응답 쿠키로 전달

  • 클라이언트와 서버는 결국 쿠키로 연결이 되어야 한다.
    • 서버는 클라이언트에 mySessionId라는 이름으로 세션ID만 쿠키에 담아서 전달한다.
    • 클라이언트는 쿠키 저장소에 mySessionId쿠키를 보관한다.
  • 회원과 관련된 정보는 전혀 클라이언트에 전달하지 않는다. 오직 추정 불가능한 세션ID만 쿠키를 통해 클라이언트에 전달한다.

클라이언트의 세션ID 쿠키 전달

  • 클라이언트는 요청시 항상 mySessionId쿠키를 전달한다.
  • 서버에서는 클라이언트가 전달한 mySessionId쿠키 정보로 세션 저장소를 조회해서 로그인시 보관한 세션 정보를 사용한다.

10. 로그인 처리하기 - 세션 직접 만들기

세션 관리는 크게 다음 3가지 기능을 제공하면 된다.

  • 세션 생성
    • sessionId 생성 (임의의 추정 불가능한 랜덤 값)
    • 세션 저장소에 sessionId와 보관할 값 저장
    • sessionId로 응답 쿠키를 생성해서 클라이언트에 전달
  • 세션 조회
    • 클라이언트가 요청한 sessionId 쿠키의 값으로, 세션 저장소에 보관한 값 조회
  • 세션 만료
    • 클라이언트가 요청한 sessionId 쿠키의 값으로, 세션 저장소에 보관한 sessionId와 값 제거

SessionManager - 세션 관리

/**
 * 세션 관리
 */
@Component
public class SessionManager {

    public static final String SESSION_COOKIE_NAME = "mySessionId";
    private Map<String, Object> sessionStore = new ConcurrentHashMap<>();

    /**
     * 세션 생성
     */
    public void createSession(Object value, HttpServletResponse response) {

        //세션 id를 생성하고, 값을 세션에 저장
        String sessionId = UUID.randomUUID().toString();
        sessionStore.put(sessionId, value);

        //쿠키 생성
        Cookie mySessionCookie = new Cookie(SESSION_COOKIE_NAME, sessionId);
        response.addCookie(mySessionCookie);
    }

    /**
     * 세션 조회
     */
    public Object getSession(HttpServletRequest request) {
        /*Cookie[] cookies = request.getCookies();
        if (cookies == null) {
            return null;
        }
        for (Cookie cookie : cookies) {
            if (cookie.getName().equals(SESSION_COOKIE_NAME)) {
                return sessionStore.get(cookie.getValue());
            }
        }
        return null;*/

        Cookie sessionCookie = findCookie(request, SESSION_COOKIE_NAME);
        if (sessionCookie == null) {
            return null;
        }
        return sessionStore.get(sessionCookie.getValue());
    }

    /**
     * 세션 만료
     */
    public void expire(HttpServletRequest request) {
        Cookie sessionCookie = findCookie(request, SESSION_COOKIE_NAME);
        if (sessionCookie != null) {
            sessionStore.remove(sessionCookie.getValue());
        }
    }

    public Cookie findCookie(HttpServletRequest request, String cookieName) {
        if (request.getCookies() == null) {
            return null;
        }
        return Arrays.stream(request.getCookies())
                .filter(cookie -> cookie.getName().equals(cookieName))
                .findAny()
                .orElse(null);
    }
}

SessionManagerTest

class SessionManagerTest {

    SessionManager sessionManager = new SessionManager();

    @Test
    void sessionTest() {

        //세션 생성
        MockHttpServletResponse response = new MockHttpServletResponse();
        Member member = new Member();
        sessionManager.createSession(member, response);

        //요청에 응답 쿠키 저장
        MockHttpServletRequest request = new MockHttpServletRequest();
        request.setCookies(response.getCookies());

        //세션 조회
        Object result = sessionManager.getSession(request);
        assertThat(result).isEqualTo(member);

        //세션 만료
        sessionManager.expire(request);
        Object expired = sessionManager.getSession(request);
        assertThat(expired).isNull();
    }
}
  • HttpServletRequest, HttpServletResponse 객체를 직접 사용할 수 없기 때문에 테스트에서 비슷한 역할을 해주는 가짜 MockHttpServletRequest, MockHttpServletResponse를 사용했다.

11. 로그인 처리하기 - 직접 만든 세션 적용

LoginController

//loginV2()
@PostMapping("/login")
public String loginV2(@Valid @ModelAttribute LoginForm form, 
				BindingResult bindingResult, HttpServletResponse response) {
	if (bindingResult.hasErrors()) {
    	return "login/loginForm";
    }

    Member loginMember 
    		= loginService.login(form.getLoginId(), form.getPassword());

    if (loginMember == null) {
    	bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
        return "login/loginForm";
    }

    // 로그인 성공 처리

    //세션 관리자를 통해 세션을 생성하고, 회원 데이터 보관
    sessionManager.createSession(loginMember, response);

    return "redirect:/";
}
//logoutV2()
@PostMapping("/logout")
public String logoutV2(HttpServletRequest request) {
	sessionManager.expire(request);
 	return "redirect:/";
}
  • private final SessionManager sessionManager; 주입
  • sessionManager.createSession(loginMember, response);
    로그인 성공시 세션을 등록한다. 세션에 loginMember를 저장해두고, 쿠키도 함께 발행한다.
  • 로그아웃시 해당 세션의 정보를 제거한다.

HomeController

@GetMapping("/")
public String homeLoginV2(HttpServletRequest request, Model model) {

	//세션 관리자에 저장된 회원 정보 조회
    Member member = (Member) sessionManager.getSession(request);
    if (member == null) {
    	return "home";
    }

	//로그인
    model.addAttribute("member", member);
    return "loginHome";
}
  • private final SessionManager sessionManager; 주입
  • 세션 관리자에서 저장된 회원 정보를 조회한다. 만약 회원 정보가 없으면, 쿠키나 세션이 없는 것 이므로 로그인 되지 않은 것으로 처리한다.

정리

  • 사실 세션이라는 것이 뭔가 특별한 것이 아니라 단지 쿠키를 사용하는데, 서버에서 데이터를 유지하는 방법일 뿐이라는 것을 이해했을 것이다. 이제 직접 만드는 세션 말고, 서블릿이 공식 지원하는 세션을 알아보자. 세션을 일정시간 사용하지 않으면 해당 세션을 삭제하는 기능을 제공한다.

12. 로그인 처리하기 - 서블릿 HTTP 세션1

HttpSession 소개

  • 서블릿이 제공하는 HttpSession도 결국 우리가 직접 만든 SessionManager와 같은 방식으로 동작한다. 서블릿을 통해 HttpSession을 생성하면 다음과 같은 쿠키를 생성한다. 쿠키 이름이 JSESSIONID이고, 값은 추정 불가능한 랜덤 값이다.
    예) Cookie: JSESSIONID=5B78E23B513F50164D6FDD8C97B0AD05

SessionConst

//상수만 가져다 쓸거기 때문에 추상클래스나, 인터페이스로 하는게 좋다
public abstract class SessionConst {
    public static final String LOGIN_MEMBER = "loginMember";
}

LoginController

//loginV3()
@PostMapping("/login")
public String loginV3(@Valid @ModelAttribute LoginForm form, 
					BindingResult bindingResult, HttpServletRequest request) {
	if (bindingResult.hasErrors()) {
    	return "login/loginForm";
    }

    Member loginMember 
    			= loginService.login(form.getLoginId(), form.getPassword());

    if (loginMember == null) {
    	bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
        return "login/loginForm";
    }

    // 로그인 성공 처리
    // 세션이 있으면 있는 세션 반환, 없으면 신규 세션을 생성
    HttpSession session = request.getSession();
    //세션에 로그인 회원 정보 보관
    session.setAttribute(SessionConst.LOGIN_MEMBER, loginMember);

    return "redirect:/";
}
//logoutV3()
@PostMapping("/logout")
public String logoutV3(HttpServletRequest request) {
	//세션을 삭제한다.
	HttpSession session = request.getSession(false);
    if (session != null) {
    	session.invalidate();
    }
    return "redirect:/";
}
  • 세션 생성과 조회
    public HttpSession getSession(boolean create);
    • request.getSession(true)
      • 세션이 있으면 기존 세션을 반환한다.
      • 세션이 없으면 새로운 세션을 생성해서 반환한다.
    • request.getSession(false)
      • 세션이 있으면 기존 세션을 반환한다.
      • 세션이 없으면 새로운 세션을 생성하지 않는다. null을 반환한다.
  • request.getSession(): 신규 세션을 생성하는 request.getSession(true)와 동일.
  • 세션에 로그인 회원 정보 보관
    session.setAttribute(SessionConst.LOGIN_MEMBER, loginMember);
    • 세션에 데이터를 보관하는 방법은 request.setAttribute()와 비슷하다. 하나의 세션에 여러 값을 저장할 수 있다.
  • session.invalidate(): 세션을 제거한다.

HomeController

@GetMapping("/")
public String homeLoginV3(HttpServletRequest request, Model model) {

	//세션이 없으면 home
	HttpSession session = request.getSession(false);
    if (session == null) {
    	return "home";
    }

    Member loginMember = (Member) session.getAttribute(SessionConst.LOGIN_MEMBER);

    //세션에 회원 데이터가 없으면 home
    if (loginMember == null) {
    	return "home";
    }

    //세션이 유지되면 로그인으로 이동
    model.addAttribute("member", loginMember);
    return "loginHome";
}
  • request.getSession(false): request.getSession()을 사용하면 로그인 하지 않은 사용자도 의미없는 세션이 만들어진다. 따라서 세션을 찾아서 사용하는 시점에는 create: false 옵션을 사용해서 세션을 생성하지 않아야 한다.
  • session.getAttribute(SessionConst.LOGIN_MEMBER): 로그인 시점에 세션에 보관한 회원 객체를 찾는다.
  • 실행시 JSESSIONID쿠키가 적절하게 생성되는 것을 확인할 수 있다.

13. 로그인 처리하기 - 서블릿 HTTP 세션2

@SessionAttribute

  • 스프링은 세션을 더 편리하게 사용할 수 있도록 @SessionAttribute를 지원한다. 이미 로그인 된 사용자를 찾을 때는 다음과 같이 사용하면 된다. 이 기능은 세션을 생성하지 않는다.
    @SessionAttribute(name = "loginMember", required = false) Member loginMember

HomeController

@GetMapping("/")
public String homeLoginV3Spring(
	@SessionAttribute(name = SessionConst.LOGIN_MEMBER, 
    					required = false) Member loginMember, Model model) {

    //세션에 회원 데이터가 없으면 home
    if (loginMember == null) {
    	return "home";
    }

    //세션이 유지되면 로그인으로 이동
    model.addAttribute("member", loginMember);
    return "loginHome";
}

TrackingModes

  • 로그인을 처음 시도하면 URL이 다음과 같이 jsessionid를 포함하고 있는 것을 확인할 수 있다.
    http://localhost:8080/;jsessionid=F59911518B921DF62D09F0DF8F83F872
    • 이것은 웹 브라우저가 쿠키를 지원하지 않을 때 쿠키 대신 URL을 통해서 세션을 유지하는 방법이다. 이 방법을 사용하려면 URL에 이 값을 계속 포함해서 전달해야 한다. 타임리프 같은 템플릿은 엔진을 통해서 링크를 걸면 jsessionid를 URL에 자동으로 포함해준다. 서버 입장에서 웹 브라우저가 쿠키를 지원하는지 하지 않는지 최초에는 판단하지 못하므로, 쿠키 값도 전달하고, URL에 jsessionid도 함께 전달한다.
  • URL 전달 방식을 끄고 항상 쿠키를 통해서만 세션을 유지하고 싶으면 application.properties에 다음 옵션을 넣어준다.
    server.servlet.session.tracking-modes=cookie

14. 세션 정보와 타임아웃 설정

sessionInfoController

@Slf4j
@RestController
public class SessionInfoController {

    @GetMapping("/session-info")
    public String sessionInfo(HttpServletRequest request) {
        HttpSession session = request.getSession(false);
        if (session == null) {
            return "세션이 없습니다.";
        }

        //세션 데이터 출력
        session.getAttributeNames().asIterator()
                .forEachRemaining(name -> 
                		log.info("session name={}, value={}", 
                        	name, session.getAttribute(name)));

        log.info("sessionId={}", session.getId());
        log.info("getMaxInactiveInterval={}", session.getMaxInactiveInterval());
        log.info("creationTime={}", new Date(session.getCreationTime()));
        log.info("lastAccessedTime={}", new Date(session.getLastAccessedTime()));
        log.info("isNew={}", session.isNew());

        return "세션 출력";

    }
}
  • sessionId: 세션Id, JSESSIONID의 값이다. 예) 34B14F008AA3527C9F8ED620EFD7A4E1
  • maxInactiveInterval: 세션의 유효 시간, 예) 1800초, (30분)
  • creationTime: 세션 생성일시
  • lastAccessedTime: 세션과 연결된 사용자가 최근에 서버에 접근한 시간, 클라이언트에서 서버로 sessionId(JSESSIONID)를 요청한 경우에 갱신된다.
  • isNew: 새로 생성된 세션인지, 아니면 이미 과거에 만들어졌고, 클라이언트에서 서버로 sessionId(JSESSIONID)를 요청해서 조회된 세션인지 여부

세션 타임아웃 설정

  • 세션과 관련된 쿠키(JSESSIONID)를 탈취 당했을 경우 오랜 시간이 지나도 해당 쿠키로 악의적인 요청을 할 수 있다.
  • 세션은 기본적으로 메모리에 생성된다. 메모리의 크기가 무한하지 않기 때문에 꼭 필요한 경우만 생성해서 사용해야 한다. 10만명의 사용자가 로그인하면 10만개의 세션이 생성되는 것이다.
  • 세션의 종료 시점을 사용자가 서버에 최근에 요청한 시간을 기준으로 30분 정도를 유지해준다. HttpSession은 이 방식을 사용한다.
  • 스프링 부트로 글로벌 설정(application.properties)
    • server.servlet.session.timeout=60: 60초, 기본은 1800(30분), 글로벌 설정은 분 단위로 설정해야 한다. 예) 60(1분), 120(2분), ...
  • 특정 세션 단위로 시간 설정
    • session.setMaxInactiveInterval(1800); //1800초
  • 세션 타임아웃 발생
    • 세션의 타임아웃 시간은 해당 세션과 관련된 JSESSIONID를 전달하는 HTTP 요청이 있으면 현재 시간으로 다시 초기화 된다. 이렇게 초기화 되면 세션 타임아웃으로 설정한 시간동안 세션을 추가로 사용할 수 있다.
    • session.getLastAccessedTime(): 최근 세션 접근 시간, LastAccessedTime이후로 timeout시간이 지나면, WAS가 내부에서 해당 세션을 제거한다.

정리

  • 세션에는 최소한의 데이터만 보관한다. 보관한 데이터 용량 * 사용자수로 세션의 메모리 사용량이 급격하게 늘어나서 장애로 이어질 수 있다. 추가로 세션의 시간을 너무 길게 가져가면 메모리 사용이 계속 누적 될 수 있으므로 적당한 시간을 선택하는 것이 필요하다. 기본이 30분이라는 것을 기준으로 고민하면 된다.

7. 로그인 처리2 - 필터, 인터셉터

1. 서블릿 필터 - 소개

  • 애플리케이션에서 여러 로직에서 공통으로 관심이 있는 것을 공통 관심사(cross-cutting concern)라고 한다. 상품 관리 컨트롤러의 등록, 수정, 삭제, 조회 등등 여러 로직에서 공통으로 인증에 대해서 관심을 가지고 있다.
  • 이러한 공통 관심사는 스프링의 AOP로도 해결할 수 있지만, 웹과 관련된 공통 관심사는 지금부터 설명할 서블릿 필터 또는 스프링 인터셉터를 사용하는 것이 좋다. 웹과 관련된 공통 관심사를 처리할 때는 HTTP의 헤더나 URL의 정보들이 필요한데, 서블릿 필터나 스프링 인터셉터는 HttpServletResquest를 제공한다.

필터 흐름

  • HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 컨트롤러
    • 필터를 적용하면 필터가 호출 된 다음에 서블릿이 호출된다. 필터는 특정 URL 패턴에 적용할 수 있다. /*라고 하면 모든 요청에 필터가 적용된다. 스프링을 사용하는 경우 서블릿은 스프링의 디스패처 서블릿으로 생각하면 된다.

필터 제한

  • HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 컨트롤러 //로그인 사용자
  • HTTP 요청 -> WAS -> 필터(적절하지 않은 요청이라 판단, 서블릿 호출X) //비 로그인 사용자

필터 체인

  • HTTP 요청 -> WAS -> 필터1 -> 필터2 -> 필터3 -> 서블릿 -> 컨트롤러

필터 인터페이스

public interface Filter {
	
    public default void init(FilterConfig filterConfig) 
    									throws ServletException {}
 
 	public void doFilter(ServletRequest request, ServletResponse response, 
    				FilterChain chain) throws IOException, ServletException;
 
 	public default void destroy() {}
}
  • 필터 인터페이스를 구현하고 등록하면 서블릿 컨테이너가 필터를 싱글톤 객체로 생성하고, 관리한다.
  • init(): 필터 초기화 메서드, 서블릿 컨테이너가 생성될 때 호출된다.
  • doFilter(): 고객의 요청이 올 때 마다 해당 메서드가 호출된다. 필터의 로직을 구현하면 된다.
  • destroy(): 필터 종료 메서드, 서블릿 컨테이너가 종료될 때 호출된다.

2. 서블릿 필터 - 요청 로그

LogFilter

@Slf4j
public class LogFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("log filter init");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
    				FilterChain chain) throws IOException, ServletException {
        log.info("log filter doFilter");

        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String requestURI = httpRequest.getRequestURI();

        String uuid = UUID.randomUUID().toString();

        try {
            log.info("REQUEST [{}][{}]", uuid, requestURI);
            chain.doFilter(request, response);
        } catch(Exception e) {
            throw e;
        } finally {
            log.info("RESPONSE [{}][{}]", uuid, requestURI);
        }
    }

    @Override
    public void destroy() {
        log.info("log filter destroy");
    }
}
  • public class LogFilter implements Filter {}
    • 필터를 사용하려면 필터 인터페이스를 구현해야 한다.
  • doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    • HTTP 요청이 오면 doFilter가 호출된다.
    • ServletRequest request는 HTTP 요청이 아닌 경우까지 고려해서 만든 인터페이스이다. HTTP를 사용하면 HttpServletRequest httpRequest = (HttpServletRequest) request;와 같이 다운 캐스팅 하면 된다.
  • String uuid = UUID.randomUUID().toString();
    • HTTP 요청을 구분하기 위해 요청당 임의의 uuid를 생성해둔다.
  • log.info("REQUEST [{}][{}]", uuid, requestURI);
    • uuid와 requestURI를 출력한다.
  • chain.doFilter(request, response);
    • 다음 필터가 있으면 필터를 호출하고, 필터가 없으면 서블릿을 호출한다. 만약 이 로직을 호출하지 않으면 다음 단계로 진행되지 않는다.

WebConfig - 필터 설정

@Configuration
public class WebConfig {
	
    @Bean
	public FilterRegistrationBean logFilter() {
 		FilterRegistrationBean<Filter> filterRegistrationBean 
        									= new FilterRegistrationBean<>();
 		filterRegistrationBean.setFilter(new LogFilter());
	 	filterRegistrationBean.setOrder(1);
 		filterRegistrationBean.addUrlPatterns("/*");
 		return filterRegistrationBean;
 	}
}
  • 필터를 등록하는 방법은 여러가지가 있지만, 스프링 부트를 사용한다면 FilterRegistrationBean을 사용해서 등록하면 된다.
  • setFilter(new LogFilter()): 등록할 필터를 지정한다.
  • setOrder(1): 필터는 체인으로 동작한다. 따라서 순서가 필요하다. 낮을 수록 먼저 동작한다.
  • addUrlPatterns("/*"): 필터를 적용할 URL 패턴을 지정한다. 한번에 여러 패턴을 지정할 수 있다.
    • URL 패턴에 대한 룰은 필터도 서블릿과 동일하다. 자세한 내용은 서블릿 URL 패턴으로 검색.
  • @ServletComponentScan``@WebFilter(filterName = "logFilter", urlPatterns = "/*")로
    필터 등록이 가능하지만 필터 순서 조절이 안된다. 따라서 FilterRegistrationBean 을 사용하자.

실행로그

hello.login.web.filter.LogFilter: REQUEST [0a2249f2-cc70-4db4-98d1-492ccf5629dd][/items]
hello.login.web.filter.LogFilter: RESPONSE [0a2249f2-cc70-4db4-98d1-492ccf5629dd][/items]
  • 실무에서 HTTP 요청시 같은 요청의 로그에 모두 같은 식별자를 자동으로 남기는 방법은 logback mdc로 검색.

3. 서블릿 필터 - 인증 체크

LoginCheckFilter

@Slf4j
public class LoginCheckFilter implements Filter {
    //default는 구현 안해도 돼

    private static final String[] whitelist 
    				= {"/", "/members/add", "/login", "/logout", "/css/*"};

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
    				FilterChain chain) throws IOException, ServletException {

        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String requestURI = httpRequest.getRequestURI();

        HttpServletResponse httpResponse = (HttpServletResponse) response;

        try {
            log.info("인증 체크 필터 시작 {}", requestURI);

            if (isLoginCheckPath(requestURI)) {
                log.info("인증 체크 로직 실행 {}", requestURI);
                HttpSession session = httpRequest.getSession(false);
                if (session == null 
                	|| session.getAttribute(SessionConst.LOGIN_MEMBER) == null) {

                    log.info("미인증 사용자 요청 {}", requestURI);
                    //로그인으로 redirect
                    httpResponse.sendRedirect("/login?redirectURL=" + requestURI);
                    return;
                }
            }

            chain.doFilter(request, response);
        } catch (Exception e) {
            throw e; //예외 로깅 가능 하지만, 톰캣까지 예외를 보내주어야 함
        } finally {
            log.info("인증 체크 필터 종료 {}", requestURI);
        }
    }

    /**
     * 화이트 리스트의 경우 인증 체크X
     */
    private boolean isLoginCheckPath(String requestURI) {
        return !PatternMatchUtils.simpleMatch(whitelist, requestURI);
    }
}
  • whitelist = {"/", "/members/add", "/login", "/logout", "/css/*"};
    • 인증 필터를 적용해도 홈, 회원가입, 로그인 화면, css 같은 리소스에는 접근할 수 있어야 한다.
  • isLoginCheckPath(requestURI)
    • 화이트 리스트를 제외한 모든 경우에 인증 체크 로직을 적용한다.
  • httpResponse.sendRedirect("/login?redirectURL=" + requestURI);
    • 현재 요청한 경로인 requestURI를 /login에 쿼리 파라미터로 함께 전달한다. /login 컨트롤러에서 로그인 성공시 해당 경로로 이동하는 기능도 추가로 개발한다.
  • retrun;
    • 필터를 더는 진행하지 않는다. 이후 필터는 물론 서블릿, 컨트롤러가 더는 호출되지 않는다. 앞서 redirect를 사용했기 때문에 redirect가 응답으로 적용되고 요청이 끝난다.

WebConfig - loginCheckFilter() 추가

@Bean
public FilterRegistrationBean loginCheckFilter() {
	FilterRegistrationBean<Filter> filterRegistrationBean 
    								= new FilterRegistrationBean<>();
	filterRegistrationBean.setFilter(new LoginCheckFilter());
    filterRegistrationBean.setOrder(2);
    filterRegistrationBean.addUrlPatterns("/*");

    return filterRegistrationBean;
}
  • setFilter(new LoginCheckFilter()): 로그인 필터를 등록한다.
  • setOrder(2): 순서를 2번으로 잡았다. 로그 필터 다음에 로그인 필터가 적용된다.
  • addUrlPatterns("/*"): 모든 요청에 로그인 필터를 적용한다.

LoginController - RedirectURL 처리

@PostMapping("/login")
public String loginV4(@Valid @ModelAttribute LoginForm form,
						BindingResult bindingResult, 
                        @RequestParam(defaultValue = "/") String redirectURL, 
                        HttpServletRequest request) {
	if (bindingResult.hasErrors()) {
    	return "login/loginForm";
    }

    Member loginMember = loginService.login(form.getLoginId(), form.getPassword());

    if (loginMember == null) {
    	bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
        return "login/loginForm";
    }

    // 로그인 성공 처리
    // 세션이 있으면 있는 세션 반환, 없으면 신규 세션을 생성
    HttpSession session = request.getSession();
    //세션에 로그인 회원 정보 보관
    session.setAttribute(SessionConst.LOGIN_MEMBER, loginMember);

    return "redirect:" + redirectURL;
}
  • 로그인 체크 필터에서, 미인증 사용자는 요청 경로를 포함해서 /login에 redirectURL 요청 파라미터를 추가해서 요청했다. 이 값을 사용해서 로그인 성공시 해당 경로로 고객을 redirect한다.

정리

  • 서블릿 필터를 잘 사용한 덕분에 로그인 하지 않은 사용자는 나머지 경로에 들어갈 수 없게 되었다. 공통 관심사를 서블릿 필터를 사용해서 해결한 덕분에 향후 로그인 관련 정책이 변경되어도 이 부분만 변경하면 된다.
  • 필터에는 다음에 설명할 스프링 인터셉터는 제공하지 않는, 아주 강력한 기능이 있는데 chain.doFilter(request, response);를 호출해서 다음 필터 또는 서블릿을 호출할 때 request, response를 다른 객체로 바꿀 수 있다. ServletRequest, ServletResponse를 구현한 다른 객체를 만들어서 넘기면 해당 객체가 다음 필터 또는 서블릿에서 사용된다.

4. 스프링 인터셉터 - 소개

스프링 인터셉터도 서블릿 필터와 같이 웹과 관련된 공통 관심 사항을 효과적으로 해결할 수 있는 기술이다. 서블릿 필터가 서블릿이 제공하는 기술이라면, 스프링 인터셉터는 스프링 MVC가 제공하는 기술이다. 둘다 웹과 관련된 공통 관심 사항을 처리하지만, 적용되는 순서와 범위, 그리고 사용방법이 다르다. 스프링 인터셉터는 서블릿 필터보다 편리하고, 더 정교하고 다양한 기능을 지원한다.

스프링 인터셉터 흐름

  • HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 스프링 인터셉터 -> 컨트롤러
    • 스프링 인터셉터는 디스패처 서블릿과 컨트롤러 사이에서 컨트롤러 호출 직전에 호출 된다.
    • 스프링 인터셉터는 스프링 MVC가 제공하는 기능이기 때문에 결국 디스패처 서블릿 이후에 등장하게 된다. 스프링 MVC의 시작점이 디스패처 서블릿이라고 생각해보면 이해가 될 것이다.
    • 스프링 인터셉터에도 URL 패턴을 적용할 수 있는데, 서블릿 URL 패턴과는 다르고, 매우 정밀하게 설정할 수 있다.

스프링 인터셉터 제한

  • HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 스프링 인터셉터 -> 컨트롤러 //로그인 사용자
  • HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 스프링 인터셉터(적절하지 않은 요청이라 판단, 컨트롤러 호출X) // 비 로그인 사용자

스프링 인터셉터 체인

  • HTTP 요청 -> WAS -> 필터 -> 서블릿 -> 인터셉터1 -> 인터셉터2 -> 컨트롤러
    • 스프링 인터셉터는 체인으로 구성되는데, 중간에 인터셉터를 자유롭게 추가할 수 있다. 예를 들어서 로그를 남기는 인터셉터를 먼저 적용하고, 그 다음에 로그인 여부를 체크하는 인터셉터를 만들 수 있다.

스프링 인터셉터 인터페이스

public interface HandlerInterceptor {

	default boolean preHandle(HttpServletRequest request, HttpServletResponse 
response, Object handler) throws Exception {}

	default void postHandle(HttpServletRequest request, HttpServletResponse 
response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {}

	default void afterCompletion(HttpServletRequest request, HttpServletResponse 
response, Object handler, @Nullable Exception ex) throws Exception {}

}
  • 서블릿 필터의 경우 단순하게 doFilter() 하나만 제공된다. 인터셉터는 컨토롤러 호출 전(preHandle), 호출 후(postHandle), 요청 완료 이후(afterCompletion)와 같이 단계적으로 잘 세분화 되어 있다.
  • 서블릿 필터의 경우 단순히 request, response만 제공했지만, 인터셉터는 어떤 컨트롤러(handler)가 호출되는지 호출 정보도 받을 수 있다. 그리고 어떤 modelAndView가 반환되는지 응답 정보도 받을 수 있다.

스프링 인터셉터 정상 흐름

  • preHandle: 컨트롤러 호출 전에 호출된다. (더 정확히는 핸들러 어댑터 호출 전에 호출된다.)
    • preHandle의 응답값이 true이면 다음으로 진행하고, false이면 더는 진행하지 않는다. false인 경우 나머지 인터셉터는 물론이고, 핸들러 어댑터도 호출되지 않는다. 그림에서 1번에서 끝이 나버린다.
  • postHandle: 컨트롤러 호출 후에 호출된다. (더 정확히는 핸들러 어댑터 호출 후에 호출된다.)
  • afterCompletion: 뷰가 렌더링 된 이후에 호출된다.

스프링 인터셉터 예외 상황

  • preHandle: 컨트롤러 호출 전에 호출된다.
  • postHandle: 컨트롤러에서 예외가 발생하면 postHandle은 호출되지 않는다.
  • afterCompletion: afterCompletion은 항상 호출된다. 이 경우 예외(ex)를 파라미터로 받아서 어떤 예외가 발생했는지 로그로 출력할 수 있다.
    • 예외가 발생하면 postHandle()은 호출되지 않으므로 예외와 무관하게 공통 처리를 하려면 afterCompletion()을 사용해야 한다.

정리

  • 인터셉터는 스프링 MVC 구조에 특화된 필터 기능을 제공한다고 이해하면 된다. 스프링 MVC를 사용하고, 특별히 필터를 꼭 사용해야 하는 상황이 아니라면 인터셉터를 사용하는 것이 더 편리하다.

5. 스프링 인터셉터 - 요청 로그

LogInterceptor

@Slf4j
public class LogInterceptor implements HandlerInterceptor {

    public static final String LOG_ID = "logId";

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String requestURI = request.getRequestURI();
        String uuid = UUID.randomUUID().toString();

        request.setAttribute(LOG_ID, uuid);

        //@RequestMapping : HandlerMethod
        //정적 리소스: ResourceHttpRequestHandler

        if (handler instanceof HandlerMethod) {
            HandlerMethod hm = (HandlerMethod) handler; //호출할 컨트롤러 메서드의 모든 정보가 포함되어 있다.
        }

        log.info("REQUEST [{}][{}][{}]", uuid, requestURI, handler);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.info("postHandler [{}]", modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        String requestURI = request.getRequestURI();
        String logId = (String) request.getAttribute(LOG_ID);
        log.info("RESPONSE [{}][{}][{}]", logId, requestURI, handler);
        if (ex != null) {
            log.error("afterCompletion error!!", ex);
        }

    }
}
  • String uuid = UUID.randomUUID().toString()
    • 요청 로그를 구분하기 위한 uuid를 생성한다.
  • request.setAttribute(LOG_ID, uuid)
    • 서블릿 필터의 경우 지역변수로 해결이 가능하지만, 스프링 인터셉터는 호출 시점이 완전히 분리되어 있다. 따라서 preHandle에서 지정한 값을 postHandle, afterCompletion에서 함께 사용하려면 어딘가에 담아두어야 한다. LogInterceptor도 싱글톤 처럼 사용되기 때문에 멤버변수를 사용하면 위험하다. 따라서 request에 담아두었다. 이 값은 afterCompletion에서 request.getAttribute(LOG_ID)로 찾아서 사용한다.
  • return true
    • true면 정상 호출이다. 다음 인터셉터나 컨트롤러가 호출된다.
  • HandlerMethod
    • 핸들러 정보는 어떤 핸들러 매핑을 사용하는가에 따라 달라진다. 스프링을 사용하면 일반적으로 @Controller, @RequestMapping을 활용한 핸들러 매핑을 사용하는데, 이 경우 핸들러 정보로 HandlerMethod가 넘어온다.
  • ResourceHttpRequestHandler
    • @Controller가 아니라 /resources/static과 같은 정적 리소스가 호출 되는 경우 ResourceHttpRequestHandler가 핸드러 정보로 넘어오기 때문에 타입에 따라서 처리가 필요하다.
  • postHandle, afterCompletion
    • 종료 로그를 postHandle이 아니라 afterCompletion에서 실행한 이유는, 예외가 발생한 경우 postHandle이 호출되지 않기 때문이다. afterCompletion은 예외가 발생해도 호출 되는 것을 보장한다.

WebConfig - 인터셉터 등록

@Configuration
public class WebConfig implements WebMvcConfigurer {
	
    @Override
 	public void addInterceptors(InterceptorRegistry registry) {
 		registry.addInterceptor(new LogInterceptor())
 				.order(1)
 				.addPathPatterns("/**")
 				.excludePathPatterns("/css/**", "/*.ico", "/error");
 	}
	//...
}
  • 인터셉터와 필터가 중복되지 않도록 필터를 등록하기 위한 logFilter()의 @Bean은 주석처리하자.
  • WebMvcConfigurer가 제공하는 addInterceptors()를 사용해서 인터셉터를 등록할 수 있다.
  • registry.addInterceptor(new LogInterceptor()): 인터셉터를 등록한다.
  • order(1): 인터셉터의 호출 순서를 지정한다. 낮을 수록 먼저 호출된다.
  • addPathPatterns("/**"): 인터셉터를 적용할 URL 패턴을 지정한다.
  • excludePathPatterns("/css/**", "/*.ico", "/error"): 인터셉터에서 제외할 패턴을 지정한다.
  • 필터와 비교시 인터셉터는 addPathPatterns, excludePathPatterns로 매우 정밀하게 URL 패턴을 지정할 수 있다.

실행 로그

REQUEST [6234a913-f24f-461f-a9e1-85f153b3c8b2][/members/add]
[hello.login.web.member.MemberController#addForm(Member)]

postHandle [ModelAndView [view="members/addMemberForm"; 
model={member=Member(id=null, loginId=null, name=null, password=null), 
org.springframework.validation.BindingResult.member=org.springframework.validat
ion.BeanPropertyBindingResult: 0 errors}]]

RESPONSE [6234a913-f24f-461f-a9e1-85f153b3c8b2][/members/add]

스프링의 URL 경로

  • 스프링이 제공하는 URL 경로는 서블릿 기술이 제공하는 URL 경로와 완전히 다르다. 더욱 자세하고, 세밀하게 설정할 수 있다.
  • PathPattern 공식 문서
? 한 문자 일치
* 경로(/) 안에서 0개 이상의 문자 일치
** 경로 끝까지 0개 이상의 경로(/) 일치
{spring} 경로(/)와 일치하고 spring이라는 변수로 캡처
{spring:[a-z]+} matches the regexp [a-z]+ as a path variable named "spring"
{spring:[a-z]+} regexp [a-z]+ 와 일치하고, "spring" 경로 변수로 캡처
{*spring} 경로가 끝날 때 까지 0개 이상의 경로(/)와 일치하고 spring이라는 변수로 캡처

/pages/t?st.html — matches /pages/test.html, /pages/tXst.html but not /pages/
toast.html
/resources/*.png — matches all .png files in the resources directory
/resources/** — matches all files underneath the /resources/ path, including /
resources/image.png and /resources/css/spring.css
/resources/{*path} — matches all files underneath the /resources/ path and 
captures their relative path in a variable named "path"; /resources/image.png 
will match with "path" → "/image.png", and /resources/css/spring.css will match 
with "path" → "/css/spring.css"
/resources/{filename:\\w+}.dat will match /resources/spring.dat and assign the 
value "spring" to the filename variable

6. 스프링 인터셉터 - 인증 체크

LoginCheckInterceptor

@Slf4j
public class LoginCheckInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request,
           HttpServletResponse response, Object handler) throws Exception {

        String requestURI = request.getRequestURI();

        log.info("인증 체크 인터셉터 실행 {}", requestURI);

        HttpSession session = request.getSession();

        if (session == null 
              || session.getAttribute(SessionConst.LOGIN_MEMBER) == null) {
            log.info("미인증 사용자 요청");
            //로그인으로 redirect
            response.sendRedirect("/login?redirectURL=" + requestURI);
            return false;
        }

        return true;
    }
}
  • 서블릿 필터와 비교해서 코드가 매우 간결하다. 인증이라는 것은 컨트롤러 호출 전에만 호출되면 된다. 따라서 preHandle만 구현하면 된다.

WebConfig

@Override
public void addInterceptors(InterceptorRegistry registry) {
	registry.addInterceptor(new LogInterceptor())
    		.order(1)
            .addPathPatterns("/**")
            .excludePathPatterns("/css/**", "/*.ico", "/error");

    registry.addInterceptor(new LoginCheckInterceptor())
    		.order(2)
            .addPathPatterns("/**")
            .excludePathPatterns("/", "/members/add", "/login", "/logout", 
            						"/css/**", "/*.ico", "/error");
}
  • 인터셉터와 필터가 중복되지 않도록 필터를 등록하기 위한 logFilter(), loginCheckFilter()의 @Bean은 주석처리하자.
  • 기본적으로 모든 경로에 해당 인터셉터를 적용(/**)하되, 홈(/), 회원가입(/member/add), 로그인(/login), 리소스 조회(/css/**), 오류(/error)와 같은 부분은 로그인 체크 인터셉터를 적용하지 않는다. 서블릿 필터와 비교해보면 매우 편리하다.

7. ArgumentResolver 활용

HomeController

@GetMapping("/")
public String homeLoginV3ArgumentResolver(@Login Member loginMember, Model model) {

	//세션에 회원 데이터가 없으면 home
    if (loginMember == null) {
    	return "home";
    }

    //세션이 유지되면 로그인으로 이동
    model.addAttribute("member", loginMember);
    return "loginHome";
}
  • @Login 애노테이션이 있으면 직접 만든 ArgumentResolver가 동작해서 자동으로 세션에 있는 로그인 회원을 찾아주고, 만약 세션에 없다면 null을 반환하도록 개발해보자.

@Login

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface Login {

}
  • @Target(ElementType.PARAMETER): 파라미터에만 사용
  • @Retention(RetentionPolicy.RUNTIME): 리플렉션 등을 활용할 수 있도록 런타임까지 애노테이션정보가 남아있음

LoginMemberArgumentResolver

//HandlerMethodArgumentResolver를 구현
@Slf4j
public class LoginMemberArgumentResolver implements HandlerMethodArgumentResolver {

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        log.info("supportsParameter 실행");

        boolean hasLoginAnnotation 
        			= parameter.hasParameterAnnotation(Login.class);
        boolean hasMemberType 
        			= Member.class.isAssignableFrom(parameter.getParameterType());

        return hasLoginAnnotation && hasMemberType;
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, 
    						ModelAndViewContainer mavContainer, 
                            NativeWebRequest webRequest, 
                            WebDataBinderFactory binderFactory) throws Exception {

        log.info("resolveArgument 실행");

        HttpServletRequest request 
        				= (HttpServletRequest) webRequest.getNativeRequest();
        HttpSession session = request.getSession(false);
        if (session == null) {
            return null;
        }

        return session.getAttribute(SessionConst.LOGIN_MEMBER);
    }
}
  • supportsParameter() : @Login 애노테이션이 있으면서 Member 타입이면 해당 ArgumentResolver가 사용된다.
  • resolveArgument() : 컨트롤러 호출 직전에 호출 되어서 필요한 파라미터 정보를 생성해준다. 여기서는 세션에 있는 로그인 회원 정보인 member 객체를 찾아서 반환해준다. 이후 스프링MVC는 컨트롤러의 메서드를 호출하면서 여기에서 반환된 member 객체를 파라미터에 전달해준다.

WebConfig

@Configuration
public class WebConfig implements WebMvcConfigurer {
	
    @Override
	public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
 		resolvers.add(new LoginMemberArgumentResolver());
	}
 	//...
}
  • 앞서 개발한 LoginMemberArgumentResolver를 등록
  • 실행해보면, 결과는 동일하지만, 더 편리하게 로그인 회원 정보를 조회할 수 있다. 이렇게 ArgumentResolver를 활용하면 공통 작업이 필요할 때 컨트롤러를 더욱 편리하게 사용할 수 있다.

스프링 MVC 2편 - 백엔드 웹 개발 활용 기술

profile
Jim
You never fail until you stop trying.
이전 포스트

스프링 MVC 2편 - 백엔드 웹 개발 활용 기술 정리(1)

다음 포스트

스프링 MVC 2편 - 백엔드 웹 개발 활용 기술 정리(3)

0개의 댓글