[英]Merge/Extend JSON Objects using Gson in Java
通常,我需要合並兩個JSON對象(類似於jQuery的$.extend()
工作方式)。 但是,Gson庫沒有內置功能,他們說他們不會實現它 。
做類似的事情:
private void merge(JsonObject firstObj, JsonObject secondObj){
for(String keyInSecondObj : secondObj.entrySet().keySet()) {
if(!firstObj.has(keyInSecondObj )){
firstObj.add(secondMap.get(keyInSecondObj));
}
}
太簡單了,因為它不處理遞歸合並JsonObjects,當兩個映射中都存在鍵時不處理沖突,並且沒有對非原始值(如Arrays)進行特殊處理。
我沒有找到任何預先構建的解決方案來做到這一點。 我更喜歡使用已經過徹底測試的東西,而不是編寫我自己的方法,但它必須是Gson (不是Jackson或其他)。
編輯:我最后編寫了我自己的實現,因為已添加作為這個問題的答案
這個問題 不重復,因為它沒有使用Gson(或Java)。
這是我第一次嘗試編寫自己的靜態合並方法。 隨意戳它的洞。
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import java.util.Map;
public class GsonTools {
public static enum ConflictStrategy {
THROW_EXCEPTION, PREFER_FIRST_OBJ, PREFER_SECOND_OBJ, PREFER_NON_NULL;
}
public static class JsonObjectExtensionConflictException extends Exception {
public JsonObjectExtensionConflictException(String message) {
super(message);
}
}
public static void extendJsonObject(JsonObject destinationObject, ConflictStrategy conflictResolutionStrategy, JsonObject ... objs)
throws JsonObjectExtensionConflictException {
for (JsonObject obj : objs) {
extendJsonObject(destinationObject, obj, conflictResolutionStrategy);
}
}
private static void extendJsonObject(JsonObject leftObj, JsonObject rightObj, ConflictStrategy conflictStrategy)
throws JsonObjectExtensionConflictException {
for (Map.Entry<String, JsonElement> rightEntry : rightObj.entrySet()) {
String rightKey = rightEntry.getKey();
JsonElement rightVal = rightEntry.getValue();
if (leftObj.has(rightKey)) {
//conflict
JsonElement leftVal = leftObj.get(rightKey);
if (leftVal.isJsonArray() && rightVal.isJsonArray()) {
JsonArray leftArr = leftVal.getAsJsonArray();
JsonArray rightArr = rightVal.getAsJsonArray();
//concat the arrays -- there cannot be a conflict in an array, it's just a collection of stuff
for (int i = 0; i < rightArr.size(); i++) {
leftArr.add(rightArr.get(i));
}
} else if (leftVal.isJsonObject() && rightVal.isJsonObject()) {
//recursive merging
extendJsonObject(leftVal.getAsJsonObject(), rightVal.getAsJsonObject(), conflictStrategy);
} else {//not both arrays or objects, normal merge with conflict resolution
handleMergeConflict(rightKey, leftObj, leftVal, rightVal, conflictStrategy);
}
} else {//no conflict, add to the object
leftObj.add(rightKey, rightVal);
}
}
}
private static void handleMergeConflict(String key, JsonObject leftObj, JsonElement leftVal, JsonElement rightVal, ConflictStrategy conflictStrategy)
throws JsonObjectExtensionConflictException {
{
switch (conflictStrategy) {
case PREFER_FIRST_OBJ:
break;//do nothing, the right val gets thrown out
case PREFER_SECOND_OBJ:
leftObj.add(key, rightVal);//right side auto-wins, replace left val with its val
break;
case PREFER_NON_NULL:
//check if right side is not null, and left side is null, in which case we use the right val
if (leftVal.isJsonNull() && !rightVal.isJsonNull()) {
leftObj.add(key, rightVal);
}//else do nothing since either the left value is non-null or the right value is null
break;
case THROW_EXCEPTION:
throw new JsonObjectExtensionConflictException("Key " + key + " exists in both objects and the conflict resolution strategy is " + conflictStrategy);
default:
throw new UnsupportedOperationException("The conflict strategy " + conflictStrategy + " is unknown and cannot be processed");
}
}
}
}
您可以使用
Map firstObject = new GSON().fromJson(json1, HashMap.class);
Map secondObject = new GSON().fromJson(json2, HashMap.class);
//根據需要合並Map firstObject和secondObject,請參閱此文章
String resultJson = new GSON().toJson(resultMap);
您可以將一個jsonobject轉換為jsonaray,(您可以在這里查看 )然后您可以將新的jsonarray添加到其他jsonobject或將兩個jsonobject轉換為jsonarray,然后創建一個新的jsonobject。
jsonObject.add("property", jsonarray);
下面的庫類允許深度合並數組和對象。 他們應用所描述的策略,但您可以通過在方法中間更改簡單操作來采用自己的策略。
合並(覆蓋或添加)的“疊加”策略:
用法(可以返回String
或Gson JsonObject
/ JsonArray
):
// Straightforward object merging:
Json.mergeObjects(
"{my_object_as_string}",
"{my_other_object_as_string}");
// Merge "my_objects" arrays and set object identity keys:
HashMap<String, String[]> keyCombinations = new HashMap<>();
keyCombinations.put(
"objects",
new String[] {"object_identity_key_one", "object_identity_key_two"});
Json.mergeArrays(
"my_objects",
keyCombinations,
"[my_array_as_string]",
"[my_other_array_as_string]"));
圖書館類:
package com.example.utils;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import java.util.ArrayList;
import java.util.HashMap;
import io.reactivex.annotations.NonNull;
@SuppressWarnings("unused")
public class Json {
/**
* Merge given JSON-objects. Same keys are merged for objects and
* overwritten by last object for primitive types.
*
* @param keyCombinations Key names for unique object identification.
* Or empty collection.
* @param objects Any amount of JSON-objects to merge.
*
* @return Merged JSON-object.
*/
public static JsonObject mergeObjects(
@NonNull
HashMap<String, String[]> keyCombinations,
Object... objects) {
JsonObject mergedObject = new JsonObject();
for (Object object : objects) {
JsonObject jsonObject = (JsonObject) object;
for (String key : jsonObject.keySet()) {
JsonElement parameter = jsonObject.get(key);
if (mergedObject.has(key)) {
// Key name matches:
if (jsonObject.get(key).isJsonObject()) {
// This is object - merge:
parameter =
mergeObjects(
keyCombinations,
mergedObject.get(key).getAsJsonObject(),
jsonObject.get(key).getAsJsonObject());
} else if (jsonObject.get(key).isJsonArray()) {
// This is array - merge:
parameter =
mergeArrays(
key,
keyCombinations,
mergedObject.get(key).getAsJsonArray(),
jsonObject.get(key).getAsJsonArray());
} else {
// This is neither object nor array - replace value:
mergedObject.add(key, parameter);
}
}
// No such field yet - add:
mergedObject.add(key, parameter);
}
}
return mergedObject;
}
/**
* Alternative - no object identity keys are set.
* See {@link Json#mergeObjects(HashMap, Object...)}
*/
public static JsonObject mergeObjects(
Object... objects) {
return (
mergeObjects(
new HashMap<>(),
objects));
}
/**
* Get GSON-object from string.
*
* @param jsonString JSON-object as string.
*
* @return JsonObject (GSON).
*/
public static JsonObject getJsonObject(String jsonString) {
JsonObject jsonObject = new JsonObject();
JsonParser parser;
parser = new JsonParser();
if (jsonString != null) {
jsonObject =
parser
.parse(
jsonString)
.getAsJsonObject();
}
return jsonObject;
}
/**
* See {@link Json#mergeObjects(HashMap, Object...)}
*/
public static String mergeObjects(
HashMap<String, String[]> keyCombinations,
String... jsonObjects) {
ArrayList<JsonObject> objects = new ArrayList<>();
for (String jsonObject : jsonObjects) {
objects.add(
Json2.getJsonObject(jsonObject));
}
return (
mergeObjects(
keyCombinations,
objects.toArray())
.toString());
}
/**
* Alternative - no object identity keys are set.
* See {@link Json#mergeObjects(HashMap, Object...)}
*/
public static String mergeObjects(
String... jsonObjects) {
ArrayList<JsonObject> objects = new ArrayList<>();
for (String jsonObject : jsonObjects) {
objects.add(
getJsonObject(jsonObject));
}
return (
mergeObjects(
new HashMap<>(),
objects.toArray())
.toString());
}
/**
* See {@link Json#mergeArrays(String, HashMap, Object...)}
*/
public static String mergeArrays(
String arrayName,
HashMap<String, String[]> keyCombinations,
String... jsonArrays) {
ArrayList<JsonArray> arrays = new ArrayList<>();
for (String jsonArray : jsonArrays) {
arrays.add(
getJsonArray(jsonArray));
}
return (
mergeArrays(
arrayName,
keyCombinations,
arrays.toArray())
.toString());
}
/**
* Alternative - no object identity keys are set.
* See {@link Json#mergeArrays(String, HashMap, Object...)}
*/
public static String mergeArrays(
String... jsonArrays) {
ArrayList<JsonArray> arrays = new ArrayList<>();
for (String jsonArray : jsonArrays) {
arrays.add(
getJsonArray(jsonArray));
}
return (
mergeArrays(
"",
new HashMap<>(),
arrays.toArray())
.toString());
}
/**
* Alternative - no object identity keys are set.
* Seee {@link Json#mergeArrays(String, HashMap, Object...)}
*/
public static JsonArray mergeArrays(
Object... jsonArrays) {
return (
mergeArrays(
"",
new HashMap<>(),
jsonArrays));
}
/**
* Merge arrays following "Overlay" strategy (overwrite or add).
* Duplicate elements are added to array until their amount is equal
* in both arrays. Objects are considered identical if their
* identifier-keys are present and their values are equal. If no such
* keys, then objects are considered identical on equal content.
*
* @param arrayName Merged arrays name or empty string.
* Used to choose from key combinations.
* @param keyCombinations Array objects identifier-key names.
* @param jsonArrays Any amount of JSON-arrays to merge.
*
* @return Merged array.
*/
public static JsonArray mergeArrays(
@NonNull
String arrayName,
@NonNull
HashMap<String, String[]> keyCombinations,
Object... jsonArrays) {
JsonArray resultArray = new JsonArray();
for (Object jsonArray : jsonArrays) {
JsonArray array = (JsonArray) jsonArray;
for (JsonElement item : array) {
if (
item.isJsonObject() &&
keyCombinations.get(arrayName) != null &&
keyCombinations.get(arrayName).length > 0) {
// Array element is an object with identifier-keys:
ArrayList<JsonElement> resultArrayObjectsFound =
getArrayObjectsByKeyValues(
resultArray,
item.getAsJsonObject(),
keyCombinations.get(arrayName));
if (resultArrayObjectsFound.size() > 0) {
// Such field is already present, merge is required:
JsonObject resultArrayObjectFound =
resultArrayObjectsFound.get(0).getAsJsonObject();
JsonObject mergedObject =
mergeObjects(
keyCombinations,
resultArrayObjectFound,
item.getAsJsonObject());
resultArray.remove(resultArrayObjectFound);
resultArray.add(mergedObject);
continue;
}
}
if (!resultArray.contains(item)) {
// No such element - add:
resultArray.add(item);
} else if (
count(resultArray, item) < count(array, item)) {
// There are more duplicates of the element - add:
resultArray.add(item);
}
}
}
return resultArray;
}
/**
* Convert String to JSON-Array (GSON).
*
* @param jsonString JSON-array as string.
*
* @return JSON-array as GSON-array.
*/
public static JsonArray getJsonArray(String jsonString) {
JsonArray jsonArray = new JsonArray();
JsonParser parser;
parser = new JsonParser();
try {
jsonArray =
parser
.parse(
jsonString)
.getAsJsonArray();
} catch (Exception ignore) {
}
return jsonArray;
}
/**
* Find array objects that have required identity keys and match the values.
*
* @param array Array to search in.
* @param object Example object for search.
* Contains required keys and values.
* @param keys Object identity keys.
*
* @return Matching JSON-elements.
*/
public static ArrayList<JsonElement> getArrayObjectsByKeyValues(
JsonArray array,
JsonObject object,
String[] keys) {
ArrayList<JsonElement> elements = new ArrayList<>();
for (JsonElement arrayElement : array) {
if (arrayElement.isJsonObject()) {
JsonObject jsonObject = arrayElement.getAsJsonObject();
boolean hasAllKeysThatMatch = true;
for (String key : keys) {
if (!jsonObject.has(key)) {
// One of the keys is not found:
hasAllKeysThatMatch = false;
break;
} else {
if (
jsonObject.get(key).isJsonPrimitive() &&
!jsonObject.get(key).equals(object.get(key))) {
// Primitive type key values don't match:
hasAllKeysThatMatch = false;
break;
}
if ((
jsonObject.get(key).isJsonObject() ||
jsonObject.get(key).isJsonArray()) &&
!jsonObject.get(key).toString().equals(
object.get(key).toString())) {
// Complex type key values don't match:
hasAllKeysThatMatch = false;
break;
}
}
}
if (hasAllKeysThatMatch) {
// Key values match:
elements.add(jsonObject);
}
}
}
return elements;
}
/**
* Count given elements in array.
*
* @param element Element to find.
*
* @return Amount of given elements in array.
*/
public static int count(
JsonArray array,
JsonElement element) {
int count = 0;
for (JsonElement currentElement : array) {
if (currentElement.isJsonPrimitive()) {
// Primitive type:
if (currentElement.equals(element)) {
count++;
}
}
if (
currentElement.isJsonObject() ||
currentElement.isJsonArray()) {
// Complex type:
if (currentElement.toString().equals(element.toString())) {
count++;
}
}
}
return count;
}
}
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.