如何用Jackson限制动态嵌套JSON中所有字符串值的长度为5字符？

需求说明 #

需要处理动态嵌套的JSON字符串，将所有键对应的字符串值截断为最大5个字符，使用Java的fasterxml.jackson库实现。

示例输入输出 #

输入1：

String inputJsonString = "{\"key1\":\"bla bla bla bla\",\"key2\":{\"key21\":\"bla bla bla\"}}";

输出1：

String outputJsonString = "{\"key1\":\"bla b\",\"key2\":{\"key21\":\"bla b\"}}";

输入2：

String inputJsonString = "{\"fname\":\"bla bla bla bla\",\"address\":{\"street\":\"bla bla bla\"}}";

输出2：

String outputJsonString = "{\"fname\":\"bla b\",\"address\":{\"street\":\"bla b\"}}";

实现方案 #

利用Jackson的树模型遍历所有节点，对字符串类型节点进行截断处理，具体步骤如下：

1. 将JSON字符串解析为可修改的ObjectNode
2. 递归遍历所有层级的节点，识别字符串节点并执行截断
3. 将处理后的节点转换回JSON字符串

完整代码示例 #

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

public class JsonStringTruncator {
    // 定义最大字符串长度
    private static final int MAX_STRING_LENGTH = 5;
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static String truncateAllStringValues(String inputJson) throws Exception {
        // 解析输入JSON为可修改的根节点
        ObjectNode rootNode = (ObjectNode) objectMapper.readTree(inputJson);
        // 递归处理所有节点
        traverseAndTruncate(rootNode);
        // 序列化回JSON字符串
        return objectMapper.writeValueAsString(rootNode);
    }

    private static void traverseAndTruncate(JsonNode node) {
        if (node.isObject()) {
            // 遍历对象的所有键值对
            node.fields().forEachRemaining(entry -> {
                JsonNode value = entry.getValue();
                if (value.isTextual()) {
                    // 截断字符串并更新节点
                    String truncated = truncateString(value.asText());
                    ((ObjectNode) node).put(entry.getKey(), truncated);
                } else if (value.isObject() || value.isArray()) {
                    // 递归处理嵌套对象或数组
                    traverseAndTruncate(value);
                }
            });
        } else if (node.isArray()) {
            // 处理数组中的每个元素
            for (int i = 0; i < node.size(); i++) {
                JsonNode element = node.get(i);
                if (element.isTextual()) {
                    String truncated = truncateString(element.asText());
                    ((com.fasterxml.jackson.databind.node.ArrayNode) node).set(i, objectMapper.getNodeFactory().textNode(truncated));
                } else if (element.isObject() || element.isArray()) {
                    traverseAndTruncate(element);
                }
            }
        }
    }

    // 字符串截断逻辑
    private static String truncateString(String original) {
        if (original == null) {
            return null;
        }
        return original.length() > MAX_STRING_LENGTH ? original.substring(0, MAX_STRING_LENGTH) : original;
    }

    // 测试方法
    public static void main(String[] args) throws Exception {
        String input1 = "{\"key1\":\"bla bla bla bla\",\"key2\":{\"key21\":\"bla bla bla\"}}";
        System.out.println(truncateAllStringValues(input1));

        String input2 = "{\"fname\":\"bla bla bla bla\",\"address\":{\"street\":\"bla bla bla\"}}";
        System.out.println(truncateAllStringValues(input2));
    }
}

代码说明 #

• ObjectMapper：Jackson的核心工具类，负责JSON的解析与序列化
• 递归遍历：覆盖嵌套对象、数组等所有层级，确保所有字符串值都被处理
• 截断逻辑：仅当字符串长度超过5时截取前5个字符，保留原内容的前半部分
• 可修改节点：使用ObjectNode和ArrayNode操作节点内容，保证JSON结构完整性

内容的提问来源于stack exchange，提问作者Bala Ganesan