타입 변환과 포매팅

package board.domain;

public record PostId(long value) {
    public PostId {
        if (value <= 0) {
            throw new IllegalArgumentException(
                    "post id must be positive");
        }
    }

    public static PostId parse(String text) {
        String candidate = text == null ? "" : text.strip();
        if (!candidate.startsWith("P-")) {
            throw new IllegalArgumentException(
                    "post id must start with P-");
        }
        try {
            return new PostId(Long.parseLong(candidate.substring(2)));
        } catch (NumberFormatException exception) {
            throw new IllegalArgumentException(
                    "post id suffix must be numeric", exception);
        }
    }

    @Override
    public String toString() {
        return "P-" + value;
    }
}

package board.web;

import board.domain.PostId;

import org.springframework.core.convert.converter.Converter;

public final class StringToPostIdConverter
        implements Converter<String, PostId> {
    @Override
    public PostId convert(String source) {
        return PostId.parse(source);
    }
}

package board.web;

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

import org.springframework.format.Formatter;

public final class CharacterCountFormatter
        implements Formatter<CharacterCountFormatter.CharacterCount> {
    @Override
    public CharacterCount parse(String text, Locale locale) {
        String candidate = text == null ? "" : text.strip();
        NumberFormat format = NumberFormat.getIntegerInstance(locale);
        format.setGroupingUsed(true);
        ParsePosition position = new ParsePosition(0);
        Number value = format.parse(candidate, position);
        if (value == null || position.getIndex() != candidate.length()) {
            throw new IllegalArgumentException(
                    "invalid localized character count");
        }
        long parsed = value.longValue();
        if (parsed < Integer.MIN_VALUE || parsed > Integer.MAX_VALUE) {
            throw new IllegalArgumentException(
                    "invalid localized character count");
        }
        return new CharacterCount((int) parsed);
    }

    @Override
    public String print(CharacterCount value, Locale locale) {
        return NumberFormat.getIntegerInstance(locale)
                .format(value.value());
    }

    public record CharacterCount(int value) {
        public CharacterCount {
            if (value < 1 || value > 720) {
                throw new IllegalArgumentException(
                        "character count must be between 1 and 720");
            }
        }
    }
}

package board.web;

import org.springframework.context.annotation.Configuration;
import org.springframework.format.FormatterRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConversionConfiguration implements WebMvcConfigurer {
    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new StringToPostIdConverter());
        registry.addFormatter(new CharacterCountFormatter());
    }
}

package board.web;

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

import java.util.Locale;

import org.junit.jupiter.api.Test;
import org.springframework.format.support.DefaultFormattingConversionService;
import org.springframework.context.i18n.LocaleContextHolder;

import board.domain.PostId;

class CharacterCountFormatterTest {
    private final CharacterCountFormatter formatter =
            new CharacterCountFormatter();

    @Test
    void 출력한_문자열은_같은_locale에서_원래_값으로_복원된다() {
        var value = new CharacterCountFormatter.CharacterCount(120);

        String printed = formatter.print(value, Locale.KOREAN);
        var parsed = formatter.parse(printed, Locale.KOREAN);

        assertThat(printed).isEqualTo("120");
        assertThat(parsed).isEqualTo(value);
    }

    @Test
    void 숫자_뒤의_임의_문자를_허용하지_않는다() {
        assertThatThrownBy(() -> formatter.parse(
                "120 chars", Locale.ENGLISH))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("invalid localized character count");
    }

    @Test
    void MVC_registry는_PostId와_CharacterCount를_정확히_연결한다() {
        var conversion = new DefaultFormattingConversionService();
        new WebConversionConfiguration()
                .addFormatters(conversion);

        LocaleContextHolder.setLocale(Locale.KOREAN);
        try {
            assertThat(conversion.convert(" P-1042 ", PostId.class))
                    .isEqualTo(new PostId(1042));
            assertThat(conversion.convert(
                    "120",
                    CharacterCountFormatter.CharacterCount.class))
                    .isEqualTo(
                            new CharacterCountFormatter.CharacterCount(120));
            assertThat(conversion.convert(
                    new CharacterCountFormatter.CharacterCount(120),
                    String.class))
                    .isEqualTo("120");
        } finally {
            LocaleContextHolder.resetLocaleContext();
        }
    }
}

print ko 120 = 120
parse ko 120 = CharacterCount[value=120]
parse en 120 chars = rejected
partial parse accepted = false
round-trip = true
MVC " P-1042 " -> PostId[value=1042]
MVC CharacterCount[value=120] -> "120"