Java 动态构建 GeoJSON 完整实现指南

2. 核心编辑器：JsonEditor

这是整个系统的核心，支持链式调用，封装了当前操作状态。

public static class JsonEditor {
    private final ObjectNode rootNode;
    private ObjectNode currentTargetNode;

    public JsonEditor(String jsonStr) throws JsonProcessingException {
        this.rootNode = (ObjectNode) OBJECT_MAPPER.readTree(jsonStr);
        this.currentTargetNode = rootNode;
    }

    /**
     * 设置目标节点路径，支持链式调用
     */
    public JsonEditor target(String nodePath) {
        // 实际实现中需解析路径并定位节点
        // 此处简化示意
        return this;
    }

    /**
     * 添加简单键值对
     */
    public JsonEditor add(String key, String value) {
        currentTargetNode.put(key, value);
        return this;
    }

    /**
     * 添加嵌套对象，使用模板方法模式
     */
    public JsonEditor addNestedObject(String key, Consumer<JsonEditor> consumer) {
        ObjectNode nestedNode = OBJECT_MAPPER.createObjectNode();
        ObjectNode originalTarget = currentTargetNode;
        
        currentTargetNode = nestedNode;
        consumer.accept(this);
        
        currentTargetNode = originalTarget;
        currentTargetNode.set(key, nestedNode);
        return this;
    }

    /**
     * 添加列表映射，支持复杂对象集合
     */
    public JsonEditor addListMap(String key, List<Map<String, Object>> list) {
        ArrayNode arrayNode = OBJECT_MAPPER.createArrayNode();
        for (Map<String, Object> item : list) {
            arrayNode.add(OBJECT_MAPPER.valueToTree(item));
        }
        currentTargetNode.set(key, arrayNode);
        return this;
    }

    public String toPrettyJson() {
        try {
            return OBJECT_MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(rootNode);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }
}

3. 辅助组件：ArrayEditor

专门处理数组类型的操作，应用组合模式，将数组逻辑从主编辑器分离。

public static class ArrayEditor {
    private final ArrayNode arrayNode;

    public ArrayEditor(ArrayNode arrayNode) {
        this.arrayNode = arrayNode;
    }

    public ArrayEditor add(Object value) {
        if (value instanceof String) {
            arrayNode.add((String) value);
        } else if (value instanceof Map) {
            arrayNode.add(OBJECT_MAPPER.valueToTree(value));
        }
        return this;
    }

    public ArrayEditor addObject(Consumer<JsonEditor> consumer) {
        ObjectNode objectNode = OBJECT_MAPPER.createObjectNode();
        JsonEditor editor = new JsonEditor("{}") {
            @Override
            public ObjectNode getRootNode() {
                return objectNode;
            }
        };
        consumer.accept(editor);
        arrayNode.add(objectNode);
        return this;
    }
}

三、设计模式应用

本方案融合了多种设计模式以提升扩展性：

• 建造者模式：JsonEditor 的链式调用允许逐步构建复杂对象，API 更流畅。
• 策略模式：通过 Consumer 和 Function 接口，允许外部传入自定义处理逻辑，如数据清洗或转换。
• 模板方法模式：在 addNestedObject 中定义创建、配置、恢复状态的骨架，具体配置由回调实现。

四、实战调用示例

1. 添加简单属性与列表

直接操作 properties 节点，支持基本类型及对象列表。

String originalJson = "{\"type\" : \"Feature\", \"geometry\" : {\"type\":\"Point\",\"coordinates\":[113.902426,22.729881]}, \"properties\" : {\"id\" : 1369981, \"location\" : \"光明区玉塘街道文明路 13 号\", \"reason\" : \"故障\", \"startTime\" : \"10:13\", \"estimatedRestore\" : \"10:15\", \"durationHours\" : 2}}";

System.out.println("=== 原始 JSON ===");
System.out.println(originalJson);

// 准备 POI 数据
List<Map<String, Object>> poiList = new ArrayList<>();
Map<String, Object> poi1 = new HashMap<>();
poi1.put("name", "南山外国语学校");
poi1.put("type", "学校");
poi1.put("distance", 500);
poiList.add(poi1);

HashMap<String, Object> contactMap = new HashMap<>();
contactMap.put("person", "李主任");
contactMap.put("phone", "13800138001");

Map<String, Object> poi2 = new HashMap<>();
poi2.put("name", "某大型数据中心");
poi2.put("type", "商业");
poi2.put("capacity", "1000 台服务器");
poi2.put("contact", contactMap);
poiList.add(poi2);

// 执行动态添加
JsonEditor editor1 = JsonPropertyManager.createEditor(originalJson);
editor1.target("properties").addListMap("majorPOIs", poiList);

2. 添加嵌套结构与数组

处理多层级数据时，利用回调函数配置内部结构。

JsonEditor editor2 = JsonPropertyManager.createEditor(originalJson);
editor2.target("properties")
    .addNestedObject("analysis", nested -> {
        nested.add("riskLevel", "中")
              .add("impactRadius", 1000)
              .addNestedArray("affectedServices", services -> {
                  services.add("电力供应")
                          .add("网络通信")
                          .add("安防系统");
              })
              .addNestedObject("timeline", timeline -> {
                  timeline.add("detectionTime", "10:10")
                          .add("dispatchTime", "10:20")
                          .add("estimatedCompletion", "12:00");
              });
    })
    .addNestedArray("repairTeams", teams -> {
        try {
            teams.addObject(team -> {
                team.add("name", "光明供电局抢修一队")
                    .add("members", 5)
                    .add("equipment", Arrays.asList("绝缘杆", "万用表", "工具箱"));
            })
            .addObject(team -> {
                team.add("name", "技术支持小组")
                    .add("members", 3)
                    .add("specialties", Arrays.asList("变压器维修", "线路检测"));
            });
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    });

System.out.println(editor2.toPrettyJson());

五、总结

通过上述实现，我们可以在不破坏原有 GeoJSON 结构的前提下，灵活地注入业务所需的动态属性。这种方案特别适合前后端交互频繁、数据结构变动较多的场景。借助设计模式的支撑，后续若需支持更多数据类型或序列化方式，只需扩展对应的 Editor 类即可，无需改动核心调用逻辑。