在Java中使用Gson合并/扩展JSON对象

通常，我需要合并两个JSON对象（类似于jQuery的工作方式）。然而，Gson库没有内置的功能，他们说

做一些类似于：

private void merge(JsonObject firstObj, JsonObject secondObj){
    for(String keyInSecondObj : secondObj.entrySet().keySet()) {
      if(!firstObj.has(keyInSecondObj )){
        firstObj.add(secondMap.get(keyInSecondObj));
    }
}

太简单了，因为它不处理递归合并的JSONObject，不处理两个映射中都存在键时的冲突，也不处理非基本值（如数组）的特殊处理

我没有找到任何预构建的解决方案来实现这一点。我更愿意使用经过彻底测试的方法，而不是编写自己的方法，但它必须是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");
            }
        }
    }
}

import com.google.gson.JsonArray；
导入com.google.gson.JsonElement；
导入com.google.gson.JsonObject；
导入java.util.Map；
公共类GsonTools{
公共静态枚举冲突策略{
抛出异常，首选第一个对象，首选第二个对象，首选非空；
}
公共静态类JsonObjectExtensionConflictException扩展异常{
公共JsonObjectExtensionConflictException（字符串消息）{
超级（信息）；
}
}
公共静态无效扩展对象（JsonObject destinationObject、冲突策略冲突解决策略、JsonObject…objs）
抛出JsonObjectExtensionConflictException{
for（JsonObject对象：objs）{
扩展对象（目标对象、目标、冲突解决策略）；
}
}
私有静态无效扩展JsonObject（JsonObject leftObj、JsonObject rightObj、ConflictStrategy ConflictStrategy）
抛出JsonObjectExtensionConflictException{
对于（Map.Entry rightEntry:rightObj.entrySet（））{
字符串rightKey=rightEntry.getKey（）；
JsonElement rightVal=rightEntry.getValue（）；
if（leftObj.has（rightKey））{
//冲突
jsoneleftval=leftObj.get（rightKey）；
if（leftVal.isJsonArray（）&&righval.isJsonArray（））{
JsonArray leftArr=leftVal.getAsJsonArray（）；
JsonArray rightArr=rightVal.getAsJsonArray（）；
//concat数组——数组中不可能有冲突，它只是一组内容
对于（int i=0；i

您可以使用

  Map firstObject = new GSON().fromJson(json1, HashMap.class);
  Map secondObject = new GSON().fromJson(json2, HashMap.class);

//根据需要合并Map firstObject和secondObject，请参见

---

您可以将一个jsonobject强制转换为jsonaray（您可以检查 )然后，您可以向另一个jsonobject添加新的jsonarray，或者将两个jsonobject都转换为jsonarray，然后创建一个新的jsonobject

jsonObject.add("property", jsonarray);

---

下面的库类允许数组和对象的深度合并。它们应用了所描述的策略，但是可以通过在方法中间改变简单操作来采用自己的策略。 合并（覆盖或添加）的“覆盖”策略：

• 基本类型字段被覆盖
• 组合具有相等声明键的对象
• 如果对象内容相等，则组合没有声明键的对象
• 其他对象被覆盖或添加
• 组合数组：在同一数组中添加重复项，直到两个数组中的重复项数量相等

用法（

String

或Gson

JsonObject

/

JsonArray

可以返回）：

//直接对象合并：
Json.mergeObjects（
“{my_object_as_string}”，
“{my_other_object_as_string}”）；
//合并“我的对象”数组并设置对象标识键：
HashMap keyCombinations=新的HashMap（）；
关键字组合(
“对象”，
新字符串[]{“object\u identity\u key\u one”，“object\u identity\u k”
jsonObject.add("property", 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;
  }

}