com.google.gson.JsonParser#parseString ( )源码实例Demo

private static String extractFieldUnderEvent(String json, String fieldName) {
    try {
        JsonElement root = JsonParser.parseString(json);
        if (root != null && root.isJsonObject() && root.getAsJsonObject().has("event")) {
            JsonElement event = root.getAsJsonObject().get("event");
            if (event.isJsonObject() && event.getAsJsonObject().has(fieldName)) {
                JsonElement eventType = event.getAsJsonObject().get(fieldName);
                if (eventType.isJsonPrimitive()) {
                    return eventType.getAsString();
                }
            }
        }
    } catch (JsonSyntaxException e) {
        log.debug("Failed to parse {} as a JSON data", json, e);
    }
    return "";
}
 

public void testObject() throws IOException {
  JsonElement element = JsonParser.parseString("{\"A\": 1, \"B\": 2}");
  JsonTreeReader reader = new JsonTreeReader(element);
  assertEquals(JsonToken.BEGIN_OBJECT, reader.peek());
  reader.beginObject();
  assertEquals(JsonToken.NAME, reader.peek());
  assertEquals("A", reader.nextName());
  assertEquals(JsonToken.NUMBER, reader.peek());
  assertEquals(1, reader.nextInt());
  assertEquals(JsonToken.NAME, reader.peek());
  assertEquals("B", reader.nextName());
  assertEquals(JsonToken.NUMBER, reader.peek());
  assertEquals(2, reader.nextInt());
  assertEquals(JsonToken.END_OBJECT, reader.peek());
  reader.endObject();
  assertEquals(JsonToken.END_DOCUMENT, reader.peek());
}
 

public int createPullReq(GHRepository origRepo, String branch,
                                 GHRepository forkRepo, String title, String body) throws InterruptedException {
        log.info("Creating Pull Request on {} from {}...", origRepo.getFullName(), forkRepo.getFullName());
        //TODO: if no commits, pull request will fail, but this doesn't handle that.
        try {
            GHPullRequest pullRequest = origRepo.createPullRequest(title, forkRepo.getOwnerName() + ":" + branch,
                    origRepo.getDefaultBranch(), body);
//            origRepo.createPullRequest("Update base image in Dockerfile", forkRepo.getOwnerName() + ":" + branch,
//                    origRepo.getDefaultBranch(), "Automatic Dockerfile Image Updater. Please merge.");
            log.info("A pull request has been created at {}", pullRequest.getHtmlUrl());
            return 0;
        } catch (IOException e) {
            log.warn("Handling error with pull request creation... {}", e.getMessage());
            JsonElement root = JsonParser.parseString(e.getMessage());
            JsonArray errorJson = root.getAsJsonObject().get("errors").getAsJsonArray();
            String error = errorJson.get(0).getAsJsonObject().get("message").getAsString();
            log.info("error: {}", error);
            if (error.startsWith("A pull request already exists")) {
                log.info("NOTE: {} New commits may have been added to the pull request.", error);
                return 0;
            } else if (error.startsWith("No commits between")) {
                log.warn("NOTE: {} Pull request was not created.", error);
                return 1;
            } else {
                // TODO: THIS WILL LOOP FOREVVEEEEEERRRR
                log.warn("An error occurred in pull request: {} Trying again...", error);
                waitFor(TimeUnit.SECONDS.toMillis(3));
                return -1;
            }
        }
    }
 

@Test(dataProvider = "inputStores")
public void testGetAndModifyJsonString(String storeContent, String image, String tag, String expectedOutput) throws Exception {
    GitHubUtil gitHubUtil = mock(GitHubUtil.class);
    JsonElement json = JsonParser.parseString(storeContent);

    String output = new GitHubJsonStore(gitHubUtil, "test").getAndModifyJsonString(json, image, tag);
    assertEquals(output, expectedOutput);
}
 

public void testEarlyClose() throws IOException {
  JsonElement element = JsonParser.parseString("[1, 2, 3]");
  JsonTreeReader reader = new JsonTreeReader(element);
  reader.beginArray();
  reader.close();
  try {
    reader.peek();
    fail();
  } catch (IllegalStateException expected) {
  }
}
 

@Override
public void accept(State state) {
    SlackConfig config = state.getConfig();
    String body = state.getParsedResponseBody();
    if (config.isPrettyResponseLoggingEnabled() && body != null && body.trim().startsWith("{")) {
        JsonElement jsonObj = JsonParser.parseString(body);
        String prettifiedJson = GsonFactory.createSnakeCase(config).toJson(jsonObj);

        JSON_RESPONSE_LOGGER.debug("--- Pretty printing the response ---\n" +
                prettifiedJson + "\n" +
                "-----------------------------------------");
    }
}
 

public static boolean isValid(String json) {
    try {
        JsonParser.parseString(json);
        return true;
    } catch (JsonSyntaxException jse) {
        return false;
    }
}
 

public void testMapNamePromotionWithJsonElementReader() {
  String json = "{'2.3':'a'}";
  Map<Double, String> map = new LinkedHashMap<Double, String>();
  map.put(2.3, "a");
  JsonElement tree = JsonParser.parseString(json);
  assertEquals(map, gson.fromJson(tree, new TypeToken<Map<Double, String>>() {}.getType()));
}
 

public void testNestedArrays() throws IOException {
  JsonElement element = JsonParser.parseString("[[],[[]]]");
  JsonTreeReader reader = new JsonTreeReader(element);
  reader.beginArray();
  reader.beginArray();
  reader.endArray();
  reader.beginArray();
  reader.beginArray();
  reader.endArray();
  reader.endArray();
  reader.endArray();
}
 

public void testNumbersFromStrings() throws IOException {
  JsonElement element = JsonParser.parseString("[\"1\", \"2\", \"3\"]");
  JsonTreeReader reader = new JsonTreeReader(element);
  reader.beginArray();
  assertEquals(1, reader.nextInt());
  assertEquals(2L, reader.nextLong());
  assertEquals(3.0, reader.nextDouble());
  reader.endArray();
}
 

public void testStringsFromNumbers() throws IOException {
  JsonElement element = JsonParser.parseString("[1]");
  JsonTreeReader reader = new JsonTreeReader(element);
  reader.beginArray();
  assertEquals("1", reader.nextString());
  reader.endArray();
}
 

public void testBooleans() throws IOException {
  JsonElement element = JsonParser.parseString("[true, false]");
  JsonTreeReader reader = new JsonTreeReader(element);
  reader.beginArray();
  assertEquals(true, reader.nextBoolean());
  assertEquals(false, reader.nextBoolean());
  reader.endArray();
}
 

public void testNulls() throws IOException {
  JsonElement element = JsonParser.parseString("[null,null]");
  JsonTreeReader reader = new JsonTreeReader(element);
  reader.beginArray();
  reader.nextNull();
  reader.nextNull();
  reader.endArray();
}
 

public void testStrings() throws IOException {
  JsonElement element = JsonParser.parseString("[\"A\",\"B\"]");
  JsonTreeReader reader = new JsonTreeReader(element);
  reader.beginArray();
  assertEquals("A", reader.nextString());
  assertEquals("B", reader.nextString());
  reader.endArray();
}
 

public void testArray() throws IOException {
  JsonElement element = JsonParser.parseString("[1, 2, 3]");
  JsonTreeReader reader = new JsonTreeReader(element);
  assertEquals(JsonToken.BEGIN_ARRAY, reader.peek());
  reader.beginArray();
  assertEquals(JsonToken.NUMBER, reader.peek());
  assertEquals(1, reader.nextInt());
  assertEquals(JsonToken.NUMBER, reader.peek());
  assertEquals(2, reader.nextInt());
  assertEquals(JsonToken.NUMBER, reader.peek());
  assertEquals(3, reader.nextInt());
  assertEquals(JsonToken.END_ARRAY, reader.peek());
  reader.endArray();
  assertEquals(JsonToken.END_DOCUMENT, reader.peek());
}
 

public static JsonElement parse(String json) {
    return JsonParser.parseString(json);
}
 

@Test
public void testArraySplitWithFieldsToKeep() throws IOException {
  TestContext t = new TestContext();
  t.setFunctionName("foo");
  LambdaContext lctx = new LambdaContext(t);

  JsonElement input = JsonParser.parseString(getResourceString("array_input_kinesis_format.json"));
  GenericJsonEvent devent = new GenericJsonEvent(input.getAsJsonObject());
  List<String> fieldsToKeep = Arrays.asList("owner", "logGroup", "logStream");
  ArraySplitOperation operation = new ArraySplitOperation("$.logEvents", fieldsToKeep);

  InternalEvent ievent = new InternalEvent("", lctx, 123);
  ievent.setEventObj(devent);
  ievent.setEventTime(124);
  List<InternalEvent> events = operation.perform(ievent);

  assertEquals(4, events.size());
  JsonElement actual = JsonParser.parseString(events.get(0).getEventString());
  assertTrue(actual.getAsJsonObject().has("owner"));
  assertTrue(actual.getAsJsonObject().has("logGroup"));
  assertTrue(actual.getAsJsonObject().has("logStream"));
  assertTrue(actual.getAsJsonObject().has("id"));
  assertTrue(actual.getAsJsonObject().has("message"));
  assertTrue(actual.getAsJsonObject().has("timestamp"));

  actual = JsonParser.parseString(events.get(1).getEventString());
  assertTrue(actual.getAsJsonObject().has("owner"));
  assertTrue(actual.getAsJsonObject().has("logGroup"));
  assertTrue(actual.getAsJsonObject().has("logStream"));
  assertTrue(actual.getAsJsonObject().has("id"));
  assertTrue(actual.getAsJsonObject().has("message"));
  assertTrue(actual.getAsJsonObject().has("timestamp"));

  actual = JsonParser.parseString(events.get(2).getEventString());
  assertTrue(actual.getAsJsonObject().has("owner"));
  assertTrue(actual.getAsJsonObject().has("logGroup"));
  assertTrue(actual.getAsJsonObject().has("logStream"));
  assertTrue(actual.getAsJsonObject().has("id"));
  assertTrue(actual.getAsJsonObject().has("message"));
  assertTrue(actual.getAsJsonObject().has("timestamp"));

  actual = JsonParser.parseString(events.get(3).getEventString());
  assertTrue(actual.getAsJsonObject().has("owner"));
  assertTrue(actual.getAsJsonObject().has("logGroup"));
  assertTrue(actual.getAsJsonObject().has("logStream"));
  assertTrue(actual.getAsJsonObject().has("id"));
  assertTrue(actual.getAsJsonObject().has("message"));
  assertTrue(actual.getAsJsonObject().has("timestamp"));
}
 

public void testEmptyObject() throws IOException {
  JsonElement element = JsonParser.parseString("{}");
  JsonTreeReader reader = new JsonTreeReader(element);
  reader.beginObject();
  reader.endObject();
}
 

public void testEmptyArray() throws IOException {
  JsonElement element = JsonParser.parseString("[]");
  JsonTreeReader reader = new JsonTreeReader(element);
  reader.beginArray();
  reader.endArray();
}
 

/**
 * Creates and completes a ReportStateAndNotification request
 *
 * @param actionsApp The SmartHomeApp instance to use to make the gRPC request
 * @param userId The agent user ID
 * @param deviceId The device ID
 * @param states A Map of state keys and their values for the provided device ID
 */
public static void makeRequest(
    SmartHomeApp actionsApp, String userId, String deviceId, Map<String, Object> states) {
  // Convert a Map of states to a JsonObject
  JsonObject jsonStates = (JsonObject) JsonParser.parseString(new Gson().toJson(states));
  ReportState.makeRequest(actionsApp, userId, deviceId, jsonStates);
}