Spring 타입 컨버터 (Converter, Formatter)

# 타입 컨버터의 필요성

HTTP의 요청 파라메타는 모두 문자열로 처리된다. 만약 숫자를 사용하고 싶다면 아래와 같이 타입을 변환해야한다.

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

 

하지만 스프링에서는 @어노테이션을 사용해서 HTTP 파라메타를 원하는 형태로 변환할 수 있다.

  @GetMapping("/hello-v2")
  public String helloV2(@RequestParam Integer data) {
    System.out.println("data = " + data);
    return "ok";
  }
  
  
  @PostMapping("/user/add")
  public String search(@ModelAttribute User user, BindingResult result) {
    
    if (result.hasError()) {
      return "/user/add"; // add.html에 모델(User)과 BindingResult가 전달된다.
    }
    userService.add(user);
    return "/home";
  }

 

@RequestParm, @ModelAttribute, @PathVariable 부터 시작해서, "/home"을 뷰 객체로 변환하거나 객체 정보를 JSON으로 전송하는 할수도 있고 좀 더 추상적인 정보 (IP, Port)를 변환하는 등 정말 수많은 곳에서 타입 변환이 발생한다.

 

 

이는 스프링에서 다양한 타입 컨버터를 가지고 있고 이를 사용하기 때문이다. 만약 개발자가 새로운 타입을 만들어서 Converter를 구현하고 싶다면 어떻게 사용해야 할까?

 

참고로 스프링3.0 이전에는 자바의 PropertyEditor 객체를 사용해 타입 변환을 했었다. 하지만 이는 동시성 문제가 있어 타입 변환할 때 마다 객체를 계속해서 생성해줘야 하는 문제점이 있었다.

 

 

---

# 스프링의 Converter 인터페이스

• 스프링에서는 타입 컨버터를 만들기위해 아래와 같은 인터페이스를 제공해준다.

package org.springframework.core.convert.converter;

  public interface Converter<S, T> {

    T convert(S source);
  }

 

• 이 인터페이스를 이용해서 아래와 같이 간단하게 컨버터를 구현할 수 있다.

public class IntegerToStringConverter implements Converter<Integer, String> {
  // 내가 만든 Integer -> String 컨버터
  @Override
  public String convert(Integer source) {
    return String.valueOf(source);
  }
}

public class StringToIntegerConverter implements Converter<String, Integer> {
  // 만약 반대로 전환하는 기능도 필요하다면 이렇게 하나 더 만들어 주면 된다.
  @Override
  public Integer convert(String source) {
    return Integer.valueOf(source);
  }
}

 

• 컨버터를 만들었다면 잘 작동하는지 반드시 테스트해봐야한다.

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

 

---

# IpPort 객체 컨버터 만들기

String <-> Integer 컨버터는 굳이 만들어야하나..? 의문이 생길 수 있다. 이번에는 좀 더 복잡한 예제를 만들어보자.

@Getter
@EqualsAndHashCode // 비교를 위한 lombok 코드 생성
public class IpPort {
    private String ip;
    private int port;

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

• 위의 IpPort 객체를 String으로 변환하는 컨버터를 구현하면 아래와 같다.

@Slf4j
public class IpPortToStringConverter implements Converter<IpPort, String> {
    @Override
    public String convert(IpPort source) {
        //IpPort 객체 -> "127.0.0.1:8080"
        return source.getIp() + ":" + source.getPort();
    }
}

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

    @Override
    public IpPort convert(String source) {
        //"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);
    }
}

 

• 마찬가지로 잘 작동하는지 테스트해보자.

  public class ConverterTest {
    @Test
    void stringToIpPort() {
      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");
    }
  
    @Test
    void ipPortToString() {
      StringToIpPortConverter converter = new StringToIpPortConverter();
      String source = "127.0.0.1:8080";
      IpPort result = converter.convert(source);
      assertThat(result).isEqualTo(new IpPort("127.0.0.1", 8080));
    }
  }

 

 

---

# 컨버터를 만들고 테스트하는 과정은 복잡하다.

매번 컨버터를 구현하고, 테스트하는 과정은 이처럼 복잡하다. 또한 만들어둔 컨버터는 프로젝트 전체에서 쓰이기에 동시성 문제가 발생할 수 있다. 컨버터를 만들고, 테스트하고 사용하는걸 한번에 관리할 수는 없을까?

 

➡ 스프링의 ConversionService

ConverionService에서 제공하는 객체

이미 알고있겠지만, 스프링의 ConversionService에서는 서비스에서 자주 사용하는 타입 컨버터들이 이미 등록되어있다.

"StringTo..."만 검색하더라도 70개가 넘는 컨버터가 존재하는 걸 볼 수 있다.

 

---

# ConversionService 인터페이스

스프링에서는 컨버터를 등록하고 쉽게 사용할 수 있도록 ConversionService 인터페이스를 제공한다. 스프링에서 기본으로 제공해주는 컨버터들이 많아 어지간하면 직접 만들일은 없지만, 만들고 싶다면 이 링크를 참조하자.

• ConversionService는 사용에 초점을 맞춘 인터페이스이다. 클라이언트는 컨버터 구현체에 의존하지 않는다.

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

 

• ConverterRegistry는 등록에 초점을 맞춘 인터페이스이다. 컨버터 구현체는 구체적인 컨버터를 작성한다.

  public interface ConverterRegistry {
    void addConverter(Converter<?, ?> converter);

    <S, T> void addConverter(Class<S> sourceType, Class<T> targetType,
        Converter<? super S, ? extends T> converter);

    void addConverter(GenericConverter converter);

    void addConverterFactory(ConverterFactory<?, ?> factory);

    void removeConvertible(Class<?> sourceType, Class<?> targetType);

  }

 

 

• 사용법은 간단하다. 인터셉터처럼 @Configuration를 통해 스프링 ConversionService에 등록하고, 사용하면 된다.
   ➡ 스프링 내장 컨버터와 똑같은 동작(str->Integer)을 한다면, 아래와 같이 직접 추가한 컨버터를 먼저 사용한다.

@Configuration
public class WebConfig implements WebMvcConfigurer {

  @Override
  public void addFormatters(FormatterRegistry registry) {
    // 스프링 내부에 있는 ConversionService에 등록된다.
    // ConversionService conversionService = new DefaultConversionService();
    
    // 직접 추가한 컨버터는, 스프링 기본 컨버터보다 높은 우선순위를 가진다.
    registry.addConverter(new StringToIntegerConverter());
    registry.addConverter(new IntegerToStringConverter());
    registry.addConverter(new StringToIpPortConverter());
    registry.addConverter(new IpPortToStringConverter());
  }
}

 

• 이제 스프링에서 사용하는 @RequestPararm등에서 우리가 만든 컨버터가 추가로 동작한다.
   ➡ 정확히는 스프링 MVC의 ArumentResolver가 등록된 ConversionService 인터페이스를 사용해 타입을 변환한다.

 

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

  @GetMapping("/ip-port") // registry.addConverter(new StringToIpPortConverter());
  public String ipPort(@RequestParam IpPort ipPort) {
    System.out.println("ipPort IP = " + ipPort.getIp());
    System.out.println("ipPort PORT = " + ipPort.getPort());
    return "ok";
  }

 

---

# 타임리프(View Template)에 컨버터 사용하기

• 타임리프는 변환하지 않은 모델 객체를 전달하더라도 타임리프 코드에서 스프링 컨버터를 적용할수도 있다.

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

 

• 아래와 같이 타임리프 변수 표현식에 ${{...}} 를 사용하면 컨버터를 사용해서 렌더링한다.

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
  ...
</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><!-- 그냥 str(ipPort) 처리 -->
    <li>${{ipPort}}: <span th:text="${{ipPort}}"></span></li><!-- 스프링 컨버터 사용 -->
  </ul>
</body>
</html>

 

• 또한 타임리프의 th:field는 자동으로 스프링 컨버터를 적용해서 HTTP 요청메시지를 보낸다.
   ➡ 컨버터를 사용하지않고 문자열 그대로 전송하려면 th:value를 사용하면 된다. 

<form th:object="${form}" th:method="post">
    th:field <input type="text" th:field="*{ipPort}"><br/> <!-- ${{ipPort}} -->
    th:value <input type="text" th:value="*{ipPort}"><br/> <!-- ${ipPort} -->
    <input type="submit"/>
</form>

 

• 우리는 당연하다고 생각하고 @ModelAttribute 를 이용해 뷰에서 객체를 받아왔지만, 실제로는 HTTP에서 전송된 문자열을 객체로 컨버터하는 과정이 있다는 걸 인지하자.

  @Data
  class IpPortForm {
    private IpPort ipPort;
    public IpPortForm(IpPort ipPort) {
      this.ipPort = ipPort;
    }
  }

...
  @GetMapping("/converter/edit")
  public String converterForm(Model model) {
    IpPort ipPort = new IpPort("127.0.0.1", 8080);
    IpPortForm form = new IpPortForm(ipPort); // Form 객체를 모델로 전달
    model.addAttribute("form", form);
    return "converter-form";
  }

  @PostMapping("/converter/edit")
  public String converterEdit(@ModelAttribute IpPortForm form, Model model) {
    // @ModelAttribute 받아보면 IpPort에 컨버터가 적용되어있음.
    // 만약 th:value로 전송하면 단순 .toString() 문자열이 들어가있다.
    IpPort ipPort = form.getIpPort();
    model.addAttribute("ipPort", ipPort);
    return "converter-view";
  }

 

---

# Formatter 포맷터

위에서 배운 Converter는 타입에 제한없이 변환기능을 제공했다. 하지만 HTTP 요청의 대부분은 String으로 변환하는 경우가 대부분이다. 그래서 스프링에서는 문자를 처리에 특화된 컨버터인 Fomatter 인터페이스를 제공한다.

 ➡ 참고로 동일한 동작을 하는 Converter와 Formatter가 있다면, 컨버터가 먼저 적용된다. 우선순위가 더 높다.

Core Technologies

 

Formatter는 특별한 String Converter라고 생각하면 된다. 문자를 출력할 때 Locale 정보를 이용하여 국제화하거나 원하는 모양의 문자열로 포맷팅할 수 있는 추가기능을 제공한다.

 ➡ 보면 인터페이스를 신기하게 상속하고있는데, 왜 이랬는지 궁금하다면 객체지향의 ISP 원칙을 찾아보자.

  public interface Printer<T> {
    String print(T object, Locale locale);
  }

  public interface Parser<T> {
    T parse(String text, Locale locale) throws ParseException;
  }
  
  public interface Formatter<T> extends Printer<T>, Parser<T> {
      String print(T object, Locale locale);
      T parse(String text, Locale locale) throws ParseException;
  }

@Slf4j
public class MyNumberFormatter implements Formatter<Number> {
    @Override
    public Number parse(String text, Locale locale) throws ParseException {
        //"1,000" -> 1000
        NumberFormat format = NumberFormat.getInstance(locale);
        return format.parse(text);
    }

    @Override
    public String print(Number object, Locale locale) {
        // 1000 -> "1,000"
        return NumberFormat.getInstance(locale).format(object);
    }
}

 

---

# 내가 만든 Formatter를 스프링 ConversionService에 등록하기

• 컨버터랑 포맷터의 사용법은 똑같다. 애초에 메서드 이름도 addFormatters 였기도 하다.
   ➡ 스프링부트에서는 DefaultConversionService를 상속받은 WebConversionService 구현체를 사용한다.

@Configuration
public class WebConfig implements WebMvcConfigurer {

  @Override
  public void addFormatters(FormatterRegistry registry) {
    // 앞에서 등록했던 컨버터
    // ConversionService conversionService = new WebConversionService();
    registry.addConverter(new StringToIpPortConverter());
    registry.addConverter(new IpPortToStringConverter());

    //추가. 스프링에서는 어댑터 패턴등을 이용해 Formatter를 Converter처럼 동작하도록 만든다.
    registry.addFormatter(new MyNumberFormatter());
  }
}

 

• 참고로 ConversionService는 스프링에 의존적인 객체가 아니다. 아래와 같이 따로 사용할 수도 있다.

public class FormattingConversionServiceTest {

  @Test
  void formattingConversionService() {
    // ConversionService 객체 생성
    DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();
    //컨버터 등록
    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);

  }
}

 

---

# Formatter를 실제 서비스에 사용해보기

컨버터랑 다른 똑같이 사용하면 된다. 등록은 달라도 사용할 때는 같은 인터페이스를 사용한다.

@Slf4j
public class MyNumberFormatter implements Formatter<Number> {

  @Override
  public Number parse(String text, Locale locale) throws ParseException {
    //"1,000" -> 1000
    NumberFormat format = NumberFormat.getInstance(locale);
    return format.parse(text);
  }

  @Override
  public String print(Number object, Locale locale) {
    // 1000 -> "1,000"
    return NumberFormat.getInstance(locale).format(object);
  }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

  @Override
  public void addFormatters(FormatterRegistry registry) {
    registry.addFormatter(new MyNumberFormatter());
  }
}

<!-- formatter-view.html -->
<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>

<!-- formatter-form.html -->
<form th:method="post" th:object="${form}">
  <!-- 클라이언트 ➡ 서버 -->  
  number <input th:field="*{number}" type="text"><br/> <!-- th:field 는 컨버터 적용 -->
  localDateTime <input th:field="*{localDateTime}" type="text"><br/> 
  <input type="submit"/>
    
</form>

 

---

# 스프링 어노테이션 포맷터 활용(@NumberFormat, @DateTimeFormat)

스프링에 있는 기본 포맷터들을 사용하다가 나만의 포맷터가 필요하다면 이렇게 만들어서 등록하면 된다. 하지만 생각해보면 날짜, 문자에 간단한 포맷팅을 추가할때도 매번 이런 과정을 거쳐 객체를 생성하기에는 너무 번거롭다.

 

 ➡ 스프링에서는 @XxxFormat(pattern="...")으로 기본 포맷터를 등록할 수 있게 구현해놓았다.

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

Core Technologies

@Data
class Form { // 모델으로 사용하는 객체에 이렇게 Formatter를 지정 해줄 수 있다.
  @NumberFormat(pattern = "###,###") // "100,000" -> 100000
  private Integer number;

  @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // "2021-08-31 ..." -> Date 객체
  private LocalDateTime 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";
  }
}

 

---

# 주의사항 (HttpMessageConverter)

@ResponceBody에 사용되는 메시지 컨버터(HttpMessageConverter)와 Conversion Service와는 전혀 상관없다.

 

이 둘은 별개의 것으로 메시지 컨버터의 경우에는 외부라이브러리(Jackson)로 동작하는거지 스프링 자체의 컨버전 서비스에서 Converter, Formatter를 사용하는게 아니다. 즉 변경하고 싶다면 스프링 @Configuration에 컨버터를 추가하는게 아니라 외부 라이브러리 관련 설정을 바꿔야한다.

 

스프링 Conversion Service는 @ModelAttribute, @RequestParam, @PathVariable 등에 적용된다.

 

# @ResponseBody를 커스텀하는 방법

물론 @ReponseBody에 사용되는 HttpMessageConverter의 구현체를 변경하는 방법도 있다. 

다만 기본 구현체(Jackson)을 굳이 변경해서 사용하면 번거롭기도하고, 굳이 그렇게까지 할 이유도 없다.

 

Rest API 서버를 구현할 때, @ResponseBody 의 컨버터를 변경하고 싶다면 스프링 기본 구현체인 Jackson에서 제공해주는 어노테이션으로 해결하자.

• 바이트 데이터 -> ByteArrayHttpMessageConverter
• 문자열 데이터 -> StringHttpMessageConverter
• 객체, HashMap -> MappingJackson2HttpMessageConveter (내부적으로 Jackson 라이브러리에 처리를 위임한다.)

import com.fasterxml.jackson.annotation.*;

 

예를 들어, Request에 담긴 Json Body의 이름 규칙이 다르다면

@JsonProperty를 이용하여 바꿀 수 있다. 만약 시간과 같이 포맷팅된 데이터는 @JsonFormat을 사용하면 된다.

@RestController
@RequestMapping("/api")
public class StudentController {

    public void post(@RequestBody Student student) {
        System.out.println(student);
    }
}

@Data
public class Student {

    @JsonProperty("my_name")
    private String myName;

    @JsonProperty("my_age")
    private String myAge;

    @JsonProperty("my_country")
    private String myCountry;
    
    @JsonFormat(
       shape = JsonFormat.Shape.STRING,
       pattern = "dd-MM-yyyy hh:mm:ss")
    public Date eventDate;

}

 

만약 하나씩 지정하는게 귀찮다면, @JsonNaming을 이용하여 포맷팅을 바꿀 수 있다. ( my_fisrt_age ➡ MyFirstAge)

@Data
@JsonNaming(value = PropertyNamingStrategy.SnakeCaseStrategy.class)
public class Student {

    private String myName; // my_name 가 여기에 저장됨
    private String myAge; // my_age 가 여기에 저장됨
    private String myCountry; // my_country 가 여기에 저장됨
}

 

특정 메서드가 해당 필드를 반환하도록 설정할수도 있다.

public class MyBean {
    public int id;
    private String name;

    @JsonGetter("name")
    public String myGetTheName() {
        return name;
    }

    @JsonSetter("name")
    public void mySetTheName(String name) {
        this.name = name;
    }
}

 

필드가 아닌 생성자로 객체를 만들고 싶다면, @JsonCreator 를 사용하면 된다.

public class BeanWithCreator {
    public int id;
    public String name;

    @JsonCreator
    public BeanWithCreator(
      @JsonProperty("id") int id, 
      @JsonProperty("theName") String name) {
        this.id = id;
        this.name = name;
    }
}

 

만약 만들어둔 DTO가 재사용된다면, 아래와 같이 한 필드에 여러 값을 지정할 수 있다.

public class AliasBean {
    @JsonAlias({ "fName", "f_name" })
    private String firstName;   
    private String lastName;
}

 

마지막으로 직렬화하면 안되는 필드는 @JsonIgnore, @JsonIgnoreProperties 로 필드가 없는 것처럼 처리할 수 있다.

public class BeanWithIgnore {
    @JsonIgnore
    public int id; // 직렬화가 되지 않음. 결과에는 name 만 남게됨

    public String name;
}

@JsonIgnoreProperties({ "id" })
public class BeanWithIgnore {
    public int id; // 직렬화가 되지않음. 결과 값에는 name만 남게됨.
    public String name;
}

public class User {
    public int id;
    public Name name;

    @JsonIgnoreType // inner class는 이렇게 ignore를 설정할 수 있다.
    public static class Name { 
        public String firstName;
        public String lastName;
    }
}

 

또는 null 인 값만 직렬화 대상에서 제외하고 싶다면, 아래와 같이 @JsonInclude를 사용하는 방법도 있다.

@JsonInclude(Include.NON_NULL)
public class MyBean {
    public int id; // null 인 경우 제외됨.
    public String name; // null 인 경우 제외됨
}

 

마지막으로 DTO를 상속하거나 inner class를 사용한 경우에도 변환이 가능하다.

🧨 다만 이렇게 복잡하게 사용하지 말고, 그냥 클래스를 2개로 나눠서 쓰자.

inner class는 그냥 쓰면 된다. 특별한거 없다.

 

public class Zoo {
    public Animal animal;

    public Zoo(Animal animal) {
        this.animal = animal;
    }
    
    @JsonTypeInfo( // 원하는 모양 {"animal": {"type":"dog", "name":"...", "barkVolume":0.0} }
            use = JsonTypeInfo.Id.NAME,
            include = JsonTypeInfo.As.PROPERTY,
            property = "type") // "type"에 타입 정보가 기록되도록 만들기
    @JsonSubTypes({ // 어떤 타입인지 기록하고 싶다면, @JsonSubTypes를 이용해서 정의
            @JsonSubTypes.Type(value = Dog.class, name = "dog"),
            @JsonSubTypes.Type(value = Cat.class, name = "cat") })
    public static class Animal {
        public String name;
    }

    @JsonTypeName("dog")
    public static class Dog extends Animal {
        public double barkVolume;

        public Dog(String name) {
            super.name = name;
        }
    }

    @JsonTypeName("cat")
    public static class Cat extends Animal {
        public int lives;
        boolean likesCream;
    }
}