인프런 강의 59일차.

 - 스프링 MVC 2편 - 백엔드 웹 개발 활용 기술 1 (김영한 강사님)

 - 1편에서 배운 MVC를 활용할 수 있는 기술 습득

 - 타입 컨버터, 파일 업로드, 활용, 쿠키, 세션, 필터, 인터셉터, 예외 처리, 타임리프, 메시지, 국제화, 검증 등등

 

 11.6 파일 업로드 - 예제로 구현하는 파일 업로드, 다운로드

  - 실제 파일이나 이미지를 업로드, 다운로드 할 때는 몇가지 고려할 점이 있는데, 구체적인 예제로 알아보자

 

 * 요구사항

  - 상품을 관리

    > 상품 이름

    > 첨부파일 하나

    > 이미지 파일 여러개

  - 첨부파일을 업로드 다운로드 할 수 있다.

  - 업로드한 이미지를 웹 브라우저에서 확인할 수 있다

 

package hello.upload.domain;

import lombok.Data;

import java.util.List;

@Data
public class Item {

    private Long id;
    private String itemName;
    private UploadFile attachFile;
    private List<UploadFile> imageFiles;
}

 - hello.upload.domain.Item.java

 - Item 상품 도메인

 

package hello.upload.domain;

import org.springframework.stereotype.Repository;

import java.util.HashMap;
import java.util.Map;

@Repository
public class ItemRepository {

    private final Map<Long, Item> store = new HashMap<>();
    private long sequence = 0L;

    public Item save(Item item) {
        item.setId(++sequence);
        store.put(item.getId(), item);
        return item;
    }

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

 - hello.upload.domain.ItemRepository.java

 - Item 상품 리파지토리

 

package hello.upload.domain;

import lombok.Data;

@Data
public class UploadFile {

    private String uploadFileName;      //사용자가 업로드한 파일 명
    private String storeFileName;       //서버에 저장한 파일 명


    public UploadFile(String uploadFileName, String storeFileName) {
        this.uploadFileName = uploadFileName;
        this.storeFileName = storeFileName;
    }
}

 - hello.upload.domain.UploadFile.java

 - 업로드 파일 정보 보관

 - uploadFilename : 사용자가 업로드 한 파일 명 (사용자에게 보여주기 위함)

 - storeFileName : 서버에 저장할 파일 명 (동일 파일명이 얼마든지 입력될 수 있으므로 파일별로 관리하기 위함)

 

package hello.upload.file;

import hello.upload.domain.UploadFile;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

@Component
public class FileStore {

    @Value("${file.dir}")
    private String fileDir;

    public String getFullPath(String filename) {
        return fileDir + filename;
    }

    public UploadFile storeFile(MultipartFile multipartFile) throws IOException {
        if(multipartFile.isEmpty()) {
            return null;
        }

        String originalFilename = multipartFile.getOriginalFilename();
        String storeFileName = createFileName(originalFilename);

        multipartFile.transferTo(new File(getFullPath(storeFileName)));

        return new UploadFile(originalFilename, storeFileName);
    }

    public List<UploadFile> storeFiles(List<MultipartFile> multipartFiles) throws IOException {
        List<UploadFile> storeFileResult = new ArrayList<>();
        for (MultipartFile multipartFile : multipartFiles) {
            if(!multipartFile.isEmpty()) {
                //Ctrl + Alt + N : 로컬변수 선언된 곳 제거 후 inline 으로 사용
                storeFileResult.add(storeFile(multipartFile));
            }
        }
        return storeFileResult;
    }

    private String createFileName(String originalFilename) {
        //UUID를 활용해 서버에 저장하는 파일명 생성
        String uuid = UUID.randomUUID().toString();
        String ext = extractExt(originalFilename);

        return uuid + "." + ext;
    }

    private String extractExt(String originalFilename) {
        int pos = originalFilename.lastIndexOf(".");
        return originalFilename.substring(pos + 1);//확장자 구하기
    }
}

 - hello.upload.file.FileStore.java

 - 파일 저장과 관련된 업무 처리

 - 멀티파트 파일을 서버에 저장하는 역할을 담당한다.

   > createStoreFileName() : 서버 내부에서 관리하는 파일명은 유일한 이름을 생성하는 UUID 를 사용해서 중복없이 관리.

   > extractExt() : 확장자를 별도로 추출해서 서버 내부에서 관리하는 파일명에도 붙여준다.

   > 예를 들어서 고객이 a.png 라는 이름으로 업로드 하면 51041c62-86e4-4274-801d-614a7d9.png 와 같이 저장한다.

 

package hello.upload.controller;

import lombok.Data;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

@Data
public class ItemForm {

    private Long itemId;
    private String itemName;
    private List<MultipartFile> imageFiles;
    private MultipartFile attachFile;
}

 - hello.upload.controller.ItemForm.java

 - 상품 저장용 Form

 - List imageFiles : 이미지를 다중 업로드 하기 위해 MultipartFile 를 사용했다.

 - MultipartFile attachFile : 멀티파트는 @ModelAttribute 에서 사용할 수 있다

 

package hello.upload.controller;

import hello.upload.domain.Item;
import hello.upload.domain.ItemRepository;
import hello.upload.domain.UploadFile;
import hello.upload.file.FileStore;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.io.Resource;
import org.springframework.core.io.UrlResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import org.springframework.web.util.UriUtils;

import java.io.IOException;
import java.net.MalformedURLException;
import java.nio.charset.StandardCharsets;
import java.util.List;

@Slf4j
@Controller
@RequiredArgsConstructor
public class ItemController {

    private final ItemRepository itemRepository;
    private final FileStore fileStore;

    @GetMapping("/items/new")
    public String newItem(@ModelAttribute ItemForm form) {
        return "item-form";
    }

    @PostMapping("/items/new")
    public String saveItem(@ModelAttribute ItemForm form, RedirectAttributes redirectAttributes) throws IOException {
        ;
        UploadFile attachFile = fileStore.storeFile(form.getAttachFile());
        List<UploadFile> storeImageFiles = fileStore.storeFiles(form.getImageFiles());

        //데이터베이스에 저장
        Item item = new Item();
        item.setItemName(form.getItemName());
        item.setAttachFile(attachFile);
        item.setImageFiles(storeImageFiles);
        itemRepository.save(item);

        redirectAttributes.addAttribute("itemId", item.getId());
        return "redirect:/items/{itemId}";
    }

    @GetMapping("/items/{id}")
    public String items(@PathVariable Long id, Model model) {
        Item item = itemRepository.findById(id);
        model.addAttribute("item", item);
        return "item-view";
    }

    @ResponseBody
    @GetMapping("/images/{filename}")
    public Resource downloadImage(@PathVariable String filename) throws MalformedURLException {
        return new UrlResource("file:" + fileStore.getFullPath(filename));
    }

    @GetMapping("/attach/{itemId}")
    public ResponseEntity<Resource> downloadAttach(@PathVariable Long itemId) throws MalformedURLException {
        Item item = itemRepository.findById(itemId);
        String storeFileName = item.getAttachFile().getStoreFileName();
        String uploadFileName = item.getAttachFile().getUploadFileName();
        UrlResource resource = new UrlResource("file:" + fileStore.getFullPath(storeFileName));
        log.info("uploadFileName = {}", uploadFileName);


        //인코딩 된 파일명을 넣어줘야 파일명이 깨지는 것을 방지할 수 있다.
        String encodeUploadFileName = UriUtils.encode(uploadFileName, StandardCharsets.UTF_8);
        //header를 추가해야만 파일이 다운로드 된다. (헤더 없을 시 브라우저에서 open이 됨)
        String contentDisposition = "attachment; filename=\"" + encodeUploadFileName + "\"";

        return ResponseEntity.ok()
                .header(HttpHeaders.CONTENT_DISPOSITION, contentDisposition)
                .body(resource);
    }
}

 - hello.upload.controller.ItemController.java

 - @GetMapping("/items/new") : 등록 폼을 보여준다.

 - @PostMapping("/items/new") : 폼의 데이터를 저장하고 보여주는 화면으로 리다이렉트 한다.

 - @GetMapping("/items/{id}") : 상품을 보여준다

 - @GetMapping("/images/{filename}") : <img> 태그로 이미지를 조회할 때 사용한다. UrlResource 로 이미지 파일을 읽어서 @ResponseBody 로 이미지 바이너리를 반환한다.

 - @GetMapping("/attach/{itemId}") : 파일을 다운로드 할 때 실행한다. 예제를 더 단순화 할 수 있지만, 파일 다운로드 시 권한 체크같은 복잡한 상황까지 가정한다 생각하고 이미지 id 를 요청하도록 했다. 파일 다운로드시에는 고객이 업로드한 파일 이름으로 다운로드 하는게 좋다. 이때는 Content-Disposition 해더에 attachment; filename="업로드 파일명" 값을 주면 된다

 

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
</head>
<body>
<div class="container">
    <div class="py-5 text-center">
        <h2>상품 등록</h2>
    </div>
    <form th:action method="post" enctype="multipart/form-data">
        <ul>
            <li>상품명 <input type="text" name="itemName"></li>
            <li>첨부파일<input type="file" name="attachFile" ></li>
            <li>이미지 파일들<input type="file" multiple="multiple" name="imageFiles" ></li>
        </ul>
        <input type="submit"/>
    </form>
</div> <!-- /container -->
</body>
</html>

 - templates/item-form.html

 - Item 등록 폼 뷰

 

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
</head>
<body>
<div class="container">
    <div class="py-5 text-center">
        <h2>상품 조회</h2>
    </div>
    상품명: <span th:text="${item.itemName}">상품명</span><br/>
    첨부파일: <a th:if="${item.attachFile}" th:href="|/attach/${item.id}|" th:text="${item.getAttachFile().getUploadFileName()}" /><br/>
    <img th:each="imageFile : ${item.imageFiles}" th:src="|/images/${imageFile.getStoreFileName()}|" width="300" height="300"/>
</div> <!-- /container -->
</body>
</html>

 - templates/item-view.html

 - 아이템 조회 뷰

 - 첨부 파일은 링크로 걸어두고, 이미지는 img 태그를 반복해서 출력한다

 

 * 실행

  - 실행해보면 하나의 첨부파일을 다운로드 업로드 하고, 여러 이미지 파일을 한번에 업로드 할 수 있다

 

 

인프런 강의 58일차.

 - 스프링 MVC 2편 - 백엔드 웹 개발 활용 기술 1 (김영한 강사님)

 - 1편에서 배운 MVC를 활용할 수 있는 기술 습득

 - 타입 컨버터, 파일 업로드, 활용, 쿠키, 세션, 필터, 인터셉터, 예외 처리, 타임리프, 메시지, 국제화, 검증 등등

 

 11.1 파일 업로드 - 파일 업로드 소개

  - HTML Form을 통한 파일 업로드를 이해하려면 먼저 폼을 전송하는 두 가지 방식의 차이를 이해해야 한다.

 

 * HTML 폼 전송 방식

  - application/x-www-form-urlencoded

  - multipart/form-data

 

  - application/x-www-form-urlencoded 방식은 HTML 폼 데이터를 서버로 전송하는 가장 기본적인 방법이다.

  - Form 태그에 별도의 enctype 옵션이 없으면 웹 브라우저는 요청 HTTP 메시지의 헤더에 다음 내용을 추가한다.

    > Content-Type: application/x-www-form-urlencoded

  - 그리고 폼에 입력한 전송할 항목을 HTTP Body에 문자로 username=kim&age=20 와 같이 & 로 구분해서 전송한다.

  - 파일을 업로드 하려면 파일은 문자가 아니라 바이너리 데이터를 전송해야 한다.

  - 문자를 전송하는 이 방식으로 파일을 전송하기는 어렵다.

  - 그리고 또 한가지 문제가 더 있는데, 보통 폼을 전송할 때 파일만 전송하는 것이 아니라는 점이다

    > ex) 이름, 나이, 첨부파일 전송...

  - 문제는 이름과 나이는 문자로 전송하고, 첨부파일은 바이너리로 동시에 전송해야 한다는 점이다. 

    > 이 문제를 해결하기 위해 HTTP는 multipart/form-data 라는 전송 방식을 제공한다.

 

  - 사용방식 : Form 태그에 별도의 enctype="multipart/form-data" 를 지정해야 한다

  - multipart/form-data 방식은 다른 종류의 여러 파일과 폼의 내용 함께 전송할 수 있다.

  - 폼의 입력 결과로 생성된 HTTP 메시지를 보면 각각의 전송 항목이 구분이 되어있다.

    > ContentDisposition 이라는 항목별 헤더가 추가되어 있고 여기에 부가 정보가 있다.

    > 예제에서는 username , age , file1 이 각각 분리되어 있다

    > 폼의 일반 데이터는 각 항목별로 문자가 전송된다

    > 파일의 경우 파일 이름과 Content-Type이 추가되고 바이너리 데이터가 전송된다

   - multipart/form-data 는 이렇게 각각의 항목을 구분해서, 한번에 전송하는 것이다

 

 * Part

  - multipart/form-data 는 application/x-www-form-urlencoded 와 비교해서 매우 복잡하고 각각의 부분( Part )로 나누어져 있다. 그렇다면 이렇게 복잡한 HTTP 메시지를 서버에서 어떻게 사용할 수 있을까?

 

 11.2 파일 업로드 - 프로젝트 생성

  - https://start.spring.io

  - 프로젝트 선택 Project : Gradle Project

  - Language : Java

  - Spring Boot : 2.7.0

  - Group : hello

  - Artifact : upload

  - Name : upload

  - Package name : hello.upload

  - Packaging : Jar

  - Java : 11

  - Dependencies : Spring Web, Thymeleaf, Lombok

* gradle.build 실행 후 아래 오류 발생 시 gradle-wrapper.properties에서 gradle 버전을 6.9 이하로 변경해서 다운로드하자. (gradle-6.9-all.zip)

 > Unable to find method 'org.gradle.api.artifacts.result.ComponentSelectionReason.getDescription()Ljava/lang/String;'. Possible causes for this unexpected error include: Gradle's dependency cache may be corrupt (this sometimes occurs after a network connection timeout.) Re-download dependencies and sync project (requires network)

 

 11.3 파일 업로드 - 서블릿과 파일 업로드1

  - 서블릿을 통한 파일 업로드를 코드와 함께 알아보자.

 

package hello.upload.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.Part;
import java.io.IOException;
import java.util.Collection;

@Slf4j
@Controller
@RequestMapping("/servlet/v1")
public class ServletUploadControllerV1 {

    @GetMapping("/upload")
    public String newFile() {
        return "upload-form";
    }

    @PostMapping("/upload")
    public String saveFileV1(HttpServletRequest request) throws IOException, ServletException {
        log.info("request={}", request);

        String itemName = request.getParameter("itemName");
        log.info("itemName={}",itemName);

        Collection<Part> parts = request.getParts();
        log.info("parts={}", parts);

        return "upload-form";
    }
}

 - hello.upload.controller.ServletUploadControllerV1.java

 - multipart/form-data를 처리하기 위한 컨트롤러 생성

 - request.getParts()메소드는 multipart/form-data 전송 방식에서 나누어진 부분을 받아서 확인할 수 있다

 

logging.level.org.apache.coyote.http11=debug;

 - application.properties

 - 서버에 로그를 남기기 위해 debug 옵션 추가

 - 이 옵션을 사용하면 HTTP 요청 메시지를 서버 로그에서 확인할 수 있다.

 - 실행해보면 multipart/formdata 방식으로 전송된 것을 확인할 수 있다.

 

 * 실행 결과 로그

logging.level.org.apache.coyote.http11=debug;

Content-Type: multipart/form-data; boundary=----xxxx

------xxxx
Content-Disposition: form-data; name="itemName"
Spring

------xxxx
Content-Disposition: form-data; name="testfile"; filename="test.tif"
Content-Type: application/octet-stream

sadaaa...

 - 실행 시 -----x로 나뉘어졌음을 확인할 수 있다.

 

 * multipart 용량 처리 옵션

#파일 용량 옵션
spring.servlet.multipart.max-file-size=1MB
spring.servlet.multipart.max-request-size=10MB

# multipart 사용여부 옵션
spring.servlet.multipart.enabled=false

 - application.properties

 - 업로드 사이즈 제한 옵션 추가

 - 사이즈를 넘으면 예외( SizeLimitExceededException )가 발생한다

 - max-file-size : 파일 하나의 최대 사이즈, 기본 1MB 이다

 - max-request-size : 멀티파트 요청 하나에 여러 파일을 업로드 할 수 있는데, 그 전체 합이다. 기본 10MB 이다.

 

 * multipart 사용여부 옵션 

 - 멀티파트는 일반적인 폼 요청인 application/x-www-form-urlencoded 보다 훨씬 복잡하다.

 - spring.servlet.multipart.enabled 옵션을 끄면 서블릿 컨테이너는 멀티파트와 관련된 처리를 하지 않는다. (default는 true)

 -  multipart 사용 false 후 실행 시 아래 로그가 표시된다.

   > request=org.apache.catalina.connector.RequestFacade@xxx

   > itemName=null

   > parts=[]

   > 결과 로그를 보면 RequestFacade가 사용되며, request.getParameter("itemName") , request.getParts() 의 결과가 비어있다.  

 -  multipart 사용 true 후 실행 시 아래 로그가 표시된다.

   > request=org.springframework.web.multipart.support.StandardMultipartHttpServletR equest

   > itemName=Spring

   > parts=[ApplicationPart1, ApplicationPart2]

   > 결과 로그를 보면 HttpServletRequest 객체가 RequestFacade -> StandardMultipartHttpServletRequest 로 변한 것을 확인할 수 있다

 

 * 참고 

  - spring.servlet.multipart.enabled 옵션을 켜면 스프링의 DispatcherServlet 에서 멀티파트 리졸버( MultipartResolver )를 실행한다.

  - 멀티파트 리졸버는 멀티파트 요청인 경우 서블릿 컨테이너가 전달하는 일반적인 HttpServletRequest 를 MultipartHttpServletRequest 로 변환해서 반환한다.

  - MultipartHttpServletRequest 는 HttpServletRequest 의 자식 인터페이스이고, 멀티파트와 관련된 추가 기능을 제공한다

  - 스프링이 제공하는 기본 멀티파트 리졸버는 MultipartHttpServletRequest 인터페이스를 구현한 StandardMultipartHttpServletRequest 를 반환한다.

  - 이제 컨트롤러에서 HttpServletRequest 대신에 MultipartHttpServletRequest 를 주입받을 수 있는데, 이것을 사용하면 멀티파트와 관련된 여러가지 처리를 편리하게 할 수 있다.

  - 그런데 이후 강의에서 설명할 MultipartFile 이라는 것을 사용하는 것이 더 편하기 때문에 MultipartHttpServletRequest 를 잘 사용하지는 않는다.

  - 더 자세한 내용은 MultipartResolver 를 검색해보자.

 

 11.4 파일 업로드 - 서블릿과 파일 업로드2

  - 서블릿이 제공하는 Part 에 대해 알아보고 실제 파일도 서버에 업로드 해보자.

  - 먼저 파일을 업로드를 하려면 실제 파일이 저장되는 경로가 필요하다.

  - 해당 경로에 실제 폴더를 만들고 default 경로를 입력해두자.

 

#파일 업로드 경로 설정(예): /Users/kimyounghan/study/file/
file.dir=D:/Study/upload

 - application.properties

 - 파일 업로드 경로 추가

   > 꼭 해당 경로에 실제 폴더를 미리 만들어두자.

   > application.properties 에서 설정할 때 경로 마지막에 / (슬래시)가 포함된 것에 주의하자

 

package hello.upload.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.util.StreamUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.Part;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Collection;

@Slf4j
@Controller
@RequestMapping("/servlet/v2")
public class ServletUploadControllerV2 {

	//application.properties에 설정한 file.dir의 값을 주입한다.
    @Value("${file.dir}")
    private String fileDir;

    @GetMapping("/upload")
    public String newFile() {
        return "upload-form";
    }

    @PostMapping("/upload")
    public String saveFileV1(HttpServletRequest request) throws IOException, ServletException {
        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());
            
            //Part 정보 출력
            Collection<String> headerNames = part.getHeaderNames();
            for (String headerName : headerNames) {
                log.info("header {} : {}", headerName, part.getHeader(headerName));
            }
            
            //편의 메소드 제공
            //content-disposition에 제공된 정보 get 가능
            //filename = part.getSubmittedFileName() 으로 획득
            log.info("getSubmittedFileName = {}", part.getSubmittedFileName());
            log.info("size={}", part.getSize()); //part body size

            //데이터 읽기
            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);   //파일에 쓰기
            }
        }
        
        return "upload-form";
    }
}

 - hello.upload.controller.ServletUploadControllerV2.java

 - 멀티파트 형식은 전송 데이터를 하나하나 각각 부분( Part )으로 나누어 전송한다.

 - parts 에는 이렇게 나누어진 데이터가 각각 담긴다.

 - 서블릿이 제공하는 Part 는 멀티파트 형식을 편리하게 읽을 수 있는 다양한 메서드를 제공한다

 

 * Part 주요 메서드

  - part.getSubmittedFileName() : 클라이언트가 전달한 파일명

  - part.getInputStream(): Part의 전송 데이터를 읽을 수 있다.

  - part.write(...): Part를 통해 전송된 데이터를 파일로 저장할 수 있다.

 

 * 실행 결과 로그

==== PART ====
name=itemName
header content-disposition: form-data; name="itemName"
submittedFileName=null
size=7
body=상품A
==== PART ====
name=file
header content-disposition: form-data; name="file"; filename="스크린샷.png"
header content-type: image/png
submittedFileName=스크린샷.png
size=112384
body=qwlkjek2ljlese...
파일 저장 fullPath=D:/Study/upload/teststudy/스크린샷.png

 - 전송한 내용

   > itemName : 상품A

   > file : 스크릿샷.png

 - 파일 저장 경로에 가보면 실제 파일이 저장된 것을 확인할 수 있다. 

 - 서블릿이 제공하는 Part 는 편하기는 하지만, HttpServletRequest 를 사용해야 하고, 추가로 파일 부분만 구분하려면 여러가지 코드를 넣어야 한다.

 

 * 참고

  - 큰 용량의 파일을 업로드를 테스트 할 때는 로그가 너무 많이 남아서 다음 옵션을 끄는 것이 좋다.

     > logging.level.org.apache.coyote.http11=debug

  - body 출력도 파일의 바이너리 데이터를 모두 출력하므로 끄는 것이 좋다.

    > log.info("body={}", body);

 

 11.5 파일 업로드 - 스프링과 파일 업로드

  - 스프링은 MultipartFile 이라는 인터페이스로 멀티파트 파일을 매우 편리하게 지원한다

package hello.upload.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;

@Slf4j
@Controller
@RequestMapping("/spring/")
public class SpringUploadController {

    @Value("${file.dir}")
    private String fileDir;

    @GetMapping("/upload")
    public String newFile() {
        return "upload-form";
    }

    @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));    //파일을 fullPath 경로에 저장
        }

        return "upload-form";
    }
}

 - hello.upload.controller.SpringUploadController.java

 - 스프링 답게 딱 필요한 부분의 코드만 작성하면 된다

 - @RequestParam MultipartFile file 업로드하는 HTML Form의 name에 맞추어 @RequestParam 을 적용하면 된다.

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

 

 * MultipartFile 주요 메서드

  - file.getOriginalFilename() : 업로드 파일 명

  - file.transferTo(...) : 파일 저장

 

 * 실행 결과 로그

request=org.springframework.web.multipart.support.StandardMultipartHttpServletRequest@5c022dc6
itemName=상품A
multipartFile=org.springframework.web.multipart.support.StandardMultipartHttpServletRequest$StandardMultipartFile@274ba730
파일 저장 fullPath=D:/Study/upload/teststudy/스크린샷.png

 - 전송한 내용

   > itemName : 상품A

   > file : 스크릿샷.png

 - StandardMultipartFile 이 호출됨을 확인

 

 

인프런 강의 57일차.

 - 스프링 MVC 2편 - 백엔드 웹 개발 활용 기술 1 (김영한 강사님)

 - 1편에서 배운 MVC를 활용할 수 있는 기술 습득

 - 타입 컨버터, 파일 업로드, 활용, 쿠키, 세션, 필터, 인터셉터, 예외 처리, 타임리프, 메시지, 국제화, 검증 등등

 

 10.1 스프링 타입 컨버터 - 프로젝트 생성

  - https://start.spring.io

  - 프로젝트 선택 Project : Gradle Project

  - Language : Java

  - Spring Boot : 2.7.0

  - Group : hello

  - Artifact : typeconverter

  - Name : typeconverter

  - Package name : hello.typeconverter

  - Packaging : Jar

  - Java : 11

  - Dependencies : Spring Web, Thymeleaf, Lombok

* gradle.build 실행 후 아래 오류 발생 시 gradle-wrapper.properties에서 gradle 버전을 6.9 이하로 변경해서 다운로드하자. (gradle-6.9-all.zip)

 > Unable to find method 'org.gradle.api.artifacts.result.ComponentSelectionReason.getDescription()Ljava/lang/String;'. Possible causes for this unexpected error include: Gradle's dependency cache may be corrupt (this sometimes occurs after a network connection timeout.) Re-download dependencies and sync project (requires network)

 

 10.2 스프링 타입 컨버터 - 스프링 타입 컨버터 소개

  - 문자를 숫자로 변환하거나, 반대로 숫자를 문자로 변환해야 하는 것 처럼 애플리케이션을 개발하다 보면 타입을 변환해야 하는 경우가 상당히 많다

 

package hello.typeconverter.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;

@RestController
public class HelloController {

    @GetMapping("/hello-v1")
    public String helloV1(HttpServletRequest request) {
        String data = request.getParameter("data"); //문자 타입 조회
        Integer intValue = Integer.valueOf(data); //숫자 타입으로 변경
        System.out.println("intValue = " + intValue);
        
        return "ok";
    }

    @GetMapping("/hello-v2")
    public String helloV2(@RequestParam Integer data) {
        System.out.println("data = " + data);
        
        return "ok";
    }
}

 - hello.typeconverter.controller.HelloController.java

 - HttpRequest.getParameter는 전부 String으로 처리된다.

 - 그러므로 다른 타입으로 사용하고 싶으면 전부 변환하는 과정을 거쳐야 한다.

 - 스프링에서 제공하는 @RequestParam Integer를 사용하게되면 스프링에서 자동으로 타입 변환까지 처리해준다.

   > 스프링이 중간에서 타입을 변환해주었기 때문이다.

 - 이러한 예는 @ModelAttribute, @PathVariable 에서도 확인할 수 있다

 

@ModelAttribute UserData data
        
class UserData {
    Integer data;
}

 - @RequestParam 와 같이, 문자 data=10 을 숫자 10으로 받을 수 있다.

 

/users/{userId}
@PathVariable("userId") Integer data

 - URL 경로는 문자다.

 - /users/10 : 여기서 10도 숫자 10이 아니라 그냥 문자 "10"이다.

 - data를 Integer 타입으로 받을 수 있는 것도 스프링이 타입 변환을 해주기 때문이다.

 

 * 스프링의 타입 변환 적용 예

  - 스프링 MVC 요청 파라미터

    > @RequestParam

    > @ModelAttribute

    > @PathVariable

  - @Value 등으로 YML 정보 읽기

  - XML에 넣은 스프링 빈 정보를 변환

  - 뷰를 렌더링 할 때

 

 * 스프링과 타입 변환

  - 이렇게 타입을 변환해야 하는 경우는 상당히 많다. 개발자가 직접 하나하나 타입 변환을 해야 한다면, 생각만 해도 괴로울 것이다.

  - 스프링이 중간에 타입 변환기를 사용해서 타입을 String Integer 로 변환해주었기 때문에 개발자는 편리하게 해당 타입을 바로 받을 수 있다.

  - 만약 개발자가 새로운 타입을 만들어서 변환하고 싶으면 어떻게 하면 될까?

 

 * 컨버터 인터페이스

package org.springframework.core.convert.converter;

public interface Converter<S, T> {
    T convert(S source);
}

 - 스프링은 확장 가능한 컨버터 인터페이스를 제공한다.

 - 개발자는 스프링에 추가적인 타입 변환이 필요하면 이 컨버터 인터페이스를 구현해서 등록하면 된다.

 - 이 컨버터 인터페이스는 모든 타입에 적용할 수 있다.

 - 필요하면 X->Y 타입으로 변환하는 컨버터 인터페이스를 만들고, 또 Y->X 타입으로 변환하는 컨버터 인터페이스를 만들어서 등록하면 된다.

 - 예를 들어서 문자로 "true" 가 오면 Boolean 타입으로 받고 싶으면 String Boolean 타입으로 변환되도록 컨버터 인터페이스를 만들어서 등록하고, 반대로 적용하고 싶으면 Boolean String 타입으로 변환되도록 컨버터를 추가로 만들어서 등록하면 된다.

 

 10.3 스프링 타입 컨버터 - Converter

  - 타입 컨버터를 어떻게 사용하는지 코드로 알아보자.

  - 타입 컨버터를 사용하려면 org.springframework.core.convert.converter.Converter 인터페이스를 구현하면 된다

    > Converter 이름을 가진 인터페이스가 많으니 스프링 Converter를 사용해야한다.

 

package hello.typeconverter.converter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.core.convert.converter.Converter;

@Slf4j
public class StringToIntegerConverter implements Converter<String, Integer> {

    @Override
    public Integer convert(String source) {
        log.info("convert source={}", source);
        return Integer.valueOf(source);
    }
}

 - hello.typeconverter.converter.StringToIntegerConverter.java

 - String 을 Integer로 변환하는 타입 컨버터 생성

 

package hello.typeconverter.converter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.core.convert.converter.Converter;

@Slf4j
public class IntegerToStringConverter implements Converter<Integer, String> {

    @Override
    public String convert(Integer source) {
        log.info("convert source={}", source);
        return String.valueOf(source);
    }
}

 - hello.typeconverter.converter.IntegerToStringConverter.java

 - Integer를 String 으로 변환하는 타입 컨버터 생성

 

 * Convert를 테스트하기 위한 ConvertTest 생성

package hello.typeconverter.converter;

import org.junit.jupiter.api.Test;

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

public class ConverterTest {

    @Test
    void stringToInteger() {
        StringToIntegerConverter converter = new StringToIntegerConverter();
        Integer result = converter.convert("10");
        assertThat(result).isEqualTo(10);
    }

    @Test
    void integerToString() {
        IntegerToStringConverter converter = new IntegerToStringConverter();
        String result = converter.convert(10);
        assertThat(result).isEqualTo("10");
    }
}

 - src\test\java\hello\typeconverter\converter\ConverterTest.java

 

 * 사용자 정의 타입 컨버터

  - 타입 컨버터 이해를 돕기 위해 조금 다른 컨버터를 준비해보았다.

  - 127.0.0.1:8080 과 같은 IP, PORT를 입력하면 IpPort 객체로 변환하는 컨버터를 만들어보자

 

package hello.typeconverter.type;

import lombok.EqualsAndHashCode;
import lombok.Getter;

@Getter
@EqualsAndHashCode
public class IpPort {

    private String ip;
    private int port;

    public IpPort(String ip, int port) {
        this.ip = ip;
        this.port = port;
    }
}

 - hello.typeconverter.type.IpPort.java

 - 롬복의 @EqualsAndHashCode 를 넣으면 모든 필드를 사용해서 equals() , hashcode() 를 생성한다.

   > 따라서 모든 필드의 값이 같다면 a.equals(b) 의 결과가 참이 된다.

 

package hello.typeconverter.converter;

import hello.typeconverter.type.IpPort;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.convert.converter.Converter;

@Slf4j
public class StringToIpPortConverter implements Converter<String, IpPort> {

    @Override
    public IpPort convert(String source) {
        log.info("convert source={}", source);
        //input source type : "127.0.0.1:8080" -> IpPort 객체
        String[] split = source.split(":");
        String ip = split[0];
        int port = Integer.parseInt(split[1]);
        return new IpPort(ip, port);
    }
}

 - hello.typeconverter.converter.StringToIpPortConverter.java

 - 127.0.0.1:8080 같은 문자를 입력하면 IpPort 객체를 만들어 반환한다.

 

package hello.typeconverter.converter;

import hello.typeconverter.type.IpPort;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.convert.converter.Converter;

@Slf4j
public class IpPortToStringConverter implements Converter<IpPort, String> {

    @Override
    public String convert(IpPort source) {
        log.info("convert source={}", source);
        //IpPort 객체 -> "127.0.0.1:8080"
        return source.getIp() + ":" + source.getPort();
    }
}

 - hello.typeconverter.converter.IpPortToStringConverter.java

 - IpPort 객체를 입력하면 127.0.0.1:8080 같은 문자를 반환한다

 

 * ConvertTest 테스트케이스 추가

@Test
void stringToipPort() {
    StringToIpPortConverter converter = new StringToIpPortConverter();
    String ipPort = "127.0.0.1:8080";
    IpPort result = converter.convert(ipPort);
    assertThat(result).isEqualTo(new IpPort("127.0.0.1", 8080));    //@EqualsAndHashCode가 선언되어 있기 때문에 isEqualsTo가 동작한다.
}

@Test
void ipPortToString() {
    IpPortToStringConverter converter = new IpPortToStringConverter();
    IpPort source = new IpPort("127.0.0.1", 8080);
    String result = converter.convert(source);
    assertThat(result).isEqualTo("127.0.0.1:8080");
}

 - 이렇게 타입 컨버터를 하나하나 직접 사용하면, 개발자가 직접 컨버팅 하는 것과 큰 차이가 없다.

 - 타입 컨버터를 등록하고 관리하면서 편리하게 변환 기능을 제공하는 역할을 하는 무언가가 필요하다.

 

 * 스프링은 용도에 따라 다양한 방식의 타입 컨버터를 제공한다.

  - Converter : 기본 타입 컨버터

  - ConverterFactory : 전체 클래스 계층 구조가 필요할 때

  - GenericConverter : 정교한 구현, 대상 필드의 애노테이션 정보 사용 가능

  - ConditionalGenericConverter : 특정 조건이 참인 경우에만 실행

  - 스프링은 문자, 숫자, 불린, Enum등 일반적인 타입에 대한 대부분의 컨버터를 기본으로 제공한다.

  - IDE에서 Converter , ConverterFactory , GenericConverter 의 구현체를 찾아보면 수 많은 컨버터를 확인할 수 있다

 

 10.4 스프링 타입 컨버터 - 컨버전 서비스 - ConversionService

  - 이렇게 타입 컨버터를 하나하나 직접 찾아서 타입 변환에 사용하는 것은 매우 불편하다.

  - 그래서 스프링은 개별 컨버터를 모아두고 그것들을 묶어서 편리하게 사용할 수 있는 기능을 제공한다

    > 이것이 바로 컨버전 서비스( ConversionService )이다

package org.springframework.core.convert;

import org.springframework.lang.Nullable;
public interface ConversionService {
    
    boolean canConvert(@Nullable Class<?> sourceType, Class<?> targetType);
    boolean canConvert(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType);
    <T> T convert(@Nullable Object source, Class<T> targetType);
    Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType);
}

 - ConversionService Interface

 - 컨버전 서비스 인터페이스는 컨버팅이 가능한지 확인하는 canConvert와 실제 컨버팅하는 convert 메소드를 제공한다

 

package hello.typeconverter.converter;

import hello.typeconverter.type.IpPort;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.core.convert.support.DefaultConversionService;

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

public class ConversionServiceTest {

    @Test
    void conversionService() {
        //사욯알 컨버터 등록
        DefaultConversionService conversionService = new DefaultConversionService();
        conversionService.addConverter(new StringToIntegerConverter()); //컨버터 등록
        conversionService.addConverter(new IntegerToStringConverter()); //컨버터 등록
        conversionService.addConverter(new StringToIpPortConverter()); //컨버터 등록
        conversionService.addConverter(new IpPortToStringConverter()); //컨버터 등록

        //사용
        Integer result = conversionService.convert("10", Integer.class);    //StringToIntegerConverter 가 동작함
        System.out.println("result = " + result);
        assertThat(result).isEqualTo(10);
        assertThat(conversionService.convert(10, String.class)).isEqualTo("10");    //IntegerToStringConverter 가 동작함

        IpPort ipPortResult = conversionService.convert("127.0.0.1L8080", IpPort.class);
        assertThat(ipPortResult).isEqualTo(new IpPort("127.0.0.1", 8080));
        assertThat(conversionService.convert(new IpPort("127.0.0.1", 8080), String.class)).isEqualTo("127.0.0.1:8080");
    }
}

 - hello.typeconverter.converter.ConversionServiceTest.java

 - conversionService 테스트 코드 구현

 - DefaultConversionService 는 ConversionService 인터페이스를 구현했는데, 추가로 컨버터를 등록하는 기능도 제공한다.

 

 * 등록과 사용 분리

  - 컨버터를 등록할 때는 StringToIntegerConverter 같은 타입 컨버터를 명확하게 알아야 한다.

  - 반면에 컨버터를 사용하는 입장에서는 타입 컨버터를 전혀 몰라도 된다.

  - 타입 컨버터들은 모두 컨버전 서비스 내부에 숨어서 제공된다.

  - 따라서 타입을 변환을 원하는 사용자는 컨버전 서비스 인터페이스에만 의존하면 된다.

  - 물론 컨버전 서비스를 등록하는 부분과 사용하는 부분을 분리하고 의존관계 주입을 사용해야 한다.

 

 * 컨버전 서비스 사용 방법

  - Integer value = conversionService.convert("10", Integer.class)

 

 * 인터페이스 분리 원칙

  - ISP(Interface Segregation Principal) : 인터페이스 분리 원칙은 클라이언트가 자신이 이용하지 않는 메서드에 의존하지 않아야 한다

  - 인터페이스를 분리하면 컨버터를 사용하는 클라이언트와 컨버터를 등록하고 관리하는 클라이언트의 관심사를 명확하게 분리할 수 있다.

  - 특히 컨버터를 사용하는 클라이언트는 ConversionService 만 의존하면 되므로, 컨버터를 어떻게 등록하고 관리하는지는 전혀 몰라도 된다.

  - 결과적으로 컨버터를 사용하는 클라이언트는 꼭 필요한 메서드만 알게된다.

    > 이렇게 인터페이스를 분리하는 것을 ISP 라 한다.

 

 * DefaultConversionService 는 두개의 인터페이스를 구현했다.

  - ConversionService : 컨버터 사용에 초점

  - ConverterRegistry : 컨버터 등록에 초점

 

 * 스프링은 내부에서 ConversionService 를 사용해서 타입을 변환한다.

  - 예를 들어서 앞서 살펴본 @RequestParam 같은 곳에서 이 기능을 사용해서 타입을 변환한다.

  - 이제 컨버전 서비스를 스프링에 적용해보자.

 

 10.5 스프링 타입 컨버터 - 스프링에 Converter 적용하기

  - 애플리케이션에 Converter 를 적용해보자.

package hello.typeconverter;

import hello.typeconverter.converter.IntegerToStringConverter;
import hello.typeconverter.converter.IpPortToStringConverter;
import hello.typeconverter.converter.StringToIntegerConverter;
import hello.typeconverter.converter.StringToIpPortConverter;
import org.springframework.context.annotation.Configuration;
import org.springframework.format.FormatterRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addFormatters(FormatterRegistry registry) {
        //formatter는 converter의 좀 더 확장된 버전이다.
        registry.addConverter(new StringToIntegerConverter());
        registry.addConverter(new IntegerToStringConverter());
        registry.addConverter(new StringToIpPortConverter());
        registry.addConverter(new IpPortToStringConverter());

    }
}

 - hello.typeconverter.WebConfig.java

 - WebConfig에 컨버터 등록

 - 스프링은 내부에서 ConversionService 를 제공한다.

 - 우리는 WebMvcConfigurer 가 제공하는 addFormatters() 를 사용해서 추가하고 싶은 컨버터를 등록하면 된다.

    > 이렇게 하면 스프링은 내부에서 사용하는 ConversionService 에 컨버터를 추가해준다.

 

 * 실행

import javax.servlet.http.HttpServletRequest;

@RestController
public class HelloController {
	...
    @GetMapping("/ip-port")
    public String ipPort(@RequestParam IpPort ipPort) {
        System.out.println("ipPort.class  "+ipPort.getIp());
        System.out.println("ipPort.class = "+ipPort.getPort());
        return "ok";
    }
    ...
}

 - hello.typeconverter.controller.HelloController.java

 - 직접 정의한 타입인 IpPort를 컨버터로 변환해보자

 - 실행 url : http://localhost:8080/ip-port?ipPort=127.0.0.1:8080

StringToIpPortConverter : convert source=127.0.0.1:8080
ipPort IP = 127.0.0.1
ipPort PORT = 8080

 - 실행 로그

 - ?ipPort=127.0.0.1:8080 쿼리 스트링이 @RequestParam IpPort ipPort 에서 객체 타입으로 잘 변환 된 것을 확인할 수 있다

 

 * 처리 과정

  - @RequestParam 은 @RequestParam 을 처리하는 ArgumentResolver 인 RequestParamMethodArgumentResolver 에서 ConversionService 를 사용해서 타입을 변환한다.

  - 부모 클래스와 다양한 외부 클래스를 호출하는 등 복잡한 내부 과정을 거치기 때문에 대략 이렇게 처리되는 것으로 이해해도 충분하다.

 

 10.6 스프링 타입 컨버터 - 뷰 템플릿에 컨버터 적용하기

  - 뷰 템플릿에 컨버터를 적용하는 방법을 알아보자.

  - 타임리프는 렌더링 시에 컨버터를 적용해서 렌더링 하는 방법을 편리하게 지원한다.

  - 이전까지는 문자를 객체로 변환했다면, 이번에는 그 반대로 객체를 문자로 변환하는 작업을 확인할 수 있다

 

package hello.typeconverter.controller;

import hello.typeconverter.type.IpPort;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class ConverterController {

    @GetMapping("/converter-view")
    public String converterView(Model model) {
        model.addAttribute("number", 10000);
        model.addAttribute("ipPort", new IpPort("127.0.0.1", 8080));
        return "converter-view";
    }
}

 - hello.typeconverter.controller.ConverterController.java

 - Model 에 숫자 10000 와 ipPort 객체를 담아서 뷰 템플릿에 전달한다.

 

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<ul>
    <li>${number}: <span th:text="${number}" ></span></li>
    <li>${{number}}: <span th:text="${{number}}" ></span></li>
    <li>${ipPort}: <span th:text="${ipPort}" ></span></li>
    <li>${{ipPort}}: <span th:text="${{ipPort}}" ></span></li>
</ul>
</body>
</html>

 - templates/converter-view.html

 - 타임리프는 ${{...}} 를 사용하면 자동으로 컨버전 서비스를 사용해서 변환된 결과를 출력해준다.

    > 스프링과 통합 되어서 스프링이 제공하는 컨버전 서비스를 사용하므로, 우리가 등록한 컨버터들을 사용할 수 있다.

 - 변수 표현식 : ${...}

 - 컨버전 서비스 적용 : ${{...}} ( 중괄호가 2개이다 )

 

 * 실행 결과

• ${number}: 10000
• ${{number}}: 10000
• ${ipPort}: hello.typeconverter.type.IpPort@59cb0946
• ${{ipPort}}: 127.0.0.1:8080

 - 타임리프 뷰 템플릿은 데이터를 문자로 출력한다. 

 

 * 실행 결과 로그

IntegerToStringConverter : convert source=10000
IpPortToStringConverter : convert
source=hello.typeconverter.type.IpPort@59cb0946

 - ${number} : 단순 문자 출력

 - ${{number}} : IntegerToStringConverter 컨버터가 적용되어 Integer 타입인 10000 을 String 타입으로 변환해서 실행

   > 이 부분은 컨버터를 실행하지 않아도 타임리프가 숫자를 문자로 자동으로 변환히기 때문에 컨버터를 적용할 때와 하지 않을 때가 같다.

 - ${ipPort} : 뷰 템플릿은 데이터를 문자로 출력하기 때문에 객체는 toString이 적용되어 표시된다.

 - ${{ipPort}} : 컨버터를 적용하게 되면 IpPort 타입을 String 타입으로 변환해야 하므로 IpPortToStringConverter 가 적용된다.

   > 127.0.0.1:8080 가 출력된다.

 

 * form에 컨버터 적용하기

package hello.typeconverter.controller;

import hello.typeconverter.type.IpPort;
import lombok.Data;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;

@Controller
public class ConverterController {

    @GetMapping("/converter-view")
    public String converterView(Model model) {
        model.addAttribute("number", 10000);
        model.addAttribute("ipPort", new IpPort("127.0.0.1", 8080));
        return "converter-view";
    }

    @GetMapping("/converter/edit")
    public String converterForm(Model model) {
        IpPort ipPort = new IpPort("127.0.0.1", 8080);
        Form form = new Form(ipPort);
        model.addAttribute("form", form);
        return "converter-form";
    }

    @PostMapping("/converter/edit")
    public String converterEdit(@ModelAttribute Form form, Model model) {
        IpPort ipPort = form.getIpPort();
        model.addAttribute("ipPort", ipPort);
        return "converter-view";
    }

    @Data
    static class Form {
        private IpPort ipPort;

        public Form(IpPort ipPort) {
            this.ipPort = ipPort;
        }
    }
}

 - hello.typeconverter.controller.ConverterController.java

 - 'Form' 객체를 데이터를 전달하는 폼 객체로 사용한다

 - GET /converter/edit : IpPort 를 뷰 템플릿 폼에 출력한다.

 - POST /converter/edit : 뷰 템플릿 폼의 IpPort 정보를 받아서 출력한다

 

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form th:object="${form}" th:method="post">
    th:field <input type="text" th:field="*{ipPort}"><br/>
    th:value <input type="text" th:value="*{ipPort}">(보여주기 용도)<br/>
    <input type="submit"/>
</form>
</body>
</html>

 - templates/converter-form.html

 - 타임리프의 th:field 는 id , name 를 출력하는 등 다양한 기능이 있는데, 여기에 컨버전 서비스도 함께 적용된다.

 - 컨버전을 사용하고 싶으면 th:field, 컨버전을 하지 않으려면 th:value를 쓰면 된다.

 - GET /converter/edit

    > th:field 가 자동으로 컨버전 서비스를 적용해주어서 ${{ipPort}} 처럼 적용이 되었다.

    > 따라서 IpPort String 으로 변환된다.

 - POST /converter/edit

    > @ModelAttribute 를 사용해서 String IpPort 로 변환된다

    > form.submit 할 경우 submit 당시에는 문자가 넘어간다(th:field가 변환된 HTML 코드 value의 값은 문자 "127.0.0.1"임)

    > submit 후 Controller에서 @ModelAttribute로 정의된 Form 을 변환하려고 봤더니 내부에 IpPort 객체가 존재하여 문자를 ipPort 객체로 변환하는 작업이 수행이 된다.

    > 즉 StringToIpPortConverter가 호출이 된다. (ModelAttribute가 내부적으로 컨버터를 사용함을 알 수 있다)

 

 10.7 스프링 타입 컨버터 - 포맷터 - Formatter

  - Converter 는 입력과 출력 타입에 제한이 없는, 범용 타입 변환 기능을 제공한다.

  - 이번에는 일반적인 웹 애플리케이션 환경을 생각해보자.

  - boolean 타입을 숫자로 바꾸는 것 같은 범용 기능 보다 개발자 입장에서는 문자를 다른 타입으로 변환하거나, 다른 타입을 문자로 변환하는 상황이 대부분이다.

  - 앞서 살펴본 예제들을 떠올려 보면 문자를 다른 객체로 변환하거나 객체를 문자로 변환하는 일이 대부분이다

 

 * 웹 애플리케이션에서 객체를 문자로, 문자를 객체로 변환하는 예

  - 화면에 숫자를 출력해야 하는데, Integer String 출력 시점에 숫자 1000 문자 "1,000" 이렇게 1000 단위에 쉼표를 넣어서 출력하거나, 또는 "1,000" 라는 문자를 1000 이라는 숫자로 변경해야 한다.

  - 날짜 객체를 문자인 "2021-01-01 10:50:11" 와 같이 출력하거나 또는 그 반대의 상황

    > 날짜 정보는 Local 정보를 활용하여 현지화 정보가 사용될 수 있다.

  - 이렇게 객체를 특정한 포맷에 맞추어 문자로 출력하거나 또는 그 반대의 역할을 하는 것에 특화된 기능이 바로 포맷터( Formatter )이다. 포맷터는 컨버터의 특별한 버전으로 이해하면 된다 

 

 * Converter vs Formatter

  - Converter 는 범용(객체 -> 객체)

  - Formatter 는 문자에 특화(객체 -> 문자, 문자 -> 객체) + 현지화(Locale)

    > Converter 의 특별한 버전

 

 * 포맷터 - Formatter 만들기

  - 포맷터( Formatter )는 객체를 문자로 변경하고, 문자를 객체로 변경하는 두 가지 기능을 모두 수행한다.

  - String print(T object, Locale locale) : 객체를 문자로 변경한다.

  - T parse(String text, Locale locale) : 문자를 객체로 변경한다.

 

package hello.typeconverter.formatter;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

import java.text.ParseException;
import java.util.Locale;

import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.*;

class MyNumberFormatterTest {

    MyNumberFormatter formatter = new MyNumberFormatter();

    @Test
    void parse() throws ParseException {
        Number number = formatter.parse("1,000", Locale.KOREA);
        assertThat(number).isEqualTo(1000L);        //Long 타입이므로 주의
    }

    @Test
    void print() {
        String print = formatter.print(1000, Locale.KOREA);
        assertThat(print).isEqualTo("1,000");
    }
}

 - hello.typeconverter.formatter.MyNumberFormatterTest.java

 - "1,000" 처럼 숫자 중간의 쉼표를 적용하려면 자바가 기본으로 제공하는 NumberFormat 객체를 사용하면 된다.

 - 이 객체는 Locale 정보를 활용해서 나라별로 다른 숫자 포맷을 만들어준다

 - parse() 를 사용해서 문자를 숫자로 변환한다.

   > 참고로 Number 타입은 Integer , Long 과 같은 숫자 타입의 부모 클래스이다.

 - print() 를 사용해서 객체를 문자로 변환한다

 

package hello.typeconverter.formatter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.format.Formatter;

import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;

@Slf4j
public class MyNumberFormatter implements Formatter<Number> {   //String을 제외한 변환할 객체를 Formatter<> 로 implements 하면 된다.

    @Override
    public Number parse(String text, Locale locale) throws ParseException {
        //text : 1,000
        //1,000 -> 1000으로 변환시키는 메소드 parse
        log.info("text = {}, locale = {}", text, locale);
        NumberFormat format = NumberFormat.getInstance(locale);
        Number number = format.parse(text);     //format.parse 시 1,000 -> 1000으로 변환된다.
        return number;
    }

    @Override
    public String print(Number object, Locale locale) {
        log.info("object = {}, local = {}", object, locale);
        NumberFormat instance = NumberFormat.getInstance(locale);
        String format = instance.format(object);    //format 메소드 호출 시 String 으로 변환된 값이 나온다.
        return format;
    }
}

 - hello.typeconverter.formatter.MyNumberFormatter.java

 - parse() 의 결과가 Long 이기 때문에 isEqualTo(1000L) 을 통해 비교할 때 마지막에 L 을 넣어주어야 한다.

 

 * 실행 결과

MyNumberFormatter - text=1,000, locale=ko_KR
MyNumberFormatter - object=1000, locale=ko_KR

 

 * 참고

 - 스프링은 용도에 따라 다양한 방식의 포맷터를 제공한다.

  > Formatter : 포맷터

  > AnnotationFormatterFactory : 필드의 타입이나 애노테이션 정보를 활용할 수 있는 포맷터

 

 10.8 스프링 타입 컨버터 - 포맷터를 지원하는 컨버전 서비스

  - 컨버전 서비스에는 컨버터만 등록할 수 있고, 포맷터를 등록할 수 는 없다.

    > 그런데 생각해보면 포맷터는 객체 -> 문자, 문자 -> 객체로 변환하는 특별한 컨버터일 뿐이다.

  - 포맷터를 지원하는 컨버전 서비스를 사용하면 컨버전 서비스에 포맷터를 추가할 수 있다.

  - 내부에서 어댑터 패턴을 사용해서 Formatter 가 Converter 처럼 동작하도록 지원한다

    > FormattingConversionService 는 포맷터를 지원하는 컨버전 서비스이다.

    > DefaultFormattingConversionService 는 FormattingConversionService 에 기본적인 통화, 숫자 관련 몇가지 기본 포맷터를 추가해서 제공한다.

 

package hello.typeconverter.formatter;

import hello.typeconverter.converter.IpPortToStringConverter;
import hello.typeconverter.converter.StringToIpPortConverter;
import hello.typeconverter.type.IpPort;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.format.support.DefaultFormattingConversionService;

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

public class FormattingConversionServiceTest {

    @Test
    void formattingConversionService() {
        DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();

        //컨버터 등록
        //FormattingConversionService가 ConversionService, ConversionRegistry를 구현하고 있기 때문에 컨버터 등록이 가능하다.
        conversionService.addConverter(new StringToIpPortConverter());
        conversionService.addConverter(new IpPortToStringConverter());

        //포맷터 등록
        conversionService.addFormatter(new MyNumberFormatter());

        //컨버터 사용
        IpPort ipPort = conversionService.convert("127.0.0.1:8080", IpPort.class);
        assertThat(ipPort).isEqualTo(new IpPort("127.0.0.1", 8080));

        //포맷터 사용
        assertThat(conversionService.convert(1000, String.class)).isEqualTo("1,000");
        assertThat(conversionService.convert("1,000", Long.class)).isEqualTo(1000L);
    }
}

 - hello.typeconverter.formatter.FormattingConversionServiceTest.java

 - formattingConversionService 테스트 생성

 

 * DefaultFormattingConversionService 상속 관계

  - FormattingConversionService 는 ConversionService 관련 기능을 상속받기 때문에 결과적으로 컨버터도 포맷터도 모두 등록할 수 있다.

  - 그리고 사용할 때는 ConversionService 가 제공하는 convert 메소드를 사용하면 된다.

  - 추가로, 스프링 부트는 DefaultFormattingConversionService 를 상속 받은 WebConversionService 를 내부에서 사용한다.

 

 10.9 스프링 타입 컨버터 - 포맷터 적용하기

  - 포맷터를 웹 애플리케이션에 적용해보자.

 

package hello.typeconverter;

import hello.typeconverter.converter.IntegerToStringConverter;
import hello.typeconverter.converter.IpPortToStringConverter;
import hello.typeconverter.converter.StringToIntegerConverter;
import hello.typeconverter.converter.StringToIpPortConverter;
import hello.typeconverter.formatter.MyNumberFormatter;
import org.springframework.context.annotation.Configuration;
import org.springframework.format.FormatterRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addFormatters(FormatterRegistry registry) {
        //formatter는 converter의 좀 더 확장된 버전이다.
        //StringToIntegerConverter, IntegerToStringConverter 는 MyNumberFormatter와 동작(숫자를 문자로, 문자를 숫자로 변경)이 동일하다.
        //우선순위 때문에 MyNumberFormatter보다 먼저 호출되기 때문에 현재 테스트에서는 주석처리한다.
//        registry.addConverter(new StringToIntegerConverter());
//        registry.addConverter(new IntegerToStringConverter());
        registry.addConverter(new StringToIpPortConverter());
        registry.addConverter(new IpPortToStringConverter());

        //추가
        registry.addFormatter(new MyNumberFormatter());

    }
}

 - hello.typeconverter.WebConfig.java

 - StringToIntegerConverter , IntegerToStringConverter 를 꼭 주석처리 하자

   > MyNumberFormatter 도 숫자 문자, 문자 숫자로 변경하기 때문에 둘의 기능이 겹친다.

   > 우선순위는 컨버터가 우선하므로 포맷터가 적용되지 않고, 컨버터가 적용된다

 

 * 실행 결과

• ${number}: 10000
• ${{number}}: 10,000

 - 호출 URL : http://localhost:8080/converter-view

 - 컨버전 서비스를 적용한 결과 MyNumberFormatter 가 적용되어서 10,000 문자가 출력된 것을 확인할 수 있다.

 

 * 실행 로그

MyNumberFormatter : text=10,000, locale=ko_KR
data = 10000

 - 호출 URL : http://localhost:8080/hello-v2?data=10,000

 - "10,000" 이라는 포맷팅 된 문자가 Integer 타입의 숫자 10000으로 정상 변환 된 것을 확인할 수 있다.

 

 10.10 스프링 타입 컨버터 - 스프링이 제공하는 기본 포맷터

  - 스프링은 자바에서 기본으로 제공하는 타입들에 대해 수 많은 포맷터를 기본으로 제공한다.

  - IDE에서 Formatter 인터페이스의 구현 클래스를 찾아보면 수 많은 날짜나 시간 관련 포맷터가 제공되는 것을 확인할 수 있다.

  - 그런데 포맷터는 기본 형식이 지정되어 있기 때문에, 객체의 각 필드마다 다른 형식으로 포맷을 지정하기는 어렵다.

  - 스프링은 이런 문제를 해결하기 위해 애노테이션 기반으로 원하는 형식을 지정해서 사용할 수 있는 매우 유용한 포맷터 두 가지를 기본으로 제공한다

    > @NumberFormat : 숫자 관련 형식 지정 포맷터 사용, NumberFormatAnnotationFormatterFactory 

    > @DateTimeFormat : 날짜 관련 형식 지정 포맷터 사용, Jsr310DateTimeFormatAnnotationFormatterFactory

 

package hello.typeconverter.controller;

import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.format.annotation.NumberFormat;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;

import java.time.LocalDateTime;

@Controller
public class FormatterController {

    @GetMapping("/formatter/edit")
    public String formatterForm(Model model) {
        Form form = new Form();
        form.setNumber(10000);
        form.setLocalDateTime(LocalDateTime.now());
        model.addAttribute("form", form);

        return "formatter-form";
    }

    @PostMapping("/formatter/edit")
    public String formatterEdit(@ModelAttribute Form form) {
        return "formatter-view";
    }

    @Data
    static class Form {

        @NumberFormat(pattern = "###,###")
        private Integer number;

        @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
        private LocalDateTime localDateTime;
    }
}

 

 - hello.typeconverter.controller.FormatterController.java

 

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form th:object="${form}" th:method="post">
    number <input type="text" th:field="*{number}"><br/>
    localDateTime <input type="text" th:field="*{localDateTime}"><br/>
    <input type="submit"/>
</form>
</body>
</html>

 - templates/formatter-form.html

 

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<ul>
    <li>${form.number}: <span th:text="${form.number}" ></span></li>
    <li>${{form.number}}: <span th:text="${{form.number}}" ></span></li>
    <li>${form.localDateTime}: <span th:text="${form.localDateTime}" ></span></li>
    <li>${{form.localDateTime}}: <span th:text="${{form.localDateTime}}" ></span></li>
</ul>
</body>
</html>

 - templates/formatter-view.html

 

 * 실행 결과

• ${form.number}: 10000
• ${{form.number}}: 10,000
• ${form.localDateTime}: 2021-01-01T00:00:00
• ${{form.localDateTime}}: 2021-01-01 00:00:00

 - 지정한 포맷으로 출력된 것을 확인할 수 있다.

 

 * 정리

  - 컨버터를 사용하든, 포맷터를 사용하든 등록 방법은 다르지만, 사용할 때는 컨버전 서비스를 통해서 일관성 있게 사용할 수 있다.

 

 * 주의

  - 메시지 컨버터( HttpMessageConverter )에는 컨버전 서비스가 적용되지 않는다.

  - 특히 객체를 JSON으로 변환할 때 메시지 컨버터를 사용하면서 이 부분을 많이 오해하는데, HttpMessageConverter 의 역할은 HTTP 메시지 바디의 내용을 객체로 변환하거나 객체를 HTTP 메시지 바디에 입력하는 것이다.

  - 예를 들어서 JSON을 객체로 변환하는 메시지 컨버터는 내부에서 Jackson 같은 라이브러리를 사용한다.

  - 객체를 JSON으로 변환한다면 그 결과는 이 라이브러리에 달린 것이다.

  - 따라서 JSON 결과로 만들어지는 숫자나 날짜 포맷을 변경하고 싶으면 해당 라이브러리가 제공하는 설정을 통해서 포맷을 지정해야 한다.

  - 결과적으로 이것은 컨버전 서비스와 전혀 관계가 없다.

  - 컨버전 서비스는 @RequestParam , @ModelAttribute , @PathVariable , 뷰 템플릿 등에서 사용할 수 있다