Java动态替换json文件中键值

在 Java 中读取 JSON 文件并根据传入的多个参数替换多个相应 key 的属性值，我们可以扩展前面的代码。我们将使用一个Map<String, String> 来存储 key 和它们的新值，然后在遍历 JSON 对象时，检查每个 key 是否在这个 Map 中，并替换对应的值。

引入依赖

<dependencies>
    <!-- Jackson Core -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.15.0</version>
    </dependency>

    <!-- Jackson Databind -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.15.0</version>
    </dependency>

    <!-- Jackson Dataformat XML -->
    <dependency>
        <groupId>com.fasterxml.jackson.dataformat</groupId>
        <artifactId>jackson-dataformat-xml</artifactId>
        <version>2.15.0</version>
    </dependency>
</dependencies>

实现

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class MultiKeyJsonModifier {

    public static void main(String[] args) {
        // JSON 文件路径
        String jsonFilePath = "json_file.json"; 

        // 要修改的多个 key 及其新值
        Map<String, String> keyValues = new HashMap<>();
        keyValues.put("key1", "newValue1"); // 需要替换的 key 和新值
        keyValues.put("key2", "newValue2"); 

        try {
            // 调用方法来修改 JSON 文件中的多个 key 的值
            modifyJsonValues(jsonFilePath, keyValues);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 修改 JSON 文件中指定的多个 key 的值
     *
     * @param jsonFilePath JSON 文件路径
     * @param keyValues    要修改的 key 及其新值的 Map
     * @throws IOException 如果文件读取或写入时出现错误
     */
    public static void modifyJsonValues(String jsonFilePath, Map<String, String> keyValues) throws IOException {
        // 创建 ObjectMapper 对象，用于处理 JSON 数据
        ObjectMapper mapper = new ObjectMapper();

        // 读取 JSON 文件并解析为 JsonNode 对象
        JsonNode rootNode = mapper.readTree(new File(jsonFilePath));

        // 调用递归方法来查找并替换多个 key 的值
        JsonNode modifiedNode = modifyNode(rootNode, keyValues);

        // 将修改后的 JSON 数据写回文件
        mapper.writerWithDefaultPrettyPrinter().writeValue(new File(jsonFilePath), modifiedNode);

        // 输出修改后的 JSON 内容
        System.out.println("Modified JSON Content: \n" + mapper.writerWithDefaultPrettyPrinter().writeValueAsString(modifiedNode));
    }

    /**
     * 递归查找并修改 JSON 节点中指定的多个 key 的值
     *
     * @param node      当前 JSON 节点
     * @param keyValues 要修改的 key 及其新值的 Map
     * @return 修改后的 JSON 节点
     */
    private static JsonNode modifyNode(JsonNode node, Map<String, String> keyValues) {
        // 如果当前节点是一个 ObjectNode（即 JSON 对象）
        if (node.isObject()) {
            ObjectNode objectNode = (ObjectNode) node;

            // 遍历对象的所有字段
            Iterator<String> fieldNames = objectNode.fieldNames();
            while (fieldNames.hasNext()) {
                String fieldName = fieldNames.next();
                JsonNode childNode = objectNode.get(fieldName);

                // 如果字段名在 keyValues 中，则替换其值
                if (keyValues.containsKey(fieldName)) {
                    objectNode.put(fieldName, keyValues.get(fieldName));
                } else {
                    // 递归调用以继续处理子节点
                    modifyNode(childNode, keyValues);
                }
            }
        } else if (node.isArray()) {
            // 如果当前节点是一个 ArrayNode（即 JSON 数组）
            for (JsonNode arrayElement : node) {
                // 递归调用以处理数组中的每个元素
                modifyNode(arrayElement, keyValues);
            }
        }
        // 返回修改后的节点
        return node;
    }
}

• modifyNode 方法通过递归遍历 JSON 结构，查找 Map 中的每个 key 并替换其值。无论 key 在对象还是数组中，该方法都能处理。

使用效果

• json文件内容如下

{
    "name": "John",
    "age": 30,
    "address": {
        "city": "SZ",
        "postalCode": "10001"
    },
    "phones": [
        {
            "type": "home",
            "address": "龙华"
        },
        {
            "type": "mobile",
            "number": "987654321"
        }
    ]
}

• 待修改数据

Map<String, String> keyValues = new HashMap<>();
keyValues.put("address", "罗湖");
keyValues.put("postalCode", "88888888888");

• 修改后json文件内容

{
    "name": "John",
    "age": 30,
    "address": {
        "city": "SZ",
        "postalCode": "88888888888"
    },
    "phones": [
        {
            "type": "home",
            "address": "罗湖"
        },
        {
            "type": "mobile",
            "number": "987654321"
        }
    ]
}

总结

通过递归遍历 JSON 结构，根据传入的 Map 动态地替换多个键值对。这个方法对处理复杂的嵌套 JSON 数据结构非常有效，并且可以灵活地扩展以处理更多复杂的修改需求