[Spring] 스프링 타입 컨버터

728x90

타입 컨버터

HTTP 요청 파라미터는 원래 String 타입으로 받을 수 있는데 타입 컨버터 때문에 개발자가 원하는 타입으로 형변환 시켜주는 역할을 한다.
- 사용 예) @RequestParam / @ModelAttribute / @PathVariable
스프링은 용도에 따라 다양한 방식의 타입 컨버터를 제공한다.
- Converter : 기본 타입 컨버터
- ConverterFactory : 전체 클래스 계층 구조가 필요할 때
- GenericConverter : 정교한 구현, 대상 필드의 애노테이션 정보 사용 가능
- ConditionalGenericConverter : 특정 조건이 참인 경우에만 실행

🔍 컨버터 인터페이스

package org.springframework.core.convert.converter;

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

스프링은 확장 가능한 컨버터 인터페이스를 제공한다.
개발자는 스프링에 추가적인 타입 변환이 필요하면 컨버터 인터페이스를 구현해서 등록하면 된다.
컨버터 인터페이스는 모든 타입에 적용할 수 있다.
Converter 이름의 인터페이스가 많으니 org.springframework.core.convert.converter.Converter 인터페이스를 사용해야 한다.

💡 문자 → 숫자

📌 conveter

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

📌 테스트 코드

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

}

💡 숫자 → 문자

📌 컨버터

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("converter =source={}", source);
        return String.valueOf(source);
    }
}

📌 테스트 코드

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

💡 문자 → IpPort 객체

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

📌 컨버터

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("converter source={}", source);

        // "127.0.0.1:8080"
        String[] split = source.split(":");
        String ip = split[0];
        int port = Integer.parseInt(split[1]);
        return new IpPort(ip, port);
    }
}

📌 테스트 코드

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

💡 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("converter source={}", source);

        // IpPort 객체 → "127.0.0.1:8080"
        return source.getIp() + ":" + source.getPort();
    }
}

📌 테스트 코드

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

컨버전 서비스 - ConversionService

스프링은 개별 컨버터를 모아두고 그것들을 묶어서 편리하게 사용할 수 있는 기능을 제공한다. 그것이 바로 컨버전 서비스(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);
}

canConvert
- 컨버팅이 가능한지에 대해서 확인해주는 역할
convert
- conConvert의 결과가 true값일 경우에만 컨버팅 기능으로써 작동된다.

📌 컨버전 서비스 테스트 코드

package hello.typeconverter.converter;

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

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

public class ConversionServiceTest {

    @Test
    void conversionService() {

        // 등록
        DefaultConversionService conversionService = new DefaultConversionService();
        conversionService.addConverter(new StringToIntegerConverter());
        conversionService.addConverter(new IntegerToStringConverter());
        conversionService.addConverter(new IpPortToStringConverter());
        conversionService.addConverter(new StringToIpPortConverter());

        // 사용
        assertThat(conversionService.convert("10", Integer.class)).isEqualTo(10);
        assertThat(conversionService.convert(10, String.class)).isEqualTo("10");

        IpPort ipPort = conversionService.convert("127.0.0.1:8080", IpPort.class);
        assertThat(ipPort).isEqualTo(new IpPort("127.0.0.1", 8080));

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

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

💡 등록과 사용 분리

컨버터를 등록할 때는 StringToIntegerConverter 같은 타입 컨버터를 명확하게 알아야 한다.
반면 컨버터를 사용하는 입장에서는 타입 컨버터를 몰라도 된다.
타입 컨버터들은 모두 컨버전 서비스 내부에 숨어서 제공된다.
따라서 타입 변환을 원하는 사용자는 컨버전 서비스 인터페이스에만 의존하면 된다. 물론 컨버전 서비스를 등록하는 부분과 사용하는 부분을 분리하고 의존관계 주입을 사용해야 한다.

✔ DefaultConversionService

DefaultConversionService 클래스는 2가지 인터페이스를 구현했다.
- ConversionService 인터페이스 - 컨버터 사용 기능
- ConverterRegistry 인터페이스 - 컨버터 등록 기능
이렇게 기능에 따라 인터페이스를 분리하면 사용하는 클라이언트와 컨버터를 등록하고 관리하는 클라이언트를 명확하게 분리할 수 있다.
- 사용하는 클라이언트는 ConversionService만 의존하면 된다.
이런 인터페이스 분리를 ISP(인터페이스 분리 원칙)라고 한다.

스프링에 Converter 적용하기

스프링은 내부에서 ConversionService를 제공한다.
우리는 WebMvcConfigurer 인터페이스가 제공하는 addFormatters() 메서드를 사용해서 추가하고 싶은 컨버터를 등로갛면 된다.
- 스프링 MVC에 등록하려면 WebMvcConfigurer 인터페이스를 구현하면 된다.
이렇게 하면 스프링은 내부에서 사용하는 ConversionService에 컨버터를 추가해준다.

📌 WebConfig (스프링에 컨버터 추가)

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) {
        registry.addConverter(new StringToIntegerConverter());
        registry.addConverter(new IntegerToStringConverter());
        registry.addConverter(new StringToIpPortConverter());
        registry.addConverter(new IpPortToStringConverter());
    }
}

📌 컨트롤러

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

'http://localhost:8080/ip-port?ipPort=127.0.0.1:8080' url로 접속하면 '?ipPort=127.0.0.1:8080' 쿼리 스트링이 @RequestParam IpPort ipPort에서 객체 타입으로 변환되었다.

🔍 처리 과정

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

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

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

💡 예제1

📌 컨트롤러 (ConverterController)

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

📌 converter-view.html

<!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>

타임리프는 ${{...}} 를 사용하면 자동으로 ConversionService를 사용해서 변환된 결과를 출력한다.
변수 표현식 : ${...}
ConversionService 적용 : ${{...}}

결과

${{number}}
- 뷰 템플릿은 문자로 출력한다. 따라서 컨버터를 적용하게 되면 Integer 타입인 10000을 String 타입으로 변환하는 컨버터인 IntegerToStringConverter를 실행하게 된다.
${{ipPort}}
- 뷰 템플릿은 데이터를 문자로 출력한다.
- 컨버터를 적용하게 되면 IpPort 타입을 String 타입으로 변환해야 하므로 IpPortToStringConverter가 적용된다.

💡 예제2

📌 컨트롤러 (ConverterController)

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

}

Form 객체는 데이터를 전달하는 폼 객체로 사용한다.
GET /converter/edit
- IpPort를 뷰 템플릿 폼에 출력한다.
POST /converter/edit
- 뷰 템플릿 폼의 IpPort 정보를 받아서 출력한다.

📌 converter-form.html

<!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>

타임리프의 th:field 는 id, name을 출력하는 등 다양한 기능이 있는데, ConversionService도 함께 적용된다.
GET /converter/edit
- th:field 가 자동으로 ConversionService를 적용해서 ${{ipPort}} 처럼 적용되어 있다.
- 따라서 IpPort → String으로 변환된다.
POST /converter/edit
- @ModelAttribute 를 사용해서 String → IpPort로 변환된다.

결과

🧷 정리

타임리프에서 th:filed 는 ConversionService 기능을 자동으로 적용시킨다.

포맷터 - Formatter

객체를 특정 포맷에 맞춰 문자로 출력하거나 또는 그 반대의 역할을 하는 것에 특화된 기능이 Formatter다.
- Converter의 특별한 버전으로 이해하면 된다.
Converter는 입력과 출력 타입에 제한이 없는 범용 타입 변환 기능을 제공한다.
그런 범용 타입 변환 기능 보다 문자를 다른 타입으로 변환하거나, 다른 타입을 문자로 변환하는 상황이 대부분이다.
- 사용 예)
  - Integer → String (쉼표도 같이 출력할 때) : 1000 → "1,000"
  - String → Integer : "1,000" → 1000
그런 기능을 하는것이 Formatter(포맷터)이다.

🔍 Locale

Locale의 현지화 정보를 사용하여 날짜, 숫자의 표현방법을 현지화에 맞춰 사용할 수 있다.

🔍 Converter vs Formatter

Converter는 범용 (객체 → 객체)
Formatter는 문자에 특화 (객체 → 문자 / 문자 → 객체) + 현지화 (Locale)

🔍 포맷터 만들기

포맷터는 객체를 문자로 변경하고, 문자를 개겣로 변겨하는 두 가지 기능을 수행한다.

💡 Formatter 인터페이스

public interface Formatter<T> extends Printer<T>, Parser<T> {
}

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

public interface Parser<T> {
    T parse(String text, Locale locale) throws ParseException;
}

Formatter 인터페이스는 Printer, Parser 인터페이스를 상속받는다.
Printer 인터페이스는 객체를 문자로 변경하는 기능을 담당한다.
- String print(T object, Locale locale) : 객체를 문자로 변경한다.
Parser 인터페이스는 문자를 객체로 변경하는 기능을 담당한다.
- T parser(String text, Locale locale) : 문자를 객체로 변경한다.

📌 MyNumberFormatter

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> {

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

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

Locale 정보를 활용해서 나라별로 다른 숫자 포맷을 만들 수 있다.

📌 테스트 코드

package hello.typeconverter.formatter;

import org.junit.jupiter.api.Test;

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

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

class MyNumberFormatterTest {

    MyNumberFormatter formatter = new MyNumberFormatter();

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

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

📍 참고)

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

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

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

ConversionService는 Converter만 등록할 수 있고, Formatter를 등록할 수 없다.
Formatter를 지원하는 ConversionService를 사용하면 Formatter를 추가할 수 있다.
내부에서 어댑터 패턴을 사용해서 Formatter가 Converter처럼 동작하도록 지원한다.
FormattingConversionService는Formatter를 지원하는 컨버전 서비스다.
DefaultFormattingConversionService는 FormattingConversionService에 기본적인 통화, 숫자 관련 몇가지 기본 포멧터를 추가해서 제공한다.
추가로 스프링 부트는 DefaultFormattingConversionService를 상속 받은 WebConversionService를 내부에서 사용한다.

📌 DefaultFormattingConversionService 사용

package hello.typeconverter.formatter;

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

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

public class FormattingConversionServiceTest {

    @Test
    void formattingConversionService() {
        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);

    }
}

FormattingConversionService는 ConversionService 관련 기능을 상속받기 때문에 결과적으로 컨버터, 포멧터 모두 등록할 수 있다.
사용할 때는 ConversionService가 제공하는 convert() 메서드를 사용하면 된다.

포멧터를 웹에서 적용하기

📌 포멧터

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> {

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

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

📌 포멧터 등록하기 (WebConfig)

package hello.typeconverter;

import hello.typeconverter.converter.IpPortToStringConverter;
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) {
//        주석처리 (컨버터는 우선순위가 높다. 포멧터는 우선순위가 낮다.)
//        registry.addConverter(new StringToIntegerConverter());
//        registry.addConverter(new IntegerToStringConverter());

        // 컨버터 추가
        registry.addConverter(new StringToIpPortConverter());
        registry.addConverter(new IpPortToStringConverter());

        // 포멧터 추가
        registry.addFormatter(new MyNumberFormatter());
    }
}

포멧터인 MyNumberFormatter도 숫자 → 문자 / 문자 → 숫자로 변경하는 기능을 담당하고 있기에 컨버터와 기능이 겹친다.
우선순위는 컨버터가 더 높아서 컨버터를 주석처리 했다.

📌 컨트롤러

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

결과

10,000 으로 컨버팅이 되었다.

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

주로 개발자가 포멧터를 만들기보단 스프링에서 기본적으로 제공하는 포멧터를 자주 쓴다.
@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;
    }
}

📌 formatter-form.html

<!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>

📌 formatter-view.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>

📍 주의

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

👀 참고자료

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-mvc-2/dashboard

스프링 MVC 2편 - 백엔드 웹 개발 활용 기술 - 인프런 | 강의

웹 애플리케이션 개발에 필요한 모든 웹 기술을 기초부터 이해하고, 완성할 수 있습니다. MVC 2편에서는 MVC 1편의 핵심 원리와 구조 위에 실무 웹 개발에 필요한 모든 활용 기술들을 학습할 수 있

www.inflearn.com

728x90

'[ Spring ] > SpringMVC 2편' 카테고리의 다른 글

[Spring] API 예외 처리 (0)	2022.03.15
[Spring] 예외 처리와 오류 페이지 (0)	2022.03.15
[Spring] 로그인 처리2 - 필터, 인터셉터 (0)	2022.03.13
[Spring] 로그인 처리1 - 쿠키, 세션 (0)	2022.03.12
[Spring] 검증2 - Bean Validation (0)	2022.03.11

타입 컨버터

🔍 컨버터 인터페이스

💡 문자 → 숫자

💡 숫자 → 문자

💡 문자 → IpPort 객체

💡 IpPort 객체 → 문자

컨버전 서비스 - ConversionService

🔍 ConversionService 인터페이스

💡 등록과 사용 분리

스프링에 Converter 적용하기

🔍 처리 과정

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

💡 예제1

💡 예제2

포맷터 - Formatter

🔍 Locale

🔍 Converter vs Formatter

🔍 포맷터 만들기

💡 Formatter 인터페이스

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

포멧터를 웹에서 적용하기

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

'[ Spring ] > SpringMVC 2편' 카테고리의 다른 글

티스토리툴바