使用Jackson库编辑JSON数组：修改嵌套字段B4的技术问询

没问题，我来教你用Jackson修改这个JSON里A8下的B4数组！先把你的目标JSON结构清晰列出来：

{ 
  "A1":"1234", 
  "A2": "123", 
  "A3": "???", 
  "A4": "object, may not be populated.", 
  "A5": { }, 
  "A6": { }, 
  "A7":{ 
    "B1": ["100"], 
    "B2": ["C"], 
    "B3": ["O", "A"] 
  }, 
  "A8":{ 
    "B4":["D1"], 
    "B5":["D2"], 
    "B6":["D3"], 
    "B7":["D4"], 
    "B8":["D5"], 
    "B9":["D6"], 
    "B10":["123"] 
  }, 
  "ignoreThisField": "it is useless" 
}

Jackson提供了两种常用的方式来修改JSON，我都给你列出来，你可以根据自己的场景选：

方式一：用树形API（适合JSON结构不固定的场景） #

这种方式不需要定义POJO类，直接操作JSON节点，灵活性很高。因为Jackson默认解析出来的JsonNode是不可变的，所以我们要转换成ObjectNode来做修改：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.io.IOException;

public class JsonModifier {
    public static void main(String[] args) throws IOException {
        // 读取JSON文件到byte数组（你的readJson方法已经实现）
        byte[] jsonData = readJson(JsonFilePath);
        
        ObjectMapper objectMapper = new ObjectMapper();
        // 解析为可变的ObjectNode
        ObjectNode rootNode = (ObjectNode) objectMapper.readTree(jsonData);
        
        // 获取A8节点，判断是否存在
        ObjectNode a8Node = (ObjectNode) rootNode.get("A8");
        if (a8Node != null) {
            // 获取B4的数组节点
            ArrayNode b4Array = (ArrayNode) a8Node.get("B4");
            
            if (b4Array != null) {
                // 示例1：修改数组里的第一个元素
                if (b4Array.size() > 0) {
                    b4Array.set(0, objectMapper.valueToTree("updated_D1"));
                }
                
                // 示例2：清空原有元素，添加新元素
                // b4Array.removeAll();
                // b4Array.add("new_D1");
                // b4Array.add("new_D1_2");
            } else {
                // 如果B4不存在，创建新的数组并添加到A8
                ArrayNode newB4Array = objectMapper.createArrayNode();
                newB4Array.add("default_D1");
                a8Node.set("B4", newB4Array);
            }
        }
        
        // 可选：移除无用的ignoreThisField字段
        rootNode.remove("ignoreThisField");
        
        // 把修改后的JSON转换成格式化的字符串
        String updatedJson = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(rootNode);
        System.out.println(updatedJson);
        
        // 或者转换成byte数组用于后续操作
        // byte[] updatedJsonBytes = objectMapper.writeValueAsBytes(rootNode);
    }
    
    // 假设你的readJson方法实现如下
    private static byte[] readJson(String jsonFilePath) {
        // 这里写你的文件读取逻辑，比如用Files.readAllBytes
        return new byte[0];
    }
}

方式二：用POJO映射（适合JSON结构固定的场景） #

如果你的JSON结构比较稳定，定义对应的POJO类会更类型安全，操作起来也更直观：

首先定义POJO类：

import com.fasterxml.jackson.annotation.JsonIgnore;
import java.util.List;

class Root {
    private String A1;
    private String A2;
    private String A3;
    private String A4;
    private Object A5;
    private Object A6;
    private A7 A7;
    private A8 A8;
    
    // 忽略不需要的字段
    @JsonIgnore
    private String ignoreThisField;

    // 生成所有字段的getter和setter方法
    public String getA1() { return A1; }
    public void setA1(String A1) { this.A1 = A1; }
    public String getA2() { return A2; }
    public void setA2(String A2) { this.A2 = A2; }
    public String getA3() { return A3; }
    public void setA3(String A3) { this.A3 = A3; }
    public String getA4() { return A4; }
    public void setA4(String A4) { this.A4 = A4; }
    public Object getA5() { return A5; }
    public void setA5(Object A5) { this.A5 = A5; }
    public Object getA6() { return A6; }
    public void setA6(Object A6) { this.A6 = A6; }
    public A7 getA7() { return A7; }
    public void setA7(A7 A7) { this.A7 = A7; }
    public A8 getA8() { return A8; }
    public void setA8(A8 A8) { this.A8 = A8; }
}

class A7 {
    private List<String> B1;
    private List<String> B2;
    private List<String> B3;

    // getter和setter
    public List<String> getB1() { return B1; }
    public void setB1(List<String> B1) { this.B1 = B1; }
    public List<String> getB2() { return B2; }
    public void setB2(List<String> B2) { this.B2 = B2; }
    public List<String> getB3() { return B3; }
    public void setB3(List<String> B3) { this.B3 = B3; }
}

class A8 {
    private List<String> B4;
    private List<String> B5;
    private List<String> B6;
    private List<String> B7;
    private List<String> B8;
    private List<String> B9;
    private List<String> B10;

    // getter和setter
    public List<String> getB4() { return B4; }
    public void setB4(List<String> B4) { this.B4 = B4; }
    public List<String> getB5() { return B5; }
    public void setB5(List<String> B5) { this.B5 = B5; }
    public List<String> getB6() { return B6; }
    public void setB6(List<String> B6) { this.B6 = B6; }
    public List<String> getB7() { return B7; }
    public void setB7(List<String> B7) { this.B7 = B7; }
    public List<String> getB8() { return B8; }
    public void setB8(List<String> B8) { this.B8 = B8; }
    public List<String> getB9() { return B9; }
    public void setB9(List<String> B9) { this.B9 = B9; }
    public List<String> getB10() { return B10; }
    public void setB10(List<String> B10) { this.B10 = B10; }
}

然后编写修改逻辑：

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class PojoJsonModifier {
    public static void main(String[] args) throws IOException {
        byte[] jsonData = readJson(JsonFilePath);
        ObjectMapper objectMapper = new ObjectMapper();
        
        // 反序列化成Root对象
        Root root = objectMapper.readValue(jsonData, Root.class);
        
        if (root.getA8() != null) {
            List<String> b4List = root.getA8().getB4();
            if (b4List != null) {
                // 修改第一个元素
                if (!b4List.isEmpty()) {
                    b4List.set(0, "updated_D1");
                }
                // 或者添加新元素
                // b4List.add("extra_D1");
            } else {
                // 如果B4为null，初始化一个新列表
                b4List = new ArrayList<>();
                b4List.add("default_D1");
                root.getA8().setB4(b4List);
            }
        }
        
        // 序列化回JSON字符串
        String updatedJson = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(root);
        System.out.println(updatedJson);
    }
    
    private static byte[] readJson(String jsonFilePath) {
        // 你的文件读取逻辑
        return new byte[0];
    }
}

两种方式各有优缺点：树形API灵活，不用写POJO，适合结构多变的JSON；POJO方式类型安全，代码可读性高，适合结构固定的场景，你可以根据自己的需求选择~

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