用javax.json.jsonObject“深度替换”

Question

{
   "Attr1":number1,
   "Attr2":number2,
   "Attr3":number3,
   "Attr4":[
      "string1"
   ],
   "Attr5":[
      {
         "Attr6":[
            {
               "Attr7":"string2",
               "Attr8":"string3",
               "$Attr9":number4
            },
            {
               "Attr7":"string4",
               "Attr8":"string5",
               "Attr9":number5
            }
         ],
         "Attr10":number6,
         "Attr14":{
            "Attr10":"string6",
            "Attr11":"string7",
            "Attr12":"string8"
         },
         "Attr13":[
            "string9",
            "string10"
         ],
         "Attr14":"string11"
      }
   ]
}

"Attr6":["newString1","newString2"],

public static JsonObject replaceValue( final JsonObject jsonObject, final String jsonKey, final JsonValue jsonValue )
{
  JsonObjectBuilder builder = Json.createObjectBuilder();

  if(jsonObject == null)
  {
    return builder.build();
  }

  Iterator<Entry<String, JsonValue>> it = jsonObject.entrySet().iterator();

  while (it.hasNext())
  {
    @SuppressWarnings( "rawtypes" )
    JsonObject.Entry mapEntry = it.next();

    if (mapEntry.getKey() == jsonKey)
    {
      builder.add(jsonKey, jsonValue);
    }
    else if (ValueType.STRING.equals(((JsonValue) mapEntry.getValue()).getValueType()) || ValueType.NUMBER.equals(((JsonValue) mapEntry.getValue()).getValueType()) || ValueType.TRUE.equals(((JsonValue) mapEntry.getValue()).getValueType()) ||
        ValueType.FALSE.equals(((JsonValue) mapEntry.getValue()).getValueType()) || (JsonValue) mapEntry.getValue() == null || "schemas".equalsIgnoreCase((String) mapEntry.getKey()))
    {
      builder.add(mapEntry.getKey().toString(), (JsonValue) mapEntry.getValue());
    }
    else if (ValueType.OBJECT.equals(((JsonValue) mapEntry.getValue()).getValueType()))
    {
      JsonObject modifiedJsonobject = (JsonObject) mapEntry.getValue();
      if (modifiedJsonobject != null)
      {
        replaceValue(modifiedJsonobject, jsonKey, jsonValue);
      }
    }
    else if (ValueType.ARRAY.equals(((JsonValue) mapEntry.getValue()).getValueType()))
    {
      for (int i = 0; i < ((JsonValue) mapEntry.getValue()).asJsonArray().size(); i++)
      {
        replaceValue((JsonObject) ((JsonValue) mapEntry.getValue()).asJsonArray().get(i), jsonKey, jsonValue);
      }
    }
  }

  return builder.build();
}

Answer 1

这是解决这个问题的另一种方法，它使用javax.json.stream.jsonParser提供的流解析器。这将从JSON源代码生成一个令牌流，其中包含javax.JSON.stream.jsonparser.event值，这些值描述令牌的类型（例如start_object、key_name等）。

对我们来说最重要的是，解析器上有skipobject()和skiparray()方法，它们允许我们删除源JSON中不需要的部分。

总体方法是构建一个新版本的JSON，逐个令牌，作为一个字符串，当我们到达JSON中的相关位置（或多个位置）时，替换替换部分。

最后，我们将新字符串转换回一个对象，这样我们就可以漂亮地打印它了。

这种方法中不使用递归。

java prettyprint-override">import java.io.IOException;
import javax.json.Json;
import javax.json.stream.JsonParser;
import javax.json.stream.JsonParser.Event;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.HashMap;
import java.util.Map;
import javax.json.JsonObject;
import javax.json.JsonWriterFactory;
import javax.json.stream.JsonGenerator;

public class StreamDemo {

    public static void doStream() throws IOException {
        JsonParser jsonParser = Json.createParser(new StringReader(JSONSTRING));

        StringBuilder sb = new StringBuilder();
        Event previous = null;

        String targetKeyName = "Attr6";
        String replacement = "[\"newString1\",\"newString2\"]";
        // This event reflects the end of the "replacement" string - namely "]".
        // We need this because this event may be different from the replaced event.
        Event replacementPreviousEvent = Event.END_ARRAY;

        // Used when we find the target key for replacement:
        boolean doReplacement = false;

        while (jsonParser.hasNext()) {
            Event event = jsonParser.next();
            if (doReplacement) {
                // Skip over the structure we want to replace:
                if (event.equals(Event.START_OBJECT)) {
                    jsonParser.skipObject();
                } else if (event.equals(Event.START_ARRAY)) {
                    jsonParser.skipArray();
                }
                // Write the replacement fragment here:
                sb.append(replacement);
                // Move to the next event in the stream:
                event = jsonParser.next();
                previous = replacementPreviousEvent;
                doReplacement = false;
            }

            if (Event.KEY_NAME.equals(event)
                    && jsonParser.getString().equals(targetKeyName)) {
                doReplacement = true;
            }

            switch (event) {
                case START_OBJECT:
                    if (Event.END_OBJECT.equals(previous)) {
                        sb.append(",");
                    }
                    sb.append("{");
                    break;
                case END_OBJECT:
                    sb.append("}");
                    break;
                case START_ARRAY:
                    sb.append("[");
                    break;
                case END_ARRAY:
                    sb.append("]");
                    break;
                case KEY_NAME:
                    sb = previousWasAValue(previous, sb);
                    sb = previousWasAnEnd(previous, sb);
                    sb.append("\"").append(jsonParser.getString()).append("\":");
                    break;
                case VALUE_STRING:
                    sb = previousWasAValue(previous, sb);
                    sb.append("\"").append(jsonParser.getString()).append("\"");
                    break;
                case VALUE_NUMBER:
                    sb = previousWasAValue(previous, sb);
                    if (jsonParser.isIntegralNumber()) {
                        sb.append(jsonParser.getLong());
                    } else {
                        sb.append(jsonParser.getBigDecimal().toPlainString());
                    }
                    break;
                case VALUE_TRUE:
                    sb = previousWasAValue(previous, sb);
                    sb.append("true");
                    break;
                case VALUE_FALSE:
                    sb = previousWasAValue(previous, sb);
                    sb.append("false");
                    break;
                case VALUE_NULL:
                    sb = previousWasAValue(previous, sb);
                    sb.append("null");
                    break;
                default:
                    break;
            }
            previous = event;
        }
        
        // At the end, pretty-print the new JSON:
        JsonObject modifiedObject = Json.createReader(new StringReader(sb.toString())).readObject();
        Map<String, Boolean> config = new HashMap<>();
        config.put(JsonGenerator.PRETTY_PRINTING, true);
        String jsonString;
        JsonWriterFactory writerFactory = Json.createWriterFactory(config);
        try ( Writer writer = new StringWriter()) {
            writerFactory.createWriter(writer).write(modifiedObject);
            jsonString = writer.toString();
        }
        System.out.println(jsonString);
    }

    private static StringBuilder previousWasAValue(Event previous, StringBuilder sb) {
        // The current value follows another value - so a separating comma is needed:
        if (Event.VALUE_STRING.equals(previous)
                || Event.VALUE_NUMBER.equals(previous)
                || Event.VALUE_TRUE.equals(previous)
                || Event.VALUE_FALSE.equals(previous)
                || Event.VALUE_NULL.equals(previous)) {
            sb.append(",");
        }
        return sb;
    }

    private static StringBuilder previousWasAnEnd(Event previous, StringBuilder sb) {
        // The current key follows the end of an object or an array, so a 
        // separating comma is needed:
        if (Event.END_OBJECT.equals(previous)
                || Event.END_ARRAY.equals(previous)) {
            sb.append(",");
        }
        return sb;
    }

    private static final String JSONSTRING
            = """
    {
       "Attr0": null,
       "Attr1": true,
       "Attr2": false,
       "Attr3": 3,
       "Attr4": [
               "string1"
       ],
       "Attr5": [{
               "Attr6": [{
                               "Attr7": "string2",
                               "Attr8": "string3",
                               "Attr9": 4
                       },
                       {
                               "Attr7": "string4",
                               "Attr8": "string5",
                               "Attr9": 5
                       }
               ],
               "Attr10": 6,
               "Attr14": {
                       "Attr10": "string6",
                       "Attr11": "string7",
                       "Attr12": "string8"
               },
               "Attr13": [
                       "string9",
                       123.45,
                       false
               ],
               "Attr15": "string11"
       }]
    }
    """;

}