Java ProcessingReport.iterator方法代碼示例

import com.github.fge.jsonschema.core.report.ProcessingReport; //導入方法依賴的package包/類
/**
 * Validates input node against given schema. Returns NULL if no errors
 * reported, else returns string representing violations.
 *
 * @param schema the json schema (see #loadSchema)
 * @param node the json node to validate
 * @return null if there are no errors, else string with all errors and
 * warnings
 * @throws ProcessingException
 */
public static String jsonSchemaValidation(JsonSchema schema, JsonNode node) throws ProcessingException, JsonProcessingException {
    ProcessingReport report = schema.validate(node);
    Iterator<ProcessingMessage> i = report.iterator();
    StringBuilder buff = new StringBuilder();
    while (!report.isSuccess() && i != null && i.hasNext()) {
        ProcessingMessage pm = i.next();

        // attempting to pretty print the json
        ObjectMapper mapper = new ObjectMapper();
        String prettyPrintJson = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(pm.asJson());

        buff.append(prettyPrintJson).append("\n\n");
    }

    return report.isSuccess() ? null : buff.toString();
}
 

import com.github.fge.jsonschema.core.report.ProcessingReport; //導入方法依賴的package包/類
protected void validateJson(String jsonFileName) throws IOException, ProcessingException, JsonLdError {

        JsonNode schema = getSchema();
        assertNotNull(schema);

        String jsonStr = getJson(jsonFileName);
        assertNotNull(jsonStr);

        Object jsonObj = JsonUtils.fromString(jsonStr);
        List<Object> expandedJson = JsonLdProcessor.expand(jsonObj);
        jsonStr = JsonUtils.toString(expandedJson);
        JsonNode json = JsonLoader.fromString(jsonStr);

        JsonValidator jsonValidator = JsonSchemaFactory.byDefault().getValidator();
        ProcessingReport processingReport = jsonValidator.validate(schema, json);
        assertNotNull(processingReport);
        if (!processingReport.isSuccess()) {

            ArrayNode jsonArray = JsonNodeFactory.instance.arrayNode();
            assertNotNull(jsonArray);

            Iterator<ProcessingMessage> iterator = processingReport.iterator();
            while (iterator.hasNext()) {
                ProcessingMessage processingMessage = iterator.next();
                jsonArray.add(processingMessage.asJson());
            }

            String errorJson = JsonUtils.toPrettyString(jsonArray);
            assertNotNull(errorJson);

            fail(errorJson);
        }
    }
 

import com.github.fge.jsonschema.core.report.ProcessingReport; //導入方法依賴的package包/類
public void validate(File ConfigurationFile) throws IOException, ProcessingException, IllegalSchemaException {
    JsonNode Configuration = JsonLoader.fromFile(ConfigurationFile);

    ProcessingReport r1 = VALIDATOR.validate(
            ConfigurationSchema,
            Configuration
    );

    if (!r1.isSuccess()) {
        Iterator<ProcessingMessage> it = r1.iterator();
        ProcessingMessage pm = it.next();
        JSONObject o = new JSONObject(pm.asJson().toString());
        throw new IllegalSchemaException(o.toString(4));
    }
}
 

import com.github.fge.jsonschema.core.report.ProcessingReport; //導入方法依賴的package包/類
/**
 * Returns set of {@link SwaggerError} created from a validation report.
 * 
 * @param report
 *            to process
 * @return set of validation errors
 */
public Set<SwaggerError> processReport(ProcessingReport report) {
    final Set<SwaggerError> errors = new HashSet<>();
    if (report != null) {
        for (Iterator<ProcessingMessage> it = report.iterator(); it.hasNext();) {
            errors.addAll(processMessage(it.next()));
        }
    }
    return errors;
}
 

import com.github.fge.jsonschema.core.report.ProcessingReport; //導入方法依賴的package包/類
@Override
public void processTuple(byte[] tuple)
{
  if (tuple == null) {
    if (err.isConnected()) {
      err.emit(new KeyValPair<String, String>(null, "null tuple"));
    }
    errorTupleCount++;
    return;
  }
  String incomingString = new String(tuple);
  try {
    if (schema != null) {
      ProcessingReport report = null;
      JsonNode data = JsonLoader.fromString(incomingString);
      report = schema.validate(data);
      if (report != null && !report.isSuccess()) {
        Iterator<ProcessingMessage> iter = report.iterator();
        StringBuilder s = new StringBuilder();
        while (iter.hasNext()) {
          ProcessingMessage pm = iter.next();
          s.append(pm.asJson().get("instance").findValue("pointer")).append(":").append(pm.asJson().get("message"))
              .append(",");
        }
        s.setLength(s.length() - 1);
        errorTupleCount++;
        if (err.isConnected()) {
          err.emit(new KeyValPair<String, String>(incomingString, s.toString()));
        }
        return;
      }
    }
    if (parsedOutput.isConnected()) {
      parsedOutput.emit(new JSONObject(incomingString));
      parsedOutputCount++;
    }
    if (out.isConnected()) {
      out.emit(objMapper.readValue(tuple, clazz));
      emittedObjectCount++;
    }
  } catch (JSONException | ProcessingException | IOException e) {
    errorTupleCount++;
    if (err.isConnected()) {
      err.emit(new KeyValPair<String, String>(incomingString, e.getMessage()));
    }
    logger.error("Failed to parse json tuple {}, Exception = {} ", tuple, e);
  }
}