import com.flipkart.zjsonpatch.JsonDiff; //导入依赖的package包/类
@Test
public void testJsonDiff() throws Exception
{
    String f_base = "src/test/resources/brat_normal.json";
    String f_addedMiddle = "src/test/resources/brat_added_entity_near_middle.json";
    String f_removedMiddle = "src/test/resources/brat_removed_entity_in_middle.json";
    String f_removedEnd = "src/test/resources/brat_removed_entity_near_end.json";

    MappingJackson2HttpMessageConverter jsonConverter = 
            new MappingJackson2HttpMessageConverter();
    
    ObjectMapper mapper = jsonConverter.getObjectMapper();
    
    JsonNode base = mapper.readTree(new File(f_base));
    JsonNode addedMiddle = mapper.readTree(new File(f_addedMiddle));
    JsonNode removedMiddle = mapper.readTree(new File(f_removedMiddle));
    JsonNode removedEnd = mapper.readTree(new File(f_removedEnd));
    
    JsonNode d_addedMiddle = JsonDiff.asJson(base, addedMiddle);
    JsonNode d_removedMiddle = JsonDiff.asJson(base, removedMiddle);
    JsonNode d_removedEnd = JsonDiff.asJson(base, removedEnd);
    
    System.out.println(d_addedMiddle);
    System.out.println(d_removedMiddle);
    System.out.println(d_removedEnd);
}
 

import com.flipkart.zjsonpatch.JsonDiff; //导入依赖的package包/类
/**
 * Evaluates the matcher for argument <var>actualJson</var>.
 *
 * @param actualJson the JSON content against which the matcher is evaluated.
 * @return <code>true</code> if <var>actualJson</var> matches <var>expectedJson</var>, otherwise <code>false</code>.
 */
@Override
public boolean matches(Object actualJson) {
    try {
        JsonNode actual = objectMapper.readTree(actualJson.toString());
        JsonNode expected = objectMapper.readTree(expectedJson);
        String diff = JsonDiff.asJson(actual, expected).toString();
        return diff.equals("[]");
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import com.flipkart.zjsonpatch.JsonDiff; //导入依赖的package包/类
/**
 * compare JSON to the content of the specified file
 *
 * @param actualJson        JSON to compare
 * @param expectedFileName  file name from which to load expected content
 * @throws IOException          if an I/O error occurs
 * @throws NullPointerException if the file doesn't exist
 */
public void assertJson(String actualJson, String expectedFileName) throws IOException {
    String path = String.format(PATH, testClass.getSimpleName(), methodName, expectedFileName);
    try (InputStream resourceAsStream = testClass.getClassLoader().getResourceAsStream(path)) {
        String expectedJson = IOUtils.toString(resourceAsStream, Charset.defaultCharset());
        JsonNode actual = objectMapper.readTree(actualJson);
        JsonNode expected = objectMapper.readTree(expectedJson);

        LOGGER.info("EXPECTED JSON: " + expectedJson);
        LOGGER.info("ACTUAL JSON: " + actualJson);

        String diff = JsonDiff.asJson(actual, expected).toString();
        if (!diff.equals("[]")) {
            throw new AssertionFailedError("Json objects are not equal: " + diff);
        }
    }
}
 

import com.flipkart.zjsonpatch.JsonDiff; //导入依赖的package包/类
private JsonNode computeJsonPatch(Response response) throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    JsonFactory factory = mapper.getFactory();
    JsonNode actualJsonTree = factory.createParser(response.getBody()).readValueAsTree();
    JsonNode expectedJsonTree = factory.createParser(expectedJson).readValueAsTree();
    JsonNode jsonPatch = JsonDiff.asJson(actualJsonTree, expectedJsonTree);
    removeReplaceOpsForIgnoredFields(jsonPatch);
    removeMoveOpsForOrderIgnoredFields(jsonPatch);
    return jsonPatch;
}
 

import com.flipkart.zjsonpatch.JsonDiff; //导入依赖的package包/类
private void execute(String path) throws Exception {
  String raw = GeneralUtils.loadResource(AstEmitterTest.class, path);
  Map<String, String> sections = TestCaseParser.parseSections(raw);
  String source = sections.get("SOURCE").trim();
  CompiledTemplate template = compiler().compile(source);

  String json = sections.get("JSON").trim();
  JsonNode expected = JsonUtils.decode(json);

  JsonNode actual = AstEmitter.get(template.code());

  // TODO: improve the diff formatting.
  String diff = JsonDiff.asJson(expected, actual).toString();
  assertEquals(actual.toString(), expected.toString(), diff);
}
 

import com.flipkart.zjsonpatch.JsonDiff; //导入依赖的package包/类
public Changeset computeNext(JsonNode document) throws IOException {
    final String documentId = document.get("id").asText();
    final Optional<JsonNode> persistentDocument = getDocument(documentId);
    final JsonNode patch = JsonDiff.asJson(persistentDocument.orElse(mapper.createObjectNode()), document);
    return new Changeset(documentId, retrieveLastOrderNumber(documentId) + 1L, filterExcludedFields(patch));
}
 

import com.flipkart.zjsonpatch.JsonDiff; //导入依赖的package包/类
private String bratRenderCommand(JCas aJCas)
    {
        StopWatch timer = new StopWatch();
        timer.start();
        
        GetDocumentResponse response = new GetDocumentResponse();
        render(response, aJCas);
        String json = toJson(response);
        
        // By default, we do a full rendering...
        RenderType renderType = RenderType.FULL;
        String cmd = "renderData";
        String data = json;

        // ... try to render diff
        String diff = null;
        JsonNode current = null;
        JsonNode previous = null;
        try {
            ObjectMapper mapper = JSONUtil.getJsonConverter().getObjectMapper();
            current = mapper.readTree(json);
            previous = lastRenderedJson != null ? mapper.readTree(lastRenderedJson) : null;
        }
        catch (IOException e) {
            LOG.error("Unable to generate diff, falling back to full render.", e);
            // Fall-through
        }
        
        if (previous != null && current != null) {
            diff = JsonDiff.asJson(previous, current).toString();
 
            // Only sent a patch if it is smaller than sending the full data. E.g. when switching
            // pages, the patch usually ends up being twice as large as the full data.
            if (diff.length() < json.length()) {
                cmd = "renderDataPatch";
                data = diff;
                renderType = RenderType.DIFFERENTIAL;
            }
            
//            LOG.info("Diff:  " + diff);
//            LOG.info("Full: {}   Patch: {}   Diff time: {}", json.length(), diff.length(), timer);
        }
        
        // Storing the last rendered JSON as string because JsonNodes are not serializable.
        lastRenderedJson = json;
        
        timer.stop();

        metrics.renderComplete(renderType, timer.getTime(), json, diff);
        
        return "Wicket.$('" + vis.getMarkupId() + "').dispatcher.post('" + cmd + "', [" + data
                + "]);";
    }