实现图表展示数据项的国际化实现方案几种方案参考

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InternationalizedField {
    String key(); // 用于指定国际化资源文件中的键
}

import java.util.List;

public class MyDTO {
    @InternationalizedField(key = "xxxxDTO.field1")
    private String field1;

    @InternationalizedField(key = "xxxxDTO.field2")
    private String field2;

    // Getters and setters
}

public class Result {
    private List<MyDTO> a;
    private List<B> bList;

    // Getters and setters
}

public class B {
    private String name;
    private String realName;

    // Getters and setters
}

import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.List;

@Service
public class MyService {

    public Result getResult(String locale) {
        MyDTO dto1 = new MyDTO();
        MyDTO dto2 = new MyDTO();
        List<MyDTO> dtoList = Arrays.asList(dto1, dto2);

        B b1 = new B();
        b1.setName("xxxxDTO.field1");

        B b2 = new B();
        b2.setName("xxxxDTO.field2");

        List<B> bList = Arrays.asList(b1, b2);

        Result result = new Result();
        result.setA(dtoList);
        result.setBList(bList);

        return result;
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }
}

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    private final MyService myService;

    public MyController(MyService myService) {
        this.myService = myService;
    }

    @GetMapping("/result")
    public Result getResult(@RequestHeader("Accept-Language") String locale) {
        return myService.getResult(locale);
    }
}

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.List;

@Component
public class InternationalizedSerializer extends JsonSerializer<Result> {

    @Autowired
    private LocalizationService localizationService;

    private static final String FIELD_A = "a";
    private static final String FIELD_B_LIST = "bList";
    private static final String FIELD_NAME = "name";
    private static final String FIELD_REAL_NAME = "realName";

    @Override
    public void serialize(Result result, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeStartObject();

        // 序列化 A 列表
        serializeA(result.getA(), gen);

        // 序列化 B 列表
        serializeB(result.getBList(), result.getA(), gen);

        gen.writeEndObject();
    }

    private void serializeA(List<MyDTO> aList, JsonGenerator gen) throws IOException {
        gen.writeArrayFieldStart(FIELD_A); // 开始写入名为 "a" 的数组字段
        for (MyDTO dto : aList) {
            gen.writeStartObject(); // 开始写入一个对象
            // 序列化 MyDTO 中的每个字段
            for (Field field : dto.getClass().getDeclaredFields()) {
                field.setAccessible(true); // 设置字段可访问
                String fieldName = field.getName(); // 获取字段名
                Object value;
                try {
                    value = field.get(dto); // 获取字段的值
                } catch (IllegalAccessException e) {
                    value = null;
                }
                gen.writeObjectField(fieldName, value); // 写入字段名和对应的值
            }
            gen.writeEndObject(); // 结束当前对象的写入
        }
        gen.writeEndArray(); // 结束数组字段的写入
    }

    private void serializeB(List<B> bList, List<MyDTO> aList, JsonGenerator gen) throws IOException {
        gen.writeArrayFieldStart(FIELD_B_LIST); // 开始写入名为 "bList" 的数组字段
        for (B b : bList) {
            gen.writeStartObject(); // 开始写入一个对象
            gen.writeStringField(FIELD_NAME, b.getName()); // 写入 "name" 字段的值
            String locale = LocaleContextHolder.getLocale().toString(); // 获取当前语言环境
            String realName = getRealNameFromDTOs(aList, b.getName(), locale); // 获取实际名称的国际化值
            gen.writeStringField(FIELD_REAL_NAME, realName); // 写入 "realName" 字段的值
            gen.writeEndObject(); // 结束当前对象的写入
        }
        gen.writeEndArray(); // 结束数组字段的写入
    }

    private String getRealNameFromDTOs(List<MyDTO> dtos, String name, String locale) {
        for (MyDTO dto : dtos) {
            for (Field field : dto.getClass().getDeclaredFields()) {
                if (field.isAnnotationPresent(InternationalizedField.class)) {
                    InternationalizedField annotation = field.getAnnotation(InternationalizedField.class);
                    if (annotation.key().equals(name)) {
                        return localizationService.getLocalizedValue(annotation.key(), locale);
                    }
                }
            }
        }
        return null;
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class JacksonConfig {

    @Bean
    public ObjectMapper objectMapper(InternationalizedSerializer internationalizedSerializer) {
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleModule module = new SimpleModule();
        module.addSerializer(Result.class, internationalizedSerializer);
        objectMapper.registerModule(module);
        return objectMapper;
    }
}