【开发情景】数据库存的JSON数据转为Map，key值是中文，转成英文，转为json数据传给前端

要将数据库中的JSON数据转换为Map并且将其中的中文键值转换为英文键值，从数据库中取出来主要是一个String类型的值。建议使用方法三。

方法一（最详细）：

一、解析JSON数据：使用 JSON 库将字符串解析为 Map。

1、从数据库读取 JSON 字符串：

假设你从数据库中读取了一段 JSON 字符串，它代表一个对象的属性。例如：

{
    "名称": "张三",
    "年龄": 30,
    "性别": "男"
}

2、使用 Jackson 库解析 JSON：

在 Java 中，使用 Jackson 库可以很方便地将 JSON 字符串解析为 Map<String, Object>。首先，你需要导入 Jackson 库。

<!-- Maven 依赖 -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.0</version>
</dependency>

3、然后在代码中使用 ObjectMapper 来解析 JSON 数据：

关于ObjectMapper的详细使用参考

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.type.TypeReference;

public class JsonParser {

    public Map<String, Object> parseJson(String jsonString) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        // 将 JSON 字符串解析为 Map<String, Object>
        Map<String, Object> map = objectMapper.readValue(jsonString, new TypeReference<Map<String, Object>>() {});
        return map;
    }
}

二、键值转换：遍历 Map，将中文键替换为相应的英文键。

1、定义键值转换的映射：

先定义一个 Map<String, String> 来存储中文键和英文键的映射关系。

public class KeyTranslator {

    private static final Map<String, String> keyMap = new HashMap<>();

    static {
        keyMap.put("名称", "name");
        keyMap.put("年龄", "age");
        keyMap.put("性别", "gender");
        // 可以继续添加更多的键值对映射
    }

    public static String translateKey(String chineseKey) {
        return keyMap.getOrDefault(chineseKey, chineseKey); // 如果找不到映射，保持原样
    }
}

2、遍历并转换 Map：

遍历原始的 Map<String, Object>，将中文键替换为英文键，并生成一个新的 Map。

public class MapTransformer {

    public Map<String, Object> transformKeys(Map<String, Object> originalMap) {
        Map<String, Object> translatedMap = new HashMap<>();

        for (Map.Entry<String, Object> entry : originalMap.entrySet()) {
            String translatedKey = KeyTranslator.translateKey(entry.getKey());
            translatedMap.put(translatedKey, entry.getValue());
        }
        return translatedMap;
    }
}

三、返回给前端

1、在 Spring Boot 中返回 JSON：

通过控制器将处理后的 Map 直接返回给前端。Spring Boot 会自动将 Map 转换为 JSON 格式。

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping("/user")
    public Map<String, Object> getUserData() throws Exception {
        ...
        Map<String, Object> translatedMap = transformer.transformKeys();
		...
        // 返回给前端
        return translatedMap;
    }
}

2、前端接收和处理 JSON 数据：

前端通过 AJAX 或 fetch 请求获取这个 JSON 数据，并处理显示。

fetch('/api/user')
    .then(response => response.json())
    .then(data => {
        console.log(data.name); // 输出 "张三"
        console.log(data.age);  // 输出 30
        console.log(data.gender); // 输出 "男"
    });

方法二（遍历，最容易理解）：

保存转换后的数据：根据需要将转换后的Map重新保存或进一步处理。

以下是Java示例代码：

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.HashMap;
import java.util.Map;

public class JsonKeyTranslator {

    public static void main(String[] args) throws Exception {
        // 假设从数据库中读取的JSON字符串
        String jsonData = "{\"名称\":\"张三\", \"年龄\":25, \"性别\":\"男\"}";

        // 创建ObjectMapper实例
        ObjectMapper objectMapper = new ObjectMapper();

        // 将JSON字符串解析为Map
        Map<String, Object> originalMap = objectMapper.readValue(jsonData, new TypeReference<Map<String, Object>>() {});

        // 创建一个新的Map存储转换后的键值对
        Map<String, Object> translatedMap = new HashMap<>();

        // 键值转换逻辑
        for (Map.Entry<String, Object> entry : originalMap.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();

            // 根据键值进行翻译（这里简单映射，实际可使用更复杂的映射逻辑）
            String translatedKey = translateKey(key);

            // 将翻译后的键值对放入新的Map
            translatedMap.put(translatedKey, value);
        }

        // 输出转换后的Map
        System.out.println(translatedMap);
    }

    // 简单的中文键值到英文键值的映射方法
    private static String translateKey(String chineseKey) {
        switch (chineseKey) {
            case "名称":
                return "name";
            case "年龄":
                return "age";
            case "性别":
                return "gender";
            // 添加更多映射规则
            default:
                return chineseKey; // 没有匹配到的键，保持原样
        }
    }
}

示例输出：
假设输入的JSON是 {"名称":"张三", "年龄":25, "性别":"男"}，
输出结果为 {"name":"张三", "age":25, "gender":"男"}。

方法三（最简单，反序列化时使用注解映射）

使用注解的方法可以在对象序列化和反序列化时直接完成键值的转换，避免手动遍历和映射。通过使用 Jackson 的注解，如 @JsonProperty 、@JsonAlias，可以直接将 JSON 中的中文键映射到对象的字段上，再以对象的形式返回给前端。
关于 @JsonProperty 、@JsonAlias 的更多了解参考---->【注解】@JsonProperty 详解
,【注解】@JsonAlias 详解
示例：使用注解直接在 ObjectMapper 映射时做转换

一、定义 User 类并使用注解：

在 User 类中，使用 @JsonProperty 注解来指定 JSON 键与类字段之间的映射关系。

import com.fasterxml.jackson.annotation.JsonProperty;

public class User {
    @JsonProperty("名称")
    private String name;

    @JsonProperty("年龄")
    private int age;

    @JsonProperty("性别")
    private String gender;

    // Getters and Setters
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

@JsonProperty 注解：这个注解告诉 Jackson，在序列化和反序列化时，应该使用指定的 JSON 键来对应类中的字段。这样你就不需要手动编写键值映射逻辑了。
自动转换：当 Jackson 解析 JSON 数据或将对象转换为 JSON 时，会自动处理这些映射，将 JSON 中的中文键正确地映射到类的字段上。

二、在控制器中返回 User 对象：

在控制器中，直接将 User 对象返回给前端，Spring Boot 会自动将其序列化为 JSON。

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping("/user")
    public User getUser() {
        // 模拟从数据库中获取数据并手动构建 User 对象
        User user = new User();
        user.setName("张三");
        user.setAge(30);
        user.setGender("男");

        return user;  // 直接返回对象，Spring Boot 自动序列化为 JSON
    }
}

三、前端接收和处理 JSON 数据：

前端通过 fetch 或其他方式获取返回的 JSON 数据。

fetch('/api/user')
    .then(response => response.json())
    .then(data => {
        console.log(data.name);   // 输出 "张三"
        console.log(data.age);    // 输出 30
        console.log(data.gender); // 输出 "男"
    });

方法三的优势：
减少代码复杂性：通过注解，省去了手动编写转换逻辑的需求，代码更加简洁。
增强可读性：注解直接在类的字段上定义，使得映射关系一目了然，维护性更好。
直接返回对象：可以直接返回对象给前端，前端无需处理额外的键值映射。