🌱 스프링 MVC 2

yeop·2023년 5월 31일

✔️ 타임리프 기본기능

컨텐츠안에 내용 바로 삽입하기 - [[…]]

<ul>
  <li>th:text 사용 <span th:text="${data}"></span></li>
  <li>컨텐츠 안에서 직접 출력하기 = [[${data}]]</li>
</ul>

이스케이프 - th:utext / [(…)]

문자를 태그로 변환하지 않고 문자 그대로 출력

th: text : 이스케이프 VS th: utext: 언이스케이프
[[…]] : 이스케이프 VS [(…)] : 언이스케이프

※ 이스케이프를 기본으로 하고 꼭 필요할 때만 언이스케이프 사용

지역변수 - th:with

<div th:with="first=${users[0]}">
  <p>처음 사람의 이름은 <span th:text="${first.username}"></span></p>
</div>

Param, Session, Spring Bean

Thymeleaf 에서 지원하는 이름으로 바로 꺼내쓸 수 있다.

<li>Request Parameter = <span th:text="${param.paramData}"></span></li>
<li>session = <span th:text="${session.sessionData}"></span></li>
<li>spring bean = <span th:text="${@helloBean.hello('Spring!')}"></span></li>

URL

<li><a th:href="@{/hello}">basic url</a></li>
<li><a th:href="@{/hello(param1=${param1}, param2=${param2})}">hello query param</a></li>
<li><a th:href="@{/hello/{param1}/{param2}(param1=${param1}, param2=${param2})}">path variable</a></li>
<li><a th:href="@{/hello/{param1}(param1=${param1}, param2=${param2})}">path variable + query parameter</a></li>

리터럴 - 작은 따옴표

소스코드 상의 고정된 값을 말하는 용어
타임리프에서 리터럴은 작은 따옴표로 감싸야한다.

<li>'hello' + ' world!' = <span th:text="'hello' + ' world!'"></span></li>
 <li>'hello world!' = <span th:text="'hello world!'"></span></li>
 <li>'hello ' + ${data} = <span th:text="'hello ' + ${data}"></span></li>
 <li>리터럴 대체 |hello ${data}| = <span th:text="|hello ${data}|"></span></li>

연산 - No-Operation

코드

<body>
<ul>
  <li>산술 연산
    <ul>
      <li>10 + 2 = <span th:text="10 + 2"></span></li>
      <li>10 % 2 == 0 = <span th:text="10 % 2 == 0"></span></li>
    </ul>
  </li>
  <li>비교 연산
    <ul>
      <li>1 > 10 = <span th:text="1 &gt; 10"></span></li>
      <li>1 gt 10 = <span th:text="1 gt 10"></span></li>
      <li>1 >= 10 = <span th:text="1 >= 10"></span></li>
      <li>1 ge 10 = <span th:text="1 ge 10"></span></li>
      <li>1 == 10 = <span th:text="1 == 10"></span></li>
      <li>1 != 10 = <span th:text="1 != 10"></span></li>
    </ul>
  </li>
  <li>조건식
    <ul>
      <li>(10 % 2 == 0)? '짝수':'홀수' = <span th:text="(10 % 2 == 0)?
'짝수':'홀수'"></span></li>
    </ul>
  </li>
  <li>Elvis 연산자
    <ul>
      <li>${data}?: '데이터가 없습니다.' = <span th:text="${data}?: '데이터가없습니다.'"></span></li>
      <li>${nullData}?: '데이터가 없습니다.' = <span th:text="${nullData}?: '데이터가 없습니다.'"></span></li>
    </ul>
  </li>
  <li>No-Operation
    <ul>
      <li>${data}?: _ = <span th:text="${data}?: _">데이터가 없습니다.</span></li>
      <li>${nullData}?: _ = <span th:text="${nullData}?: _">데이터가없습니다.</span></li>
    </ul>
  </li>
</ul>
</body>

No-Operation
- _ 인 경우 마치 타임리프가 실행되지 않는 것 처럼 동작한다. 이것을 잘 사용하면 HTML
  의 내용 그대로 활용할 수 있다. 마지막 예를 보면 데이터가 없습니다. 부분이 그대로 출력된다

속성 값 설정 - 추가, Checked

속성 추가

- th:attrappend = <input type="text" class="text" th:attrappend="class='large'" /><br/>
- th:attrprepend = <input type="text" class="text" th:attrprepend="class='large '" /><br/>
- th:classappend = <input type="text" class="text" th:classappend="large" /><br/>

Checked 속성
- 기존의 checked는 false로 설정해도 무조건 체크가 되어져서 렌더링된다. 하지만 th:ckecked를 사용하면 false로 설정할 경우 checked 설정 자체를 없애준다.
- checked o
- checked x

반복 - th:each , ___Stat

___Stat

index : 0부터 시작하는 값
count : 1부터 시작하는 값
size : 전체 사이즈
even , odd : 홀수, 짝수 여부( boolean )
first , last :처음, 마지막 여부( boolean )

current : 현재 객체

<tr th:each="user, userStat : ${users}">
 <td th:text="${userStat.count}">username</td>
 <td th:text="${user.username}">username</td>
 <td th:text="${user.age}">0</td>
 <td>
 index = <span th:text="${userStat.index}"></span>
 count = <span th:text="${userStat.count}"></span>
 size = <span th:text="${userStat.size}"></span>
 even? = <span th:text="${userStat.even}"></span>
 odd? = <span th:text="${userStat.odd}"></span>
 first? = <span th:text="${userStat.first}"></span>
 last? = <span th:text="${userStat.last}"></span>
 current = <span th:text="${userStat.current}"></span>
 </td>
 </tr>

조건부 - if, unless, switch/case

조건을 만족하지 못할 시 해당 태그 전체가 삭제된다.

<span th:text="'미성년자'" th:if="${user.age lt 20}"></span>
<span th:text="'미성년자'" th:unless="${user.age ge 20}"></span>

<td th:switch="${user.age}">
	 <span th:case="10">10살</span>
	 <span th:case="20">20살</span>
	 <span th:case="*">기타</span>
 </td>

주석

HTML 주석


<!--
<span th:text="${data}">html data</span>
-->

타임리프 파서 주석

<!--/* [[${data}]] */-->
<!--/*-->
<span th:text="${data}">html data</span>
<!--*/-->

타임리프 프로토타입 주석 - 파일 자체를 열때는 주석처리, 타임리프를 사용해서 렌더링되는 경우에는 주석 처리 X
```

```

블록 - 타임리프 자체 태그 <th:block>

자바스크립트 인라인

자바스크립트 인라인 사용전
- <script>~~~</script>
사용
- <script th:inline=”javascript”>~~~</script>

템플릿 조각 (컴포넌트)

컴포넌트 선언 코드

<footer th:fragment="copyParam (param1, param2)">
 <p>파라미터 자리 입니다.</p>
 <p th:text="${param1}"></p>
 <p th:text="${param2}"></p>
</footer>

컴포넌트 사용 코드

replace 대신 insert 사용 시 div 태그 내부로 삽입

<h1>파라미터 사용</h1>
<div th:replace="~{template/fragment/footer :: copyParam ('데이터1', '데이터2')}"></div>

템플릿 레이아웃

레이아웃 선언 코드

<html xmlns:th="http://www.thymeleaf.org">
<head th:fragment="common_header(title,links)">
 <title th:replace="${title}">레이아웃 타이틀</title>
 <!-- 공통 -->
 <link rel="stylesheet" type="text/css" media="all" th:href="@{/css/
awesomeapp.css}">
 <link rel="shortcut icon" th:href="@{/images/favicon.ico}">
 <script type="text/javascript" th:src="@{/sh/scripts/codebase.js}"></
script>
 <!-- 추가 -->
 <th:block th:replace="${links}" />
</head>

레이아웃 사용 코드

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="template/layout/base :: common_header(~{::title},~{::link})">
 <title>메인 타이틀</title>
 <link rel="stylesheet" th:href="@{/css/bootstrap.min.css}">
 <link rel="stylesheet" th:href="@{/themes/smoothness/jquery-ui.css}">
</head>
<body>
메인 컨텐츠
</body>
</html>

common_header(~{::title},~{::link}) 이 부분이 핵심이다.
- ::title 은 현재 페이지의 title 태그들을 전달한다.
- ::link 는 현재 페이지의 link 태그들을 전달한다.

✔️ 타임리프 - 스프링 통합과 폼

입력 폼 처리

`th:object`

커맨드 객체를 지정한다
*{...} : 선택 변수식이라고 하며 th:object 에서 선택한 객체에 접근한다.
- *{itemName} == ${item.itemName}

`th:field`

HTML 태그의 Id, name, value 속성을 자동으로 처리해준다.

체크박스

단일1 - 히든 필드 추가

타임리프를 사용하지 않고 HTML 태그만을 사용해서 체크박스를 구현하면 체크를 했을 때는 True값이 정상적으로 넘어오지만 체크를 하지 않았을 경우에는 아무것도 넘어오지 않아 Null값으로 처리된다.
해결방법
- 히든 필드 추가
  - <input type="hidden" name="_open" value="on">
  - 위와 같이 히든 필드를 추가하면 체크를 하지 않았을 경우 False 값이 넘어오게 된다.

단일2 - th:field

th:field를 사용하면 체크박스의 히든필드 부분을 자동으로 생성해서 처리해준다.
체크박스에서 체크를 해서 저장한 후 값을 불러와서 사용할 때는 값이 True이면 Checked 속성을 삽입해주는 것을 개발자가 직접 처리해야한다.
- 하지만 타임리프의 th:field를 사용하면 값이 True인 경우 체크를 자동으로 처리해준다.

멀티

<!-- multi checkbox -->
        <div>
            <div>등록 지역</div>
            <div th:each="region : ${regions}" class="form-check form-check-inline">
                <input type="checkbox" th:field="*{regions}" th:value="${region.key}"
                       class="form-check-input">
                <label th:for="${#ids.prev('regions')}"
                       th:text="${region.value}" class="form-check-label">서울</label>
            </div>
        </div>

th:for="${#ids.prev('regions')}"
- each 루프 안에서 id값 추적하는 방법
- each 루프 안에서 타임리프는 field값으로 넣은 값 뒤에 숫자를 붙여 임의로 id를 선언한다.
  
  @ModelAttribute의 특별한 사용법
- 등록폼, 상세화면, 수정폼에서 모두 체크박스를 보여주기 위해서는 각각의 컨트롤러에서 model.addAttribute(...) 를 사용해서 데이터를 반복해서 넣어주어야한다.
```
		@ModelAttribute("regions")
    public Map<String, String> regions(){
        Map<String, String> regions = new LinkedHashMap<>();
        regions.put("SEOUL", "서울");
        regions.put("BUSAN", "부산");
        regions.put("JEJU", "제주");
        return regions;
    }
```
  - 이렇게 하면 컨트롤러를 요청할 때 regions에서 반환한 값이 자동으로 model에 담기게 된다.

라디오 버튼

<!-- radio button -->
        <div>
            <div>상품 종류</div>
            <div th:each="type : ${itemTypes}" class="form-check form-check-inline">
                <input type="radio" th:field="*{itemType}" th:value="${type.name()}"
                       class="form-check-input">
                <label th:for="${#ids.prev('itemType')}" th:text="${type.description}"
                       class="form-check-label">
                    BOOK
                </label>
            </div>
        </div>

타임리프에서 ENUM 직접 접근

현재 상태: @ModelAttribute를 통해서 모델에 ENUM을 담아 전달
직접 접근
- <div th:each="type: ${T(hello.itemservice.domain.item.ItemType).values()}>

셀렉트 박스

<!-- SELECT -->
    <div>
        <div>배송 방식</div>
        <select th:field="${item.deliveryCode}" class="form-select">
            <option value="">==배송 방식 선택==</option>
            <option th:each="deliveryCode : ${deliveryCodes}" th:value="${deliveryCode.code}" disabled
                    th:text="${deliveryCode.displayName}">FAST</option>
        </select>
    </div>

✔️ 메시지, 국제화

메시지

모든 파일에서 ‘상품명’이라는 단어를 모두 ‘상품이름’으로 고쳐야 할 겨우 모든화면을 찾아가면서 변경하기에는 너무 오랜 시간이 걸린다.
이런 다양한 메시지를 한 곳(별도의 파일)에서 관리하도록 하는 기능을 메시지 기능이라고 한다.

국제화

영어권 국가에서 들어오는 클라이언트에게는 영어, 한국에서 들어오면 한국어를 제공
메시지 파일을 언어별로 생성해서 국제화하다.
인식 방법
- HTTP accpt-language 헤더 값을 사용
- 사용자가 직접 언어를 선택 → 쿠키 처리

스프링이 제공하는 메시지, 국제화

테스트 사용

resources 안에 message.properties → 디폴트 파일 message_en.properties → Locale.ENGLISH

코드

@SpringBootTest
public class MessageSourceTest {

    @Autowired
    MessageSource ms;

    @Test
    void helloMessage(){
        String result = ms.getMessage("hello", null, null);
assertThat(result).isEqualTo("안녕");
    }

    @Test
    void notFoundMessageCode(){
assertThatThrownBy(() -> ms.getMessage("no_code", null, null))
                .isInstanceOf(NoSuchMessageException.class);
        System.out.println(Locale.getDefault());
    }

    @Test
    void notFoundMessageCodeDefaultMessage(){
        String result = ms.getMessage("no_code", null, "기본 메시지", null);
assertThat(result).isEqualTo("기본 메시지");
    }

    @Test
    void argumentMessage(){
        String result = ms.getMessage("hello.name", new Object[]{"Spring"}, null);
assertThat(result).isEqualTo("안녕 Spring");
    }

    @Test
    void defaultLang(){
assertThat(ms.getMessage("hello", null, null)).isEqualTo("안녕");
assertThat(ms.getMessage("hello", null, Locale.KOREA)).isEqualTo("안녕");
    }

    @Test
    void enLang(){
assertThat(ms.getMessage("hello", null, Locale.ENGLISH)).isEqualTo("hello");
    }

}

애플리케이션 적용

메시지
- <div th:text="#{label.item}"></h2>
- 인자: <p th:text="#{hello.name(${item.itemName})}"></p>
국제화
- 각 locale에 맞는 properties 파일이 있다면 스프링이 Accept-language 헤더값을 사용해서 자동으로 적용시켜준다.
- LocaleResolver
  - 만약 Locale 선택 방식을 변경하려면 LocaleResolver의 구현체를 변경해서 쿠키나 세션 기반의 Locale 선택 기능을 사용할 수 있따.

✔️ Validation

V1 - Error Map

컨트롤러 코드

ModelAttribute Annotation으로 인해 item이 자동으로 model에 등록되기 때문에 return으로 리렌더링 되어도 기존에 입력했던 값이 그대로 유지된다.

@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()){
            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}";
    }

HTML 코드

errors 다음에 있는 ? 연산자
- ?를 붙이지 않고 실행할 때 errors가 null값이라면 null값의 요소를 찾는 것이기 때문에 NullpointException 오류가 난다.
- 하지만 ?를 사용하면 errors가 null값이라면 바로 null을 반환한다.

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

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

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

남은 문제점
- 뷰에 중복되는 코드가 많다
- 타입 오류 처리가 안된다.

V2 - BindingResult

// FieldError
bindingResult.addError(new FieldError("item", "price", item.getPrice(), false, null, null, "가격은 1,000 ~ 1,000,000 까지 허용합니다"));
// ObjectError
bindingResult.addError(new ObjectError("item", null, null,"가격 * 수량의 합은 10,000원 이상이어야 합니다. 현재 값 = " + resultPrice));

BindingResult

인자에 BindingResult bindingResult 추가
- @ModelAttribute 다음에 위치해야한다.
- Model에 자동으로 포함된다.

FieldError

bindingResult.addError(new FieldError(objectName(ModelAttribute 인스턴스 이름)
, field, rejectedValue, bindingFailure(타입 오류같은 바인딩 실패인지, 검증 실패인지 구분 값),
 codes(메시지 코드), arguments(메시지에 사용하는 인자) defaultMessage)

FieldError를 사용할 때 잘못된 값을 입력하면 입력값이 유지되지 않는 이유
- 사용자의 데이터가 컨트롤러의 @ModelAttribute에 바인딩되는 시점에 에러가 발생하면 모델 객체에 사용자 입력 값을 유지하기 어렵다.
- 예를 들어서 가격에 숫자가 아닌 문자가 입력된다면 가격은 Integer 타입이므로 문자를 보관할 수 있는 방법이 없다.
- 그래서 오류가 발생한 경우 사용자 입력 값을 보관하는 별도의 방법이 필요한다.
- FieldError가 rejectedValue 속성을 사용해 해당 기능을 제공한다.
  - 이 때 타임리프의 th:field는 정상 상황에서는 모델 객체의 값을 사용하고, 오류가 발생하면 FieldError에서 보관한 값을 사용해서 값을 출력함으로써 이 문제를 해결한다.
GlobalError
- bindingResult.addError(new ObjectError(objectName, defaultMessage)

타임리프

#fields
- #fields.hasGlobalError()
- BindingResult가 제공하는 검증 오류가 접근할 수 있다.
th:errors
- 해당 필드에 오류가 있는 경우 태그 출력
th:errorclass
- th:field에서 지정한 필드에 오류가 있으면 class정보를 추가한다.

※ @ModelAttribute에 바인딩 시 타입 오류가 발생하면?

오류정보(FieldError)를 BindingResult에 담아서 컨트롤러를 정상 호출한다.

V3 - errors.properties

errors.properties 파일을 생성하고 application.properties 파일에 spring.messages.basename=messages,errors 를 추가한다.
errors.properties 파일에 있는 값에 따라 각각 code, argument에 값을 대입한다.

// FieldError
bindingResult.addError(new FieldError("item", "itemName", item.getItemName(), false, new String[]{"required.item.itemName"}, null, null));
// ObjectError
bindingResult.addError(new ObjectError("item", new String[]{"totalPriceMin"}, new Object[]{10000, resultPrice}, null));

V4 - reject, rejectValue

// FieldError , rejectValue
bindingResult.rejectValue("price", "range", new Object[]{1000, 1000000}, null);
// ObjectError, reject
bindingResult.reject("totalPriceMin", new Object[]{10000, resultPrice}, null);

FieldError, ObjectError는 다루기가 번거롭다.
BindingResult는 이미 본인이 검증해야 할 객체인 target을 알고 있다. → 이를 활용해 rejectValue와, reject가 FieldError, ObjectError를 대체한다.
오류 코드를 축약해서 입력해도 잘 찾아서 출력한다.
- MessageCodesResolver를 이용하기 때문
```
MessageCodesResolver codesResolver = new DefaultMessageCodesResolver();
String [] messageCodes = codesResolver.resolveMessageCodes("required", "item");
```
  - 기본 메시지 (코드) 생성 규칙
    객체 오류
    객체 오류의 경우 다음 순서로 2가지 생성
    1.: code + "." + object name
    2.: code
    예) 오류 코드: required, object name: item
    1. : required.item
    2. : required
    필드 오류
    필드 오류의 경우 다음 순서로 4가지 메시지 코드 생성
    1.: code + "." + object name + "." + field
    2.: code + "." + field
    3.: code + "." + field type
    4.: code
  - 동작방식
    - rejectValue(), reject() 는 내부에서 MessageCodesResolver를 사용한다.
    - FieldError - rejectValue(”itemName”, “required”) required.item.itemName
      required.itemName
      required.java.lang.String
      required
    - ObjectError - reject(”totalPriceMin”) totalPriceMin.item
      totalPriceMin

ValidationUtils

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

스프링이 직접 만든 오류 메시지 처리

검증 오류 코드 종류

개발자가 직접 설정한 오류 코드 → rejectValue()를 직접 호출
스프링이 직접 검증 오류에 추가한 경우
- → 로그 확인 → 메시지 코드 확인 typeMismatch.item.price
  typeMismatch.price
  typeMismatch.java.lang.Integer
  typeMismatch 다음과 같이 4가지 메시지 코드가 입력되어 있다. → 스프링은 타입 오류가 발생하면 typeMismatch 라는 오류 코드를 사용하는데 이 코드가 MessageCodesResolver를 통하면서 4가지 메시지 코드가 생성된 것이다.

V5 - Validator 분리

컨트롤러 코드

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

        itemValidator.validate(item, bindingResult);

        if(bindingResult.hasErrors()){
            log.info("error={}", 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 클래스 생성

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

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

        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "itemName", "required");

        if (item.getPrice() == null || item.getPrice() < 1000 || item.getPrice() > 1000000){
            errors.rejectValue("price", "range", new Object[]{1000, 1000000}, null);
        }
        if(item.getQuantity() == null || item.getQuantity() > 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를 컴포넌트 스캔했기 때문에 컨트롤러에서는 validator를 주입하고 사용하면 된다.

V6 - @Validated, WebDataBinder

Validator 클래스에 Validator 인터페이스를 implement한 이유는 체계적으로 검증 기능을 도입하기 위해서이다.

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

위와 같이 선언한 후에 검증을 하고자 하는 컨트롤러의 Argument로 @Validated Annotation을 추가하면 앞서 WebDataBinder에 등록한 검증기를 찾아서 실행한다.
이 때 여러 검증기를 등록한다면 그 중 어떤 검증기가 실행되어야 할 지 구분하기 위해 supports 메서드가 사용된다.

※ 글로벌 설정

@SpringBootApplication
public class ItemServiceApplication implements WebMvcConfigurer {
 public static void main(String[] args) {
	 SpringApplication.run(ItemServiceApplication.class, args);
	 }
	 @Override
	 public Validator getValidator() {
	 return new ItemValidator();
	 }
}

✔️ Bean Validation

build.gradle에 의존관계 추가
- implementation 'org.springframework.boot:spring-boot-starter-validation

@NotBlank : 빈값 + 공백만 있는 경우를 허용하지 않는다.
@NotNull : null 을 허용하지 않는다.
@Range(min = 1000, max = 1000000) : 범위 안의 값이어야 한다.
@Max(9999) : 최대 9999까지만 허용한다.

검증 순서

@ModelAttribute 각각의 필드에 타입 변환 시도
1. 성공하면 다음으로
2. 실패하면 typeMismatch 로 FieldError 추가
  
  → errors.properties에 선언한 에러메시지 출력
Validator 적용

바인딩에 성공한 필드만 Bean Validation 적용
BeanValidator는 바인딩에 실패한 필드는 BeanValidation을 적용하지 않는다.
타입 변환에 성공해서 바인딩에 성공한 필드여야 BeanValidation 적용이 의미 있다

에러 메시지

//errors.properties
#Bean Validation 추가

NotBlank={0} 공백X
Range={0}, {2} ~ {1} 허용
Max={0}, 최대 {1}

{0} 은 필드명이고, {1} , {2} ...은 각 애노테이션 마다 다르다.
BeanValidation 메시지 찾는 순서
1. 생성된 메시지 코드 순서대로 messageSource(errors.properties) 에서 메시지 찾기
2. 애노테이션의 message 속성 사용 → @NotBlank(message = "공백! {0}")
3. 라이브러리가 제공하는 기본 값 사용

오브젝트 오류

FieldError가 아닌 ObjectError를 처리하는 방법

실무에서는 두번째 방법 권장

@ScriptAssert

@Data
@ScriptAssert(lang = "javascript", script = "_this.price * _this.quantity >= 
10000")
public class Item {
 //...
}

글로벌 오류 직접 추가

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

한계와 해결

상황
- 수정할 때는 id를 필수값으로 하고 수량에 제한을 두지 않지만 등록할 때는 id가 없어도 되고 수량에 제한을 둔다 → 수정과 등록의 Validation을 다르게 설정하는 경우

2가지 방법

BeanValidation의 Group 기능을 사용
1. 각 그룹별 인터페이스 파일 생성
2. 데이터 클래스의 각 Validation Annotation에 groups Argument 추가
3. 컨트롤러의 Validated Annotation에 Argument로 인터페이스 클래스 선언
Item을 직접 사용하지 않고, ItemSaveForm, ItemUpdateForm 같은 폼 전송을 위한 별도의 모델 객체를 만들어 사용 - DTO
- 주의사항
  - @ModelAttribute의 Argument 고려 - 생략할 시 모델 객체 이름으로 등록
  - 레포지토리 메서드의 인자값으로는 item 인스턴스가 들어가야하기 때문에 item 생성 후 삽입

Bean Validation - HTTP 메시지 컨버터(Body)

@ModelAttribute는 HTTP요청 파라미터(URL 쿼리스트링, Post Form)를 다룰 때 사용한다.

@RequestBody는 HTTP Body의 데이터를 객체로 변환할 때 사용한다. (API JSON 요청)

API - 3가지 경우

성공 요청: 성공
실패 요청: JSON 객체로 생성하는 것 자체가 실패
검증 오류 요청: JSON을 객체로 생성하는 것은 성공했고, 검증에서 실패

@ModelAttribute VS @RequestBody

@ModelAttribute는 각각의 필드 단위로 적용된다. 그래서 특정 필드에 타입이 맞지 않는 오류가 발생해도 나머지 필드는 정상 처리할 수 있다. → 특정 필드가 바인딩되지 않아도 나머지 필드는 정상 바인딩, Validator 검증 가능
HttpMessageConverter는 전체 객체 단위로 적용된다.
- 따라서 메시지 컨버터의 작동이 성공해서 ItemSaveForm 객체를 만들어야 @Validated가 적용된다.
```
→ **RequestBody는 메시지 컨버터 단계에서 JSON 데이터를 객체로 변경하지 못하면 Validator 검증 불가능**
```
  → HttpMessageConverter 단계에서 실패한 예외 처리방법은 뒤의 예외 처리 부분에서 다룸.

✔️ 로그인 처리 - 쿠키, 세션

로그인, 회원가입 폼, 기능 구현 (Base)

홈 화면 HTML

회원가입

Member Data Class

MemberRepository

// 자바 문법 참고
public Optional<Member> findByLoginId(String loginId) {
 return findAll().stream()
 .filter(m -> m.getLoginId().equals(loginId))
 .findFirst();
 }

MemberController
HTML

로그인

LoginService (도메인 패키지에 생성)
login DTO (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:/";
 }

쿠키

쿠키 생성 로직

Cookie cookie = new Cookie("memberId", String.valueOf(loginMember.getId()));
response.addCookie(cookie);

로그아웃 로직

새로운 쿠키를 만들고 setMaxAge로 유효시간을 0초로 만든다.

		@PostMapping("/logout")
    public String logout(HttpServletResponse response){
        expiredCookie(response, "memberId");
        return "redirect:/";
    }

    private static void expiredCookie(HttpServletResponse response, String cookieName) {
        Cookie cookie = new Cookie(cookieName, null);
        cookie.setMaxAge(0);
        response.addCookie(cookie);
    }

쿠키 보안 문제

문제점

쿠키 값은 임의로 변경할 수 있다.
쿠키에 보관된 정보는 훔쳐갈 수 있다.
해커가 쿠키를 한번 훔쳐가면 평생 사용할 수 있다.

대안

쿠키에 중요한 값을 노출하지 않고, 사용자 별로 예측 불가능한 임의의 토큰을 노출, 서버에서 토큰과 사용과 id를 매핑해서 인식, 서버에서 토큰 관리
토큰이 해킹당해도 시간이 지나면 사용할 수 없도록 서버에서 해당 토큰의 만료시간을 짧게 유지한다.

세션

동작 방식

쿠키의 보안 이슈를 해결하려면 중요한 정보는 모두 서버에 저장해야 한다. → 이렇게 서버에 중요한 정보를 보관하고 연결을 유지하는 방법을 세션이라고 한다.

세션 직접 만들기

세션 매니저 클래스

@Component
public class SessionManager {

    private Map<String, Object> sessionStore = new ConcurrentHashMap<>();
    public static final String SESSION_COOKIE_NAME = "mySessionId";
    /**
     * 세션 생성
     */
    public void createSession(Object value, HttpServletResponse response){
        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 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());
        }
    }

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

세션 테스트

@Test
    void sessionTest(){
        //세션 생성
        MockHttpServletResponse response = new MockHttpServletResponse();
        Member member = new Member();
        sessionManager.createSession(member, response);

        //쿠키 조작
        MockHttpServletRequest request = new MockHttpServletRequest();
        request.setCookies(response.getCookies());

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

        //세션 만료
        sessionManager.expire(request);
        Object expired = sessionManager.getSession(request);
        assertThat(expired).isNull();
    }

서블릿 HTTP 세션

HttpSession의 쿠키 이름은 JSESSIONID 이고 값은 추정 불가능한 랜덤 ㄱ밧

세션 생성과 조회

코드

// 로그인 성공 처리 TODO
//sessionManager.createSession(loginMember, response);
HttpSession session = request.getSession();
session.setAttribute(SessionConst.LOGIN_MEMBER, loginMember);

//sessionManager.expire(request);
HttpSession session = request.getSession(false);
if (session != null){
    session.invalidate();
}

세션 생성 및 조회
- request.getSession(True)
  - True일 경우 - 생성 - Default값
    - 세션이 있으면 기존 세션 반환
    - 없으면 새로운 세션 생성 후 반환
  - False일 경우 - 조회
    - 세션이 있으면 기존 세션 반환
    - 없으면 null 반환
세션 삭제
- session.invalidate()

@SessionAttribute

세션을 편리하게 사용할 수 있도록 스프링에서 지원하는 Annotation

기존코드

		//@GetMapping("/")
    public String loginHomeV3(HttpServletRequest request, Model model){
        HttpSession session = request.getSession(false);
        if (session == null){
            return "home";
        }
        Object member = session.getAttribute(SessionConst.LOGIN_MEMBER);
        if (member == null){
            return "home";
        }
        model.addAttribute("member", member);
        return "loginHome";
    }

변경 후 코드

    @GetMapping("/")
    public String loginHomeV3Spring(@SessionAttribute(value = SessionConst.LOGIN_MEMBER, required = false) Member member, Model model){
        if (member == null){
            return "home";
        }
        model.addAttribute("member", member);
        return "loginHome";
    }
}

※ Traking Mode

서버입장에서 웹브라우저가 쿠키를 지원하는지 모르기 때문에 최초 접근 시 쿠기 값도 전달하고 URL에도 JSESSIONID 를 전달한다.
- URL 전달 방식을 끄고 쿠키를 통해서만 세션을 유지하고 싶을 때
  - application.properties - server.servlet.session.tracking-modes=cookie

세션 정보와 타임아웃 설정

세션 정보

@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("maxInactiveInterval={}", 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 )를 요청해서 조회된 세션인지 여부

세션 타임아웃 설정
- 문제점
  - 사용자가 로그아웃을 하지않고 웹 브라우저를 종료한 경우 서버는 웹 브라우저를 종료한 것인지 아닌지를 인식할 수 없어서 데이터를 언제 삭제해야 하는지 판단하기가 어렵다.
  - 이 경우 남아있는 세션을 무한정 보관하면 문제가 발생한다.
- HttpSession의 해결방법
  - 위와 같은 문제를 해결하기 위해 세션의 타임아웃 시간을 마지막 접근 시간으로부터 30분을 Default값으로 잡는다.
- 타임 아웃 시간 설정방법
  - 글로벌 설정: application.properties - server.servlet.session.timeout=60 (글로벌 설정은 분 단위로 설정해야한다.)
  - 특정 세션 설정: session.setMaxInactiveInterval(1800);
실무 주의점
- 세션에는 최소한의 데이터만 보관해야한다. 현재 프로젝트에는 Member 객체 전체를 담았지만 실무에서 사용할 때는 아이디, 닉네임 등 꼭 필요한 정보들만 핏하게 담는게 좋다.

✔️ 필터, 인터셉터

공통 관심 사항

로그인한 사용자만 상품 관리 페이지에 들어갈 수 있어야한다.
- 현재는 URL을 입력하면 로그인을 하지않아도 해당 페이지에 들어갈 수 있다.
이러한 공통관심사는 AOP로도 해결할 수 있찌만. 웹과 관련된 공통 관심사를 처리할 때는 HTTP 헤더나 URL 정보가 필요하기 때문에 HttpServletRequest를 제공하는 서블릿 필터나 스프링 인터셉터를 사용하는게 좋다.

서블릿 필터

필터 인터페이스를 구현하고 등록하면 서블릿 컨테이너가 필터를 싱글톤 객체로 생성하고 관리한다.

필터 제한 플로우

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

필터 - 요청 로그

필터 코드 (LogFilter)

ServletRequest request는 HTTP 요청이 아닌 경우까지 고려해서 만든 인터페이스이기 때문에 HTTP를 사용하면 HttpServletRequest로 다운 케스팅하면 된다.

chain.doFilter(request, response);
- 이 로직을 호출하지 않으면 다음 단계로 진행되지 않는다.

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

Configuration 코드 (WebConfig) - FilterRegistrationBean

@Configuration
public class WebConfig {

    @Bean
    public FilterRegistrationBean logFilter(){
        FilterRegistrationBean<Filter> filterRegistrationBean = new FilterRegistrationBean<>();
        filterRegistrationBean.setFilter(new LogFilter());
        filterRegistrationBean.setOrder(1);
        filterRegistrationBean.addUrlPatterns("/*");

        return filterRegistrationBean;
    }
}

@ServletComponentScan @WebFilter(filterName = "logFilter", urlPatterns = "/*") 로
필터 등록이 가능하지만 필터 순서 조절이 안된다. 따라서 FilterRegistrationBean 을 사용하자

필터 - 인증 체크

필터 코드 (LoginCheckFilter)

sendRedirect에 redirectURL을 Param으로 줌으로써 로그인페이지로 리다렉트 한 후 로그인 시 요청했던 페이지로 다시 돌아갈 수 있도록 한다.
- LoginController login 로직 return 값에 RequestParam으로 받은 redirectURL 추가

@Slf4j
public class LoginCheckFilter implements Filter {

    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();
                if(session == null || session.getAttribute(SessionConst.LOGIN_MEMBER) == null){
                    log.info("미인증 사용자 요청 {}", requestURI);
                    httpResponse.sendRedirect("/login?redirectURL=" + requestURI);
                    return;
                }
            }
            chain.doFilter(request, response);
        } catch (Exception e){
            throw e;
        } finally {
            log.info("인증 체크 필터 종료 {}", requestURI);
        }
    }

    private boolean isLoginCheckPath(String requestURI){
        return !PatternMatchUtils.simpleMatch(whitelist, requestURI);
    }
}

Configuration 코드

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

        return filterRegistrationBean;
    }

스프링 인터셉터

스프링 인터셉터 제한 플로우

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

스프링 인터셉터 호출 흐름

인터셉터 예외 상황

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

인터셉터 코드

setAttribute를 통해 uuid 값을 전달해서 같은 값을 사용할 수 있다.

@Slf4j
public class LoginInterceptor 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);

        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("postHandle [{}]", modelAndView);
    }

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

Configuration 등록 코드

@Configuration
public class WebConfig implements WebMvcConfigurer {

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

스프링 인터셉터 - 인증 요청

인터셉터 코드

URL 체크를 Configuration 클래스에서 하기때문에 인터셉터 로직이 단순해진다.

@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(false);
        if(session == null || session.getAttribute(SessionConst.LOGIN_MEMBER) == null){
            log.info("미인증 사용자 요청");
            response.sendRedirect("login?redirectURL=" + requestURI);
            return false;
        }
        return true;
    }
}

Configuration 등록 코드

@Configuration
public class WebConfig implements WebMvcConfigurer {

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

        registry.addInterceptor(new LoginCheckInterceptor())
                .order(2)
                .addPathPatterns("/**")
                .excludePathPatterns("/", "/members/add", "/login", "/logout", "/css/**", "/*.ico", "/error");
    }

Argument Resolver

@Login Annotation이 있으면 직접 만든 ArgumentResolver가 동작해서 자동으로 세션에 있는 로그인 회원을 찾아주고, 만약 세션에 없다면 null 값을 반환하도록 개발

로그인 Annotation 생성

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

Target: 파라미터에만 사용
Retatetion: 리플렉션 등을 활용할 수 있도록 런타임까지 애노테이션 정보가 남아있음.

LoginMenberArgumentResolver 생성

@Slf4j
public class LoginMemberArgumentResolver implements HandlerMethodArgumentResolver {
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        log.info("supportParameter 실행");
        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 : 컨트롤러 호출 직전에 호출되어서 필요한 파라미터 정보를 생성

Configuration에 설정 추가

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(new LoginMemberArgumentResolver());
    }
}

✔️ 예외 처리와 오류 페이지

웹 애플리케이션

웹 애플리케이션은 사용자 요청별로 별도의 쓰레드가 할당되고, 서블릿 컨테이너 안에서 실행된다. 애플리케이션에서 예외가 발생했는데, 어디선가 try ~ catch로 예외를 잡아서 처리하면 아무런 문제가 없다. 그런데 만약에 애플리케이션에서 예외를 잡지 못하고, 서블릿 밖으로 까지 예외가 전달되면 어떻게 동작할까?

Exception

예외처리를 하지못한 예외가 발생하게 되면 서블릿밖인 WAS(Tomcat)까지 전달이 되고 톰캣이 기본으로 제공하는 오류 화면을 볼 수 있다
- 500 - Internal Server Error
라우팅을 해놓지 않은 아무 URL을 호출 시에는 404 - Not Found 오류 화면 반환

⚙️ **WAS(여기까지 전파) <- 필터 <- 서블릿 <- 인터셉터 <- 컨트롤러(예외발생)**

SendError

response.sendError(HTTP 상태 코드, 오류 메시지)
- 상태 코드와 오류 메시지도 추가할 수 있다.
해당 메서드가 실행되면 당장 예외가 발생하는 것은 아니지만, 서블릿 컨테이너에게 오류가 발생했다는 점을 전달 할 수 있다.

⚙️ **WAS(sendError 호출 기록 확인) <- 필터 <- 서블릿 <- 인터셉터 <- 컨트롤러**

서블릿 예외 처리

서블릿 오류 페이지 등록

코드

package hello.exception;

@Component
public class WebServerCustomizer implements WebServerFactoryCustomizer<ConfigurableWebServerFactory> {
    @Override
    public void customize(ConfigurableWebServerFactory factory) {
        ErrorPage errorPage404 = new ErrorPage(HttpStatus.NOT_FOUND, "/error-page/404");
        ErrorPage errorPage500 = new ErrorPage(HttpStatus.INTERNAL_SERVER_ERROR, "/error-page/500");
        ErrorPage errorPageEx = new ErrorPage(RuntimeException.class, "/error-page/500");
        factory.addErrorPages(errorPage404, errorPage500, errorPageEx);
    }
}

오류 처리 컨트롤러 등록

코드

@Slf4j
@Controller
public class ServletExController {

    @GetMapping("/error-ex")
    public void errorEx(){
        throw new RuntimeException("예외 발생!");
    }
    @GetMapping("/error-404")
    public void error404(HttpServletResponse response) throws IOException {
        response.sendError(404, "404오류!");
    }
    @GetMapping("/error-500")
    public void error500(HttpServletResponse response) throws IOException {
        response.sendError(500);
    }
}

서블릿 오류 페이지 작동원리

⚙️ **WAS(여기까지 전파) <- 필터 <- 서블릿 <- 인터셉터 <- 컨트롤러(예외발생)

WAS /error-page/500 다시 요청 -> 필터 -> 서블릿 -> 인터셉터 -> 컨트롤러(/errorpage/500) -> View**

예외가 발생해서 WAS까지 전파된다.
WAS는 오류 페이지 경로를 찾아서 내부에서 오류 페이지를 호출한다. 이때 오류 페이지 경로로 필터, 서블릿, 인터셉터, 컨트롤러가 모두 다시 호출된다.
- 오류 정보 추가
  - WAS는 오류 페이지를 단순히 다시 요청만 하는 것이 아니라, 오류 정보를 request 의 attribute에 추가해서 넘겨준다.
    
    javax.servlet.error.exception : 예외
    javax.servlet.error.exception_type : 예외 타입
    javax.servlet.error.message : 오류 메시지
    javax.servlet.error.request_uri : 클라이언트 요청 URI
    javax.servlet.error.servlet_name : 오류가 발생한 서블릿 이름
    javax.servlet.error.status_code : HTTP 상태 코드

서블릿 예외 처리 - 필터

오류가 발생하면 WAS에서 다시 한번 호출이 발생하는데 이때 다시 필터와 인터셉터가 호출된다. 그런데 필터와 인터셉터는 오류가 발생한 요청에서 이미 한번 완료된 사항이기 때문에 굳이 호출할 필요가 없다.
서블릿은 이 문제를 해결하기 위해 DispatcherType 이라는 추가정보를 제공한다.
- DispatcherType
  
  REQUEST : 클라이언트 요청
  ERROR : 오류 요청
  FORWARD : MVC에서 배웠던 서블릿에서 다른 서블릿이나 JSP를 호출할 때
  RequestDispatcher.forward(request, response);
  INCLUDE : 서블릿에서 다른 서블릿이나 JSP의 결과를 포함할 때
  RequestDispatcher.include(request, response);
  ASYNC : 서블릿 비동기 호출
해결방법
- Configuration에서 Filter를 추가할 때 해당 코드를 추가하면 된다.
  - filterRegistrationBean.setDispatcherTypes(DispatcherType.REQUEST, DispatcherType.ERROR);
  - setDispatcherTypes의 Default Value는 Request

서블릿 예외 처리 - 인터셉터

인터셉터에는 DispatcherType과 같은 것이 없다.
excludePathPatterns에 error-page 경로를 추가해주면 된다.

스프링부트 예외 처리

스프링 부트는 에러페이지를 자동으로 등록한다.
- /error 라는 경로로 기본 오류 페이지를 설정한다.
WebServerCustomizer로 상태코드와 예외 처리를 설정하지 않으면 기본 오류 페이지로 사용된다.
BasicErrorController라는 스프링 컨트롤러 또한 자동으로 등록한다.
- ErrorPage에서 등록한 /error를 매핑해서 처리하는 컨트롤러
개발자는 오류페이지(뷰)만 등록하면 된다.
- 우선순위
  1. 뷰템플릿
    1. resources/templates/error/500.html
    2. resources/templates/error/5xx.html
  2. 정적 리소스
  3. 적용 대상이 없을 때 뷰 이름(error)

오류 정보를 뷰 페이지에 쉽게 노출시킬 수 있다.

코드

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
 <meta charset="utf-8">
</head>
<body>
<div class="container" style="max-width: 600px">
 <div class="py-5 text-center">
 <h2>500 오류 화면 스프링 부트 제공</h2>
 </div>
 <div>
 <p>오류 화면 입니다.</p>
 </div>
 <ul>
 <li>오류 정보</li>
 <ul>
 <li th:text="|timestamp: ${timestamp}|"></li>
 <li th:text="|path: ${path}|"></li>
 <li th:text="|status: ${status}|"></li>
 <li th:text="|message: ${message}|"></li>
 <li th:text="|error: ${error}|"></li>
 <li th:text="|exception: ${exception}|"></li>
 <li th:text="|errors: ${errors}|"></li>
 <li th:text="|trace: ${trace}|"></li>
 </ul>
 </li>
 </ul>
 <hr class="my-4">
</div> <!-- /container -->
</body>
</html>

옵션
- application.properties
```
server.error.include-exception=true
server.error.include-message=on_param
server.error.include-stacktrace=on_param
server.error.include-binding-errors=on_param
```
- 기본 값이 never 인 부분은 다음 3가지 옵션을 사용할 수 있다.
  - never : 사용하지 않음
  - always :항상 사용
  - on_param : 파라미터가 있을 때 사용

✔️ API 예외처리

직접 컨트롤러 처리

		@RequestMapping(value = "/error-page/500", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity <Map<String, Object>> errorPage500Api(HttpServletRequest request, HttpServletResponse response){
        Map<String, Object> result = new HashMap<>();
        Exception ex = (Exception) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);
        result.put("status", request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE));
        result.put("message", ex.getMessage());

        Integer statusCode = (Integer) request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);
        return new ResponseEntity(result, HttpStatus.valueOf(statusCode));
    }

produces=MediaType.APPLICATION_JSON_VALUE를 선언하면 클라이언트가 요청하는 HTTP Header의 Accpet의 값이 application/json일 때 해당 메서드가 우선호출된다. ※ Jackson 라이브러리는 Map을 Json 구조로 변환할 수 있다.

스프링 부트 기본 오류 처리

Request Accept 타입이 HTML일 때와 같이 Application/json 일 때에도 BasicErrorController에서 자동으로 JSON 형식으로 오류처리를 해준다.
- BasicErrorController를 확장하면 JSON 오류 메시지도 변경할 수 있다.
하지만 HTML 형식이 아닌 JSON형식의 경우에는 API마다 발생하는 예외의 경우가 다양하고 복잡하다. 따라서 BasicErrorController를 이용한 방식은 4xx, 5xx 오류와 같이 일관되게 처리할 수 있는 HTML 화면을 처리할 때 사용하고 API 오류처리는 @ExceptionHandler 를 사용하자

HandlerExceptionResolver

기존에는 컨트롤러에서 예외가 발생해서 서블릿을 넘어 WAS까지 전달되면 500에러를 던져줬다. 이 에러를 400에러, 404에러 등 자신이 원하는 에러로 바꿔서 던져주거나 메시지, 형식을 바꾸기 위해서는 ExceptionResolver를 조작해야한다.

- 코드1
    
    ```java
    @Slf4j
    public class MyHandlerExceptionResolver implements HandlerExceptionResolver {
     @Override
     public ModelAndView resolveException(HttpServletRequest request,
    HttpServletResponse response, Object handler, Exception ex) {
    	 try {
    			 if (ex instanceof IllegalArgumentException) {
    			 log.info("IllegalArgumentException resolver to 400");
    			 response.sendError(HttpServletResponse.SC_BAD_REQUEST, ex.getMessage());
    			 return new ModelAndView();
    	 }
    	 } catch (IOException e) {
    			 log.error("resolver ex", e);
    	 }
    	 return null;
     }
    }
    ```

반환 값에 따른 동작 방식

HandlerExceptionResolver 의 반환 값에 따른 DispatcherServlet 의 동작 방식은 다음과 같다.
- 빈 ModelAndView
  - new ModelAndView() 처럼 빈 ModelAndView 를 반환하면 뷰를 렌더링 하지 않고, 정상 흐름으로 서블릿이 리턴된다.
- ModelAndView 지정
  - ModelAndView 에 View , Model 등의 정보를 지정해서 반환하면 뷰를 렌더링한다.
- null
  - null 을 반환하면, 다음 ExceptionResolver 를 찾아서 실행한다. 만약 처리할 수 있는
    ExceptionResolver 가 없으면 예외 처리가 안되고, 기존에 발생한 예외를 서블릿 밖으로 던진다.

ExceptionResolver 활용

예외 상태 코드 변환
- 예외를 response.sendError(xxx) 호출로 변경해서 서블릿에서 상태 코드에 따른 오류를
  처리하도록 위임
- 이후 WAS는 서블릿 오류 페이지를 찾아서 내부 호출, 예를 들어서 스프링 부트가 기본으로 설정한 /error 가 호출됨
뷰 템플릿 처리
- ModelAndView 에 값을 채워서 예외에 따른 새로운 오류 화면 뷰 렌더링 해서 고객에게 제공
API 응답 처리
- response.getWriter().println("hello"); 처럼 HTTP 응답 바디에 직접 데이터를 넣어주는
  것도 가능하다. 여기에 JSON 으로 응답하면 API 응답 처리를 할 수 있다.

코드

@Slf4j
public class UserHandlerExceptionResolver implements HandlerExceptionResolver {
 private final ObjectMapper objectMapper = new ObjectMapper();
 @Override
 public ModelAndView resolveException(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex) {
 try {
	 if (ex instanceof UserException) {
		 log.info("UserException resolver to 400");
		 String acceptHeader = request.getHeader("accept");
		 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
			 if ("application/json".equals(acceptHeader)) {
				 Map<String, Object> errorResult = new HashMap<>();
				 errorResult.put("ex", ex.getClass());
				 errorResult.put("message", ex.getMessage());

				 String result = objectMapper.writeValueAsString(errorResult);
				
				 response.setContentType("application/json");
				 response.setCharacterEncoding("utf-8");
				 response.getWriter().write(result);
				 return new ModelAndView();
			 } else {
			 //TEXT/HTML
				 return new ModelAndView("error/500");
			 }
	 }
 } catch (IOException e) {
 log.error("resolver ex", e);
 }
 return null;
 }
}

스프링이 제공하는 ExceptionResolver

⚙️ 1.**ExceptionHandlerExceptionResolver** - `@ExceptionHandler` 2.ResponseStatusExceptionResolver - HTTP 상태 코드 지정3.DefaultHandlerExceptionResolver - 스프링 내부 기본 예외 처리

2. ResponseStatusExceptionResolver

**@ResponseStatus 가 달려있는 예외 처리**
```
@ResponseStatus(code = HttpStatus.BAD_REQUEST, reason = "잘못된 요청 오류")
public class BadRequestException extends RuntimeException {
}
```
- sendError를 통해 지정한 상태코드, 메시지 처리 → WAS에서 다시 오류페이지를 내부 요청
ResponseStatusException 예외 처리
```
@GetMapping("/api/response-status-ex2")
public String responseStatusEx2() {
 throw new ResponseStatusException(HttpStatus.NOT_FOUND, "error.bad", new
IllegalArgumentException());
}
```
- @ResponseStatus는 개발자가 직접 변경할 수 없는 예외에는 적용할 수 없다.
  - 동적 변경을 위해서는 ReponseStatusException 사용
※ 메시지 기능 사용 가능 - messages.properties에 메시지 지정 후 reason 값에 대입

1. ExceptionHandlerExceptionResolver - `@ExceptionHandler`

@ExceptionHandler 를 선언하고, 해당 컨트롤러에서 처리하고 싶은 예외를 지정해주면 된다.
다음과 같이 다양한 예외를 한번에 처리 할 수 있다.
- @ExceptionHandler({AException.class, BException.class})
❗실행흐름
- 컨트롤러를 호출한 결과 IllegalArgumentException 예외가 컨트롤러 밖으로 던져진다.
  - 예외가 발생했으로 ExceptionResolver 가 작동한다. 가장 우선순위가 높은
    ExceptionHandlerExceptionResolver 가 실행된다.
  - ExceptionHandlerExceptionResolver 는 해당 컨트롤러에 IllegalArgumentException 을 처리할 수 있는 @ExceptionHandler 가 있는지 확인한다.
  - illegalExHandle() 를 실행한다.
  - @RestController 이므로 illegalExHandle() 에도 @ResponseBody 가 적용된다. 따라서 HTTP 컨버터가 사용되고, 응답이 다음과 같은 JSON으로 반환된다.
  - @ResponseStatus(HttpStatus.BAD_REQUEST) 를 지정했으므로 HTTP 상태 코드 400으로 응답한다.

`@ControllerAdvice`

대상으로 지정한 여러 컨트롤러에 @ExceptionHandler, @InitBinder 기능을 부여해준다. 지정방법

// Target all Controllers annotated with @RestController
@ControllerAdvice(annotations = RestController.class)
public class ExampleAdvice1 {}

// Target all Controllers within specific packages
@ControllerAdvice("org.example.controllers")
public class ExampleAdvice2 {}

// Target all Controllers assignable to specific classes
@ControllerAdvice(assignableTypes = {ControllerInterface.class, AbstractController.class})
public class ExampleAdvice3 {}

✔️ 스프링 타입 컨버터

스프링 타입 변환 적용 예

스프링 MVC 요청 파라미터
- @RequestParam, @ModelAttribute, @PathVariable
뷰를 렌더링 할 때

타입 컨버터 - Converter

Integer를 String으로 변환하는 Converter와 같이 범용적인 컨버터는 스프링이 제공한다. 하지만 직접 만든 객체형 타입으로의 변환을 위한 컨버터는 직접 선언해서 컨버전 서비스를 이용하는 addFormatters로 추가해야한다.

컨버터 인터페이스를 통해 컨버터 클래스를 구현한다.
WebConfig의 addFormatters 메서드를 사용해 컨버터를 추가한다.
1. 스프링 내부에서 ConversionService를 제공한다.

ConversionService

타입 컨버터를 선언해두고 하나씩 직접 찾아서 사용하는 것은 매우 불편하기 때문에 스프링은 개별 컨버터를 모아두고 사용할 수 있는 ConversionService 기능을 제공한다.

인터페이스 분리 원칙 - ISP

ISP는 클라이언트가 자신이 이용하지 않는 메서드에 의존하지 않아야 한다.
DefaultConversionService 다음 두 인터페이스를 구현했다.
- ConversionService : 컨버터 사용에 초점
- ConversionRegistry : 컨버터 등록에 초점
  
  이렇게 인터페이스를 분리하면 컨버터를 사용하는 클라이언트와 컨버터를 등록하고 관리하는 클라이언트의 관심사를 명확하게 분리할 수 있다. 특히 컨버터를 사용하는 클라이언트는 ConversionService만 의존하면 되므로, 컨버터를 어떻게 등록하고 관리하는지 전혀 몰라도 된다.

뷰 템플릿에 컨버터 적용하기

타임리프는 ${{...}} 를 사용하면 자동으로 컨버전 서비스를 사용해서 변환된 결과를 출력한다.
- 변수표현식: ${...}
- 컨버전 서비스 적용: ${{...}}
th:field 를 사용하는 경우 컨버전 서비스가 자동으로 적용되기 때문에 일반적인 변수표현식을 사용하면 된다.

포맷터 - Formatter

컨버터는 범용 (객체 → 객체)
포맷터는 문자에 특화 (객체 → 문자, 문자 → 객체) + 현지화(Locale)

코드

public class MyNumberFormatter implements Formatter<Number> {
    @Override
    public Number parse(String text, Locale locale) throws ParseException {
        NumberFormat format = NumberFormat.getInstance(locale);
        return format.parse(text);
    }
    @Override
    public String print(Number object, Locale locale) {
        return NumberFormat.getInstance(locale).format(object);
    }
}

포맷터를 지원하는 컨버전 서비스 - `FormattingConversionService`

DefaultFormattingConversionService 는 FormattingConversionService 에 기본적인 통화, 숫자 관련 몇가지 기본 포맷터를 추가해서 제공한다.
FormattingConversionService 는 ConversionService관련 기능을 상속받기 떄문에 결과적으로 컨버터도 포맷터도 모두 등록할 수 있다.

→ 스프링 부트는 DefaultFormattingConversionService를 상속 받은 WebConversionService를 내부에서 사용한다.

스프링이 제공하는 기본 포맷터

Formatter 인터페이스의 구현 클래스를 찾아보면 수 많은 날짜나 시간 관련 포맷터가 제공되는 것을 확인할 수 있다. 그런데 포맷터는 기본형식이 지정되어 있기 떄문에 객체의 각 필드마다 다른 형식으로 포맷을 지원하기는 어렵다. → 이를 해결하기 위해 스프링에서는 두가지 애노테이션을 제공한다.
- @NumberFormat
  - 숫자 관련 형식 지정 포맷터 사용
- @DateTimeFormat
  - 날짜 관련 형식 지정 포맷터 사용
```
	@Data
 static class Form {
	 @NumberFormat(pattern = "###,###")
	 private Integer number;
	 @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
	 private LocalDateTime localDateTime;
 }
```

주의

메시지 컨버터(HttpMessageConverter)에는 컨버전 서비스가 적용되지 않는다.
HttpMessageConverter의 역할은 HTTP 메시지 바디의 내용을 객체로 변환하거나 객체를 HTTP메시지바디에 입력하는 것이다.
예를 들어 JSON를 객체로 변환하는 메시지 컨버터는 내부에서 Jackson 같은 라이브러리를 사용한다. JSON 결과로 만들어지는 숫자나 날짜 포맷을 변경하고 싶으면 해당 라이브러리가 제공하는 설정을 통해서 포맷을 지정해야 한다.
결과적으로 이것은 컨버전 서비스와 전혀 관계가 없다.
컨버전 서비스는 @RequestParam, @ModelAttribute, @PathVariable, 뷰 템플릿 등에서 사용할 수 있다.

✔️ 파일 전송

HTML 폼 전송 방식

application/x-www-form-urlencoded
multipart/form-data

문자와 바이너리 파일을 동시에 전송하는 것처럼 여러 형식의 폼을 전송시키기 위해서는 multipart/form-data라는 전송 방식을 사용해야한다.

→ enctype="multipart/form-data" 를 Form 태그에 선언

멀티 파트 사용 옵션

업로드 사이즈 제한

spring.servlet.multipart.max-file-size=1MB
spring.servlet.multipart.max-request-size=10MB

서블릿과 파일 업로드

코드

		@PostMapping("/upload")
    public String saveFileV1(HttpServletRequest request) throws ServletException, IOException {
        log.info("request={}", request);
        String itemName = request.getParameter("itemName");
        log.info("itemName={}", itemName);
        Collection<Part> parts = request.getParts();
        log.info("parts={}",parts);

        for (Part part : parts) {
            log.info("==== PART ====");
            log.info("name={}", part.getName());
            Collection<String> headerNames = part.getHeaderNames();
            for (String headerName : headerNames) {
                log.info("header {}: {}", headerName, part.getHeader(headerName));
            }

            //편의 메서드
            log.info("submittedFileName={}", part.getSubmittedFileName());
            log.info("size={}", part.getSize());

            //데이터 읽기
            InputStream inputStream = part.getInputStream();
            String body = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
            log.info("body={}", body);

            //파일에 저장하기
            if (StringUtils.hasText(part.getSubmittedFileName())){
                String fullPath = fileDir + part.getSubmittedFileName();
                log.info("파일 저장 fullPath={}", fullPath);
                part.write(fullPath);
            }
        }

멀티파트 형식은 전송 데이터를 하나하나 각각 PART로 나누어 전송한다.
서블릿이 제공하는 PART는 멀티파트 형식을 편리하게 읽을 수 있는 메서드를 제공한다.

스프링과 파일 업로드

코드

		@PostMapping("/upload")
    public String saveFile(@RequestParam String itemName,
                           @RequestParam MultipartFile file, HttpServletRequest request) throws IOException {
        log.info("request={}", request);
        log.info("itemName={}", itemName);
        log.info("multiPartFile={}", file);

        if(!file.isEmpty()){
            String fullPath = fileDir + file.getOriginalFilename();
            log.info("fullPath={}", fullPath);
            file.transferTo(new File(fullPath));
        }
        return "upload-form";
    }

@ModelAttribute에서도 MultipartFile을 동일하게 사용할 수 있다.

yeop

이전 포스트

🌱 스프링 MVC 1

다음 포스트