是否可以使用 Jackson JSON 库合并两个 JSON 文档？我基本上使用 Jackson 映射器和简单的 Java 地图。
我尝试在 Google 和 Jackson 的文档中搜索，但找不到任何内容。
受到 StaxMans 答案的启发，我实现了这种合并方法。
public static JsonNode merge(JsonNode mainNode, JsonNode updateNode) {
Iterator<String> fieldNames = updateNode.fieldNames();
while (fieldNames.hasNext()) {
String fieldName = fieldNames.next();
JsonNode jsonNode = mainNode.get(fieldName);
// if field exists and is an embedded object
if (jsonNode != null && jsonNode.isObject()) {
merge(jsonNode, updateNode.get(fieldName));
}
else {
if (mainNode instanceof ObjectNode) {
// Overwrite field
JsonNode value = updateNode.get(fieldName);
((ObjectNode) mainNode).put(fieldName, value);
}
}
}
return mainNode;
}
希望这对某人有帮助。
一种方法是像这样使用
ObjectReaderMyBean defaults = objectMapper.readValue(defaultJson, MyBean.class);
ObjectReader updater = objectMapper.readerForUpdating(defaults);
MyBean merged = updater.readValue(overridesJson);
它将合并两个来源的数据。这只会进行浅复制，即不会对包含的对象进行递归合并。
否则，您可能需要将 JSON 作为树读取 (
JsonNode编辑：（2017 年 4 月 3 日）
根据 @Fernando Correia 的评论，即将推出的 Jackson 2.9（将于 2017 年 4 月或 5 月发布）实际上添加了一个新的 feature，最终允许深度合并。
受到阿恩的回答的启发。编辑它以添加节点中可能包含节点数组的情况。
public static JsonNode merge(JsonNode mainNode, JsonNode updateNode) {
Iterator<String> fieldNames = updateNode.fieldNames();
while (fieldNames.hasNext()) {
String updatedFieldName = fieldNames.next();
JsonNode valueToBeUpdated = mainNode.get(updatedFieldName);
JsonNode updatedValue = updateNode.get(updatedFieldName);
// If the node is an @ArrayNode
if (valueToBeUpdated != null && valueToBeUpdated.isArray() &&
updatedValue.isArray()) {
// running a loop for all elements of the updated ArrayNode
for (int i = 0; i < updatedValue.size(); i++) {
JsonNode updatedChildNode = updatedValue.get(i);
// Create a new Node in the node that should be updated, if there was no corresponding node in it
// Use-case - where the updateNode will have a new element in its Array
if (valueToBeUpdated.size() <= i) {
((ArrayNode) valueToBeUpdated).add(updatedChildNode);
}
// getting reference for the node to be updated
JsonNode childNodeToBeUpdated = valueToBeUpdated.get(i);
merge(childNodeToBeUpdated, updatedChildNode);
}
// if the Node is an @ObjectNode
} else if (valueToBeUpdated != null && valueToBeUpdated.isObject()) {
merge(valueToBeUpdated, updatedValue);
} else {
if (mainNode instanceof ObjectNode) {
((ObjectNode) mainNode).replace(updatedFieldName, updatedValue);
}
}
}
return mainNode;
}
下面是 Scala 中的实现。源节点和目标节点大多是可交换的，除非源节点和目标节点都存在分支。
def mergeYamlObjects(source: ObjectNode, target: ObjectNode, overwrite: Boolean = true): ObjectNode = {
if (target == null)
source
else if (source == null)
target
else {
val result = source.deepCopy
val fieldlist = source.fieldNames.asScala.toList ++ target.fieldNames.asScala.toList
for (item <- fieldlist) {
if (!(source has item)) {
result put(item, target get item)
} else {
if ((source get item).isValueNode) {
if (target has item)
if (overwrite)
result.put(item, target get item)
} else {
result.put(item, mergeYamlObjects(source.get(item).asInstanceOf[ObjectNode],
target.get(item).asInstanceOf[ObjectNode], overwrite = overwrite))
}
}
}
result
}
}
如果有人只是想将两个或多个 JsonNode 对象添加到一个 JsonNode 中，这可能是一种方法：
ArrayNode arrayNode = objectMapper.createArrayNode();
arrayNode.add(firstJsonNode);
arrayNode.add(secondJsonNode);
arrayNode.add(thirdJsonNode);
JsonNode root = JsonNodeFactory.instance.objectNode();
((ObjectNode) root).put("", arrayNode);
System.out.println("merged array node #: " + root);
这里，是将两棵 JSON 树合并为一棵的完整实现。希望它会有所帮助:)
/**
* Merge two JSON tree into one i.e mergedInTo.
*
* @param toBeMerged
* @param mergedInTo
*/
public static void merge(JsonNode toBeMerged, JsonNode mergedInTo) {
Iterator<Map.Entry<String, JsonNode>> incomingFieldsIterator = toBeMerged.fields();
Iterator<Map.Entry<String, JsonNode>> mergedIterator = mergedInTo.fields();
while (incomingFieldsIterator.hasNext()) {
Map.Entry<String, JsonNode> incomingEntry = incomingFieldsIterator.next();
JsonNode subNode = incomingEntry.getValue();
if (subNode.getNodeType().equals(JsonNodeType.OBJECT)) {
boolean isNewBlock = true;
mergedIterator = mergedInTo.fields();
while (mergedIterator.hasNext()) {
Map.Entry<String, JsonNode> entry = mergedIterator.next();
if (entry.getKey().equals(incomingEntry.getKey())) {
merge(incomingEntry.getValue(), entry.getValue());
isNewBlock = false;
}
}
if (isNewBlock) {
((ObjectNode) mergedInTo).replace(incomingEntry.getKey(), incomingEntry.getValue());
}
} else if (subNode.getNodeType().equals(JsonNodeType.ARRAY)) {
boolean newEntry = true;
mergedIterator = mergedInTo.fields();
while (mergedIterator.hasNext()) {
Map.Entry<String, JsonNode> entry = mergedIterator.next();
if (entry.getKey().equals(incomingEntry.getKey())) {
updateArray(incomingEntry.getValue(), entry);
newEntry = false;
}
}
if (newEntry) {
((ObjectNode) mergedInTo).replace(incomingEntry.getKey(), incomingEntry.getValue());
}
}
ValueNode valueNode = null;
JsonNode incomingValueNode = incomingEntry.getValue();
switch (subNode.getNodeType()) {
case STRING:
valueNode = new TextNode(incomingValueNode.textValue());
break;
case NUMBER:
valueNode = new IntNode(incomingValueNode.intValue());
break;
case BOOLEAN:
valueNode = BooleanNode.valueOf(incomingValueNode.booleanValue());
}
if (valueNode != null) {
updateObject(mergedInTo, valueNode, incomingEntry);
}
}
}
private static void updateArray(JsonNode valueToBePlaced, Map.Entry<String, JsonNode> toBeMerged) {
toBeMerged.setValue(valueToBePlaced);
}
private static void updateObject(JsonNode mergeInTo, ValueNode valueToBePlaced,
Map.Entry<String, JsonNode> toBeMerged) {
boolean newEntry = true;
Iterator<Map.Entry<String, JsonNode>> mergedIterator = mergeInTo.fields();
while (mergedIterator.hasNext()) {
Map.Entry<String, JsonNode> entry = mergedIterator.next();
if (entry.getKey().equals(toBeMerged.getKey())) {
newEntry = false;
entry.setValue(valueToBePlaced);
}
}
if (newEntry) {
((ObjectNode) mergeInTo).replace(toBeMerged.getKey(), toBeMerged.getValue());
}
}
将 json -> json 与 ObjectMapper 合并：
@SneakyThrows
public static String mergeToPretty(String baseJson, String overrideJson) {
ObjectMapper objectMapper = new ObjectMapper();
Object base = objectMapper.readValue(baseJson, Object.class);
Object merged = objectMapper.readerForUpdating(base).readValue(overrideJson);
return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(merged);
}
备注：
，
@SneakyThrows 可以替换为异常处理。.writerWithDefaultPrettyPrinter()如果您的目标是连接两个 JSON，我发现的最简单的方法如下（考虑到您已准备好两个 ObjecNode）：
ObjectMapper mapper = new ObjectMapper();
// Dummy objects to concatenate
Map<String, Object> map = new HashMap();
map.put("k", "v");
Map<String, Object> secondMap = new HashMap();
secondMap.put("secondK", "secondV");
//Transforming Objects into ObjectNode
ObjectNode firstObjectNode = mapper.convertValue(map, ObjectNode.class);
ObjectNode secondObjectNode = mapper.convertValue(secondMap, ObjectNode.class);
//Concatenating secondObjectNode into firstObjectNode
firstObjectNode.setAll(secondObjectNode);
//Output will be: {"k":"v","secondK":"secondV"}
System.out.println(firstObjectNode);
希望有帮助
private String merge(FirstObject firstObject, SecondObject secondObject) throws JsonProcessingException {
JsonNode firstNode = objectMapper.valueToTree(firstObject);
JsonNode secondNode = objectMapper.valueToTree(secondObject);
((ObjectNode) firstNode).setAll((ObjectNode) secondNode);
return objectMapper.writeValueAsString(firstNode);
}
public static void main(String[] args) {
FirstObject firstObject = new FirstObject();
firstObject.setFirstValue("first");
SecondObject secondObject = new SecondObject();
secondObject.setSecondValue("second");
System.out.println(merge(firstObject, secondObject)); // {"firstValue":"first","secondValue":"second"}
}