如何比较JSON文档并返回与Jackson或Gson的差异？ [英] How to compare JSON documents and return the differences with Jackson or Gson?
问题描述
我使用spring-boot来开发后端服务。有一种方案可以比较2-beans（一个是DB对象，另一个是客户端请求的对象）并返回new element，modified element，如果没有更改，则返回false。 2豆的格式如下
I am using spring-boot to develop backend services. There is a scenario to compare 2-beans(one is the DB object and another one is the client requested object) and return the "new element","modified element" and if there is no change then return false. The 2-beans are in a below format
"sampleList":{
"timeStamp":"Thu, 21 Jun 2018 07:57:00 +0000",
"id":"5b19441ac9e77c000189b991",
"sampleListTypeId":"type001",
"friendlyName":"sample",
"contacts":[
{
"id":"5b05329cc9e77c000189b950",
"priorityOrder":1,
"name":"sample1",
"relation":"Friend",
"sampleInfo":{
"countryCode":"91",
"numberType":"MOBILE",
"numberRegion":"IN"
}
},
{
"id":"5b05329cc9e77c000189b950",
"priorityOrder":1,
"name":"sample2",
"relation":"Friend",
"sampleInfo":{
"countryCode":"91",
"numberType":"MOBILE",
"numberRegion":"IN"
}
}
]
}
我在java浏览过互联网关于这种情况的bean比较，但我找不到更简单的东西解决方案但找到了一些很酷的JSON解决方案。我可以看到GSON的一些解决方案，但它不会返回客户端对象包含新元素和更改元素。有没有办法在JSON或JAVA中返回更新和修改过的元素？你的帮助应该是值得的。即使是暗示对我来说也是一个很好的开始。
I have browsed internet about bean comparison for this scenario in java but I couldn't find any simpler solution but found some cool solution for JSON. I can see some solution for GSON but it will not return the client object contains "new element" and the "changes element". Is there any way to return the newer and modified element in JSON or JAVA? Your help should be appreciable. Even a hint will be a great start for me.
推荐答案
将JSON文档读取为 Map s并比较它们
您可以将这两个JSON文档读作 Map< K，V> 。请参阅下面的Jackson和Gson示例：
Reading the JSON documents as Maps and comparing them
You could read both JSON documents as Map<K, V>. See the below examples for Jackson and Gson:
ObjectMapper mapper = new ObjectMapper();
TypeReference<HashMap<String, Object>> type =
new TypeReference<HashMap<String, Object>>() {};
Map<String, Object> leftMap = mapper.readValue(leftJson, type);
Map<String, Object> rightMap = mapper.readValue(rightJson, type);
Gson gson = new Gson();
Type type = new TypeToken<Map<String, Object>>(){}.getType();
Map<String, Object> leftMap = gson.fromJson(leftJson, type);
Map<String, Object> rightMap = gson.fromJson(rightJson, type);
然后使用Guava的 Maps.difference （地图< K，V>，地图< K，V>） 来比较它们。它返回 MapDifference< K，V> 实例：
Then use Guava's Maps.difference(Map<K, V>, Map<K, V>) to compare them. It returns a MapDifference<K, V> instance:
MapDifference<String, Object> difference = Maps.difference(left, right);
如果您对结果不满意，可以考虑展平地图，然后比较它们。它将提供更好的比较结果，尤其是对于嵌套对象和数组。
If you are not happy with the result, you can consider flattening the maps and then compare them. It will provide better comparison results especially for nested objects and arrays.
要平整地图，您可以使用：
To flat the map, you can use:
public final class FlatMapUtil {
private FlatMapUtil() {
throw new AssertionError("No instances for you!");
}
public static Map<String, Object> flatten(Map<String, Object> map) {
return map.entrySet().stream()
.flatMap(FlatMapUtil::flatten)
.collect(LinkedHashMap::new, (m, e) -> m.put("/" + e.getKey(), e.getValue()), LinkedHashMap::putAll);
}
private static Stream<Map.Entry<String, Object>> flatten(Map.Entry<String, Object> entry) {
if (entry == null) {
return Stream.empty();
}
if (entry.getValue() instanceof Map<?, ?>) {
return ((Map<?, ?>) entry.getValue()).entrySet().stream()
.flatMap(e -> flatten(new AbstractMap.SimpleEntry<>(entry.getKey() + "/" + e.getKey(), e.getValue())));
}
if (entry.getValue() instanceof List<?>) {
List<?> list = (List<?>) entry.getValue();
return IntStream.range(0, list.size())
.mapToObj(i -> new AbstractMap.SimpleEntry<String, Object>(entry.getKey() + "/" + i, list.get(i)))
.flatMap(FlatMapUtil::flatten);
}
return Stream.of(entry);
}
}
它使用 JSON指针表示法在 RFC 6901 中为密钥定义，因此您可以轻松找到值。
It uses the JSON Pointer notation defined in the RFC 6901 for the keys, so you can easily locate the values.
考虑以下JSON文档：
Consider the following JSON documents:
{
"name": {
"first": "John",
"last": "Doe"
},
"address": null,
"birthday": "1980-01-01",
"company": "Acme",
"occupation": "Software engineer",
"phones": [
{
"number": "000000000",
"type": "home"
},
{
"number": "999999999",
"type": "mobile"
}
]
}
{
"name": {
"first": "Jane",
"last": "Doe",
"nickname": "Jenny"
},
"birthday": "1990-01-01",
"occupation": null,
"phones": [
{
"number": "111111111",
"type": "mobile"
}
],
"favorite": true,
"groups": [
"close-friends",
"gym"
]
}
以下代码进行比较它们并显示差异：
And the following code to compare them and show the differences:
Map<String, Object> leftFlatMap = FlatMapUtil.flatten(leftMap);
Map<String, Object> rightFlatMap = FlatMapUtil.flatten(rightMap);
MapDifference<String, Object> difference = Maps.difference(leftFlatMap, rightFlatMap);
System.out.println("Entries only on the left\n--------------------------");
difference.entriesOnlyOnLeft()
.forEach((key, value) -> System.out.println(key + ": " + value));
System.out.println("\n\nEntries only on the right\n--------------------------");
difference.entriesOnlyOnRight()
.forEach((key, value) -> System.out.println(key + ": " + value));
System.out.println("\n\nEntries differing\n--------------------------");
difference.entriesDiffering()
.forEach((key, value) -> System.out.println(key + ": " + value));
它将产生以下输出：
Entries only on the left
--------------------------
/address: null
/phones/1/number: 999999999
/phones/1/type: mobile
/company: Acme
Entries only on the right
--------------------------
/name/nickname: Jenny
/groups/0: close-friends
/groups/1: gym
/favorite: true
Entries differing
--------------------------
/birthday: (1980-01-01, 1990-01-01)
/occupation: (Software engineer, null)
/name/first: (John, Jane)
/phones/0/number: (000000000, 111111111)
/phones/0/type: (home, mobile)
这篇关于如何比较JSON文档并返回与Jackson或Gson的差异？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
