메시지·국제화

site.title=게시판
post.create=게시글 등록
post.saved=제목이 {0}이고 본문이 {1}자인 게시글을 저장했습니다.
category.GENERAL=일반
category.QUESTION=질문
category.NOTICE=공지

site.title=Board
post.create=Create post
post.saved=Saved post {0} with {1} characters.
category.GENERAL=General
category.QUESTION=Question
category.NOTICE=Notice

package board.i18n;

import java.util.Locale;

import org.springframework.context.MessageSource;
import org.springframework.stereotype.Component;

@Component
public final class PostMessageService {
    private final MessageSource messages;

    public PostMessageService(MessageSource messages) {
        this.messages = messages;
    }

    public String saved(
            String title,
            String content,
            Locale locale
    ) {
        int characterCount = content.codePointCount(0, content.length());
        return messages.getMessage(
                "post.saved",
                new Object[]{title, characterCount},
                locale);
    }

    public String categoryLabel(PostCategory category, Locale locale) {
        return messages.getMessage(
                "category." + category.name(),
                null,
                locale);
    }

    public enum PostCategory {
        GENERAL, QUESTION, NOTICE
    }
}

package board.i18n;

import java.util.List;
import java.util.Locale;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver;

@Configuration(proxyBeanMethods = false)
public class LocaleConfiguration {
    static final Locale DEFAULT_LOCALE = Locale.KOREAN;
    static final List<Locale> SUPPORTED_LOCALES = List.of(
            Locale.KOREAN,
            Locale.ENGLISH);

    @Bean
    ResourceBundleMessageSource messageSource() {
        var source = new ResourceBundleMessageSource();
        source.setBasename("i18n/spring-ch7-messages/messages");
        source.setDefaultEncoding("UTF-8");
        source.setFallbackToSystemLocale(false);
        source.setDefaultLocale(DEFAULT_LOCALE);
        return source;
    }

    @Bean
    LocaleResolver localeResolver() {
        var resolver = new AcceptHeaderLocaleResolver();
        resolver.setSupportedLocales(SUPPORTED_LOCALES);
        resolver.setDefaultLocale(DEFAULT_LOCALE);
        return resolver;
    }

    static Locale resolveSupportedLocaleTag(String languageTag) {
        if (languageTag == null || languageTag.isBlank()) {
            return DEFAULT_LOCALE;
        }
        Locale requested = Locale.forLanguageTag(languageTag);
        return SUPPORTED_LOCALES.stream()
                .filter(locale -> locale.getLanguage()
                        .equals(requested.getLanguage()))
                .findFirst()
                .orElse(DEFAULT_LOCALE);
    }
}

package board.i18n;

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

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Locale;
import java.util.Set;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.context.NoSuchMessageException;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.mock.web.MockHttpServletRequest;

class MessageSourceContractTest {
    private static final Set<String> REQUIRED_CODES = Set.of(
            "site.title",
            "post.create",
            "post.saved",
            "category.GENERAL",
            "category.QUESTION",
            "category.NOTICE");

    private ResourceBundleMessageSource messages;

    @BeforeEach
    void setUp() {
        messages = new LocaleConfiguration().messageSource();
    }

    @Test
    void 영어_bundle은_argument_순서를_문장에_맞게_배치한다() {
        var result = messages.getMessage(
                "post.saved",
                new Object[]{"Spring", 45},
                Locale.ENGLISH);

        assertThat(result)
                .isEqualTo("Saved post Spring with 45 characters.");
    }

    @Test
    void 저장_메시지는_보조_평면_문자를_code_point_하나로_센다() {
        var service = new PostMessageService(messages);

        assertThat(service.saved("Unicode", "A😀", Locale.ENGLISH))
                .isEqualTo("Saved post Unicode with 2 characters.");
    }

    @Test
    void 영어_bundle은_분류의_업무_의미를_보존한다() {
        assertThat(messages.getMessage(
                "site.title", null, Locale.ENGLISH))
                .isEqualTo("Board");
        assertThat(messages.getMessage(
                "category.GENERAL", null, Locale.ENGLISH))
                .isEqualTo("General");
        assertThat(messages.getMessage(
                "category.QUESTION", null, Locale.ENGLISH))
                .isEqualTo("Question");
        assertThat(messages.getMessage(
                "category.NOTICE", null, Locale.ENGLISH))
                .isEqualTo("Notice");
    }

    @Test
    void 지원_locale_bundle은_필수_code를_빠짐없이_가진다()
            throws Exception {
        assertThat(bundleKeys("messages.properties"))
                .containsExactlyInAnyOrderElementsOf(REQUIRED_CODES);
        assertThat(bundleKeys("messages_en.properties"))
                .containsExactlyInAnyOrderElementsOf(REQUIRED_CODES);
    }

    @Test
    void accept_language는_지원_언어로_좁히고_나머지는_기본값을_쓴다() {
        var resolver = new LocaleConfiguration().localeResolver();
        var english = new MockHttpServletRequest();
        english.addHeader("Accept-Language", "en-US,en;q=0.9");
        var unsupported = new MockHttpServletRequest();
        unsupported.addHeader("Accept-Language", "fr-FR,fr;q=0.9");

        assertThat(resolver.resolveLocale(english))
                .isEqualTo(Locale.ENGLISH);
        assertThat(resolver.resolveLocale(unsupported))
                .isEqualTo(Locale.KOREAN);
        assertThat(LocaleConfiguration.resolveSupportedLocaleTag("en-US"))
                .isEqualTo(Locale.ENGLISH);
        assertThat(LocaleConfiguration.resolveSupportedLocaleTag("fr-FR"))
                .isEqualTo(Locale.KOREAN);
        assertThat(LocaleConfiguration.resolveSupportedLocaleTag("%%%"))
                .isEqualTo(Locale.KOREAN);
        assertThat(LocaleConfiguration.resolveSupportedLocaleTag(null))
                .isEqualTo(Locale.KOREAN);
    }

    @Test
    void 존재하지_않는_code는_기본_문자열_대신_예외로_발견한다() {
        assertThatThrownBy(() -> messages.getMessage(
                "post.unknown",
                null,
                Locale.KOREAN))
                .isInstanceOf(NoSuchMessageException.class);
    }

    private List<String> bundleKeys(String fileName) throws Exception {
        String path = "/i18n/spring-ch7-messages/" + fileName;
        try (var input = MessageSourceContractTest.class
                .getResourceAsStream(path)) {
            assertThat(input).as(path).isNotNull();
            var reader = new BufferedReader(new InputStreamReader(
                    input, StandardCharsets.UTF_8));
            return reader.lines()
                    .filter(line -> !line.isBlank())
                    .filter(line -> !line.startsWith("#"))
                    .map(line -> line.substring(0, line.indexOf('=')))
                    .toList();
        }
    }
}