web项目国际化指南

已于 2025-02-06 11:33:02 修改
阅读量814 收藏 8
点赞数 10
分类专栏： java 文章标签： web项目国际化 多线程
于 2025-01-16 19:27:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tianmlin1/article/details/145188466
版权

目录

前言

代码案例

注意事项

直接new一个线程的用例

使用线程池的用例

总结

前言

在国际化浪潮下，目前已经有很多项目需要支持国际化。所谓的国际化就是需要根据用户选择的语言，终端页面的展示、接口的返回等都需要跟着语言一起切换。

这里就用用一个简单的案例来说明，web项目国际化的步骤与注意事项。国际化的步骤网上的教程很多，我这里就着重介绍一下在多线程环境下的国际化支持。

代码案例

先定义一个国际化的枚举类

package com.tml.mouseDemo.constants;

import lombok.Getter;

import static com.tml.mouseDemo.constants.CommonConstants.APP;
import static com.tml.mouseDemo.constants.CommonConstants.SYS;

@Getter
public enum I18nKey {

    INVALID_PWD(10001,APP),
    SAY_HELLO(10002,APP),
    NETWORK_ERROR(90001,SYS);

    private int code;

    private String type;

    I18nKey(int code, String type) {
        this.code = code;
        this.type = type;
    }
}

用户选择的语言环境， 我这边假设放在http请求的header中的language_code

再定义一个语言的上下文

package com.tml.mouseDemo.config;

import com.alibaba.ttl.TransmittableThreadLocal;

public class LanguageContext {
 
    private static final ThreadLocal<String> LANGUAGE = new TransmittableThreadLocal<>();
 
    public static String get() {
        return LANGUAGE.get();
    }
 
    public static void set(String age) {
        LANGUAGE.set(age);
    }
 
    public static void clean() {
        if (LANGUAGE.get() != null) {
            LANGUAGE.remove();
        }
    }
 
}

特别说明：

这里一定要使用 TransmittableThreadLocal，为什么要使用ttl可以参考这一篇文章阿里巴巴TransmittableThreadLocal使用指南

再定义一个拦截器

package com.tml.mouseDemo.config;


import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import static com.tml.mouseDemo.constants.CommonConstants.LANGUAGE_CODE;

@Slf4j
public class RequestInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String language = request.getHeader(LANGUAGE_CODE);
        log.info("RequestInterceptor preHandle,request language is {}", language);
        LanguageContext.set(language);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("RequestInterceptor afterCompletion,request language is {},ready to clean data!", LanguageContext.get());
        LanguageContext.clean();
    }
}

接着注册拦截器

package com.tml.mouseDemo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.nio.charset.Charset;
import java.util.List;

@Configuration
public class WebAppConfig implements WebMvcConfigurer {

    @Bean
    public HttpMessageConverter<String> responseBodyConverter() {
        StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));
        return stringHttpMessageConverter;

    }

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(responseBodyConverter());
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new RequestInterceptor()).addPathPatterns("/**");
    }
}

操作国际化的工具类

package com.tml.mouseDemo.core.i18n;

import com.tml.mouseDemo.config.LanguageContext;
import com.tml.mouseDemo.constants.I18nKey;
import lombok.extern.slf4j.Slf4j;

import java.util.Locale;
import java.util.Optional;
import java.util.ResourceBundle;

import static com.tml.mouseDemo.constants.CommonConstants.DEFAULT_LANGUAGE_CODE;

@Slf4j
public class I18nUtil {

    /**
     * 获取当前线程的language
     *
     * @return
     */
    public static String getLanguageCode() {
        String lanCode = LanguageContext.get();
        return Optional.ofNullable(lanCode).orElse(DEFAULT_LANGUAGE_CODE);
    }

    public static String getI18nMessage(I18nKey i18nKey) {

        String languageCode = getLanguageCode();

        try {
            StringBuilder sb = new StringBuilder();
            sb.append("i18n.").append("messages_").append(i18nKey.getType());


            String i18keyPrefix = sb.toString();
            String actualKey = i18nKey.getType() + "." + i18nKey.name().toLowerCase();
            Locale locale = new Locale(languageCode);
            ResourceBundle bundle = ResourceBundle.getBundle(i18keyPrefix, locale);
            String message = new String(bundle.getString(actualKey).getBytes("iso-8859-1"), "utf-8");
            log.info("getI18nMessage i18keyPrefix:{}--languageCode:{}--actualKey:{}--message:{}", i18keyPrefix, languageCode, actualKey, message);
            return message;

        } catch (Exception e) {
            log.error("getI18nMessage occur error", e);
        }

        return i18nKey.name().toLowerCase();
    }
}

国际化配置文件参考

准备完成后，就可以来测试一下了，先看一个简单的单线程案例

    @PostMapping("/i18n")
    public CommonResponse<String> i18nHandler(String pwd) {
        log.info("i18nHandler pwd:{}",pwd);
        if (StrUtil.isBlank(pwd)||pwd.length()<6) {
            return CommonResponse.failWithI18n(I18nKey.INVALID_PWD);
        }
        return CommonResponse.success("common handler");
    }

运行结果如下

 能正常的进行中英文切换，达到了预期

注意事项

下面来掩饰多线程环境下国际化的案例

直接new一个线程的用例

@PostMapping("/i18nHandlerWithThread")
    public CommonResponse<String> i18nHandlerWithThread(String pwd) {
        log.info("i18nHandler pwd:{}",pwd);

        if (StrUtil.isBlank(pwd)||pwd.length()<6) {
            return CommonResponse.failWithI18n(I18nKey.INVALID_PWD);
        }
        //模拟异步发短信
        new Thread(()->{
            try {
                Thread.sleep(2000);
                String sendMsg = I18nUtil.getI18nMessage(I18nKey.SAY_HELLO);
                log.info("i18nHandler sendMsg:{}",sendMsg);

            }catch (Exception e) {
                log.error("i18nHandlerWithThread occur error", e);
            }

        },"i18n--001").start();

        return CommonResponse.success("common handler");
    }

这里通过模拟异步线程发送短信来演示

请求了两次，能实现中英文的切换，也是符合预期，当然实际生产环境，很少会直接创建线程来使用，这里需要注意的是，我们使用的是阿里的TransmittableThreadLocal

使用线程池的用例

先定义两个线程池，一个普通的线程池，一个使用ttl装饰的线程池

package com.tml.mouseDemo.config;

import com.alibaba.ttl.threadpool.TtlExecutors;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.*;

@Slf4j
@Configuration
public class CommonConfig {

    Thread.UncaughtExceptionHandler exceptionHandler = (Thread t, Throwable e) -> {
        log.info("current thread occurs error！", e);
    };

    @Bean
    public ThreadPoolExecutor executor() {

        ThreadFactory threadFactory = new ThreadFactoryBuilder().
                setUncaughtExceptionHandler(exceptionHandler).
                setNameFormat("mouse-worker-%d").build();
        int processors = Runtime.getRuntime().availableProcessors();
        log.info("processors:{}", processors);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1,
                processors * 2,
                0L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingDeque<>(1000),
                threadFactory,
                new ThreadPoolExecutor.AbortPolicy());
        return executor;
    }


    /**
     * 使用阿里的 TransmittableThreadLocal 装饰线程池
     * @return
     */
    @Bean
    public Executor ttlExecutor() {

        ThreadFactory threadFactory = new ThreadFactoryBuilder().
                setUncaughtExceptionHandler(exceptionHandler).
                setNameFormat("mouse-worker-ttl-%d").build();
        int processors = Runtime.getRuntime().availableProcessors();
        log.info("processors:{}", processors);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1,
                processors * 2,
                0L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingDeque<>(1000),
                threadFactory,
                new ThreadPoolExecutor.AbortPolicy());

        Executor ttlExecutor = TtlExecutors.getTtlExecutor(executor);
        return ttlExecutor;
    }


    
}

这里，我特意将两个线程池的核心线程数设置为了1，这样是为了方便演示 

关键的用例在这里，我这里用两个线程池来做对比

package com.tml.mouseDemo.controller;

import cn.hutool.core.util.StrUtil;
import com.tml.mouseDemo.config.LanguageContext;
import com.tml.mouseDemo.constants.CommonResponse;
import com.tml.mouseDemo.constants.I18nKey;
import com.tml.mouseDemo.core.i18n.I18nUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
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.RestController;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

@RestController
@Slf4j
public class TestController {

    @Autowired
    private ThreadPoolExecutor executor;

    @Autowired
    private Executor ttlExecutor;

   

    @PostMapping("/i18nHandlerWithThreadPool")
    public CommonResponse<String> i18nHandlerWithThreadPool(String pwd) {
        log.info("i18nHandler pwd:{}",pwd);

        if (StrUtil.isBlank(pwd)||pwd.length()<6) {
            return CommonResponse.failWithI18n(I18nKey.INVALID_PWD);
        }
        //模拟异步发短信
        executor.execute(()->{
            try {
                Thread.sleep(2000);
                String sendMsg = I18nUtil.getI18nMessage(I18nKey.SAY_HELLO);
                log.info("i18nHandler sendMsg:{}",sendMsg);

            }catch (Exception e) {
                log.error("i18nHandlerWithThread occur error", e);
            }
        });

        //模拟异步发短信
        ttlExecutor.execute(()->{
            try {
                Thread.sleep(2000);
                String sendMsg = I18nUtil.getI18nMessage(I18nKey.SAY_HELLO);
                log.info("i18nHandler sendMsg:{}",sendMsg);

            }catch (Exception e) {
                log.error("i18nHandlerWithThread occur error", e);
            }
        });



        return CommonResponse.success("common handler");
    }

}

执行两次请求，看下效果

稍微解释一下执行的结果，因为普通的线程池的核心线程数是1，也就意味着这个线程会被复用，因此绑定在这个线程上的ThreadLocal变量也是会复用的，这也是强烈推荐使用 阿里巴巴TransmittableThreadLocal使用指南 的原因。

总结

通过上面的几个案例，演示了在国际化的web项目中使用多线程的注意事项，如果你们的项目中会使用多线程编程并且会使用线程池，那么久强烈建议使用阿里的TransmittableThreadLocal

另外，在我们这个用例中，我们将国际化配置文件分成了系统国际化配置文件messages_sys和业务国际化配置文件messages_app，这样可以将国际化的配置分开，方便管理。当然，如果你还有更好的解决方案，欢迎在评论区留言!

最后，上面的代码案例都上传到github，欢迎前来围观我的github

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值