Java 类com.fasterxml.jackson.core.util.DefaultIndenter 实例源码

public static String marshalJson(CASServiceResponse serviceResponse) {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    //Force newlines to be LF (default is system dependent)
    DefaultPrettyPrinter printer = new DefaultPrettyPrinter()
            .withObjectIndenter(new DefaultIndenter("  ", "\n"));

    //create wrapper node
    Map<String, Object> casModel = new HashMap<>();
    casModel.put("serviceResponse", serviceResponse);
    try {
        return mapper.writer(printer).writeValueAsString(casModel);
    } catch (JsonProcessingException e) {
        throw new RuntimeException(e);
    }
}

public void testCustomSeparatorsWithPP() throws Exception
{
    StringWriter sw = new StringWriter();
    JsonGenerator gen = new JsonFactory().createGenerator(ObjectWriteContext.empty(), sw);
    gen.setPrettyPrinter(new DefaultPrettyPrinter().withSeparators(Separators.createDefaultInstance()
            .withObjectFieldValueSeparator('=')
            .withObjectEntrySeparator(';')
            .withArrayValueSeparator('|')));

    _writeTestDocument(gen);
    gen.close();
    assertEquals("[ 3| \"abc\"| [ true ]| {" + DefaultIndenter.SYS_LF +
            "  \"f\" = null;" + DefaultIndenter.SYS_LF +
            "  \"f2\" = null" + DefaultIndenter.SYS_LF +
            "} ]", sw.toString());
}

public void testCustomSeparatorsWithPPWithoutSpaces() throws Exception
{
    StringWriter sw = new StringWriter();
    JsonGenerator gen = new JsonFactory().createGenerator(ObjectWriteContext.empty(), sw);
    gen.setPrettyPrinter(new DefaultPrettyPrinter().withSeparators(Separators.createDefaultInstance()
            .withObjectFieldValueSeparator('=')
            .withObjectEntrySeparator(';')
            .withArrayValueSeparator('|'))
        .withoutSpacesInObjectEntries());

    _writeTestDocument(gen);
    gen.close();
    assertEquals("[ 3| \"abc\"| [ true ]| {" + DefaultIndenter.SYS_LF +
            "  \"f\"=null;" + DefaultIndenter.SYS_LF +
            "  \"f2\"=null" + DefaultIndenter.SYS_LF +
            "} ]", sw.toString());
}

@Nonnull
private static ObjectWriter createJsonWriter(final boolean prettyPrint) {
    final ObjectMapper mapper = new ObjectMapper();

    if (!prettyPrint) {
        return mapper.writer();
    }

    final DefaultPrettyPrinter.Indenter indenter = new DefaultIndenter("    ", DefaultIndenter.SYS_LF);
    final DefaultPrettyPrinter printer = new DefaultPrettyPrinter("");
    printer.withoutSpacesInObjectEntries();
    printer.indentObjectsWith(indenter);
    printer.indentArraysWith(indenter);

    return mapper.writer(printer);
}

/**
 @return The JSON pretty-printed representation of this configuration.
 */
@Override
public final String toString() {
    final ObjectMapper mapper = new ObjectMapper()
        .configure(SerializationFeature.INDENT_OUTPUT, true);
    final DefaultPrettyPrinter.Indenter indenter = new DefaultIndenter(
        "\t", DefaultIndenter.SYS_LF
    );
    final DefaultPrettyPrinter printer = new DefaultPrettyPrinter();
    printer.withObjectIndenter(indenter);
    printer.withArrayIndenter(indenter);
    try {
        return mapper.writer(printer).writeValueAsString(this);
    } catch(final JsonProcessingException e) {
        throw new AssertionError(e);
    }
}

@Override
public void afterPropertiesSet() {
    super.setModules(this.modules);

    super.afterPropertiesSet();

    ObjectMapper objMapper = this.getObject();
    DefaultIndenter indenter = new DefaultIndenter(StringUtils.repeat(StringUtils.SPACE, this.indentSize), StringUtils.LF);

    SdcctPrettyPrinter prettyPrinter = new SdcctPrettyPrinter(indenter.getIndent());
    prettyPrinter.indentArraysWith(indenter);
    prettyPrinter.indentObjectsWith(indenter);

    objMapper.setDefaultPrettyPrinter(prettyPrinter);

    objMapper.setPropertyInclusion(this.propInclusion);
}

@SuppressWarnings("unused")
private static void prettyPrint(String json) throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    JsonNode node = mapper.readTree(json);

    CustomPrettyPrinter prettyPrinter = new CustomPrettyPrinter();
    prettyPrinter.indentArraysWith(DefaultIndenter.SYSTEM_LINEFEED_INSTANCE);
    StringBuilder sb = new StringBuilder();
    JsonGenerator jg = mapper.getFactory().createGenerator(CharStreams.asWriter(sb))
            .setPrettyPrinter(prettyPrinter);
    jg.writeTree(node);
    jg.close();

    System.out.println(sb.toString().replace("\"", "\\\"").replace(DefaultIndenter.SYS_LF,
            "\"" + DefaultIndenter.SYS_LF + " + \""));
}

private static ObjectMapper prettyMapper() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setBase64Variant(Base64Variants.MODIFIED_FOR_URL);
    mapper.configure(SerializationFeature.INDENT_OUTPUT, true);

    mapper.registerModule(tuuidModule());

    if (!Env.dev()) {
        mapper.registerModule(new AfterburnerModule());
    }

    DefaultPrettyPrinter pp = new DefaultPrettyPrinter();
    pp = pp.withObjectIndenter(new DefaultIndenter("  ", "\n"));

    mapper.setDefaultPrettyPrinter(pp);

    return mapper;
}

/**
 * Static factory that creates {@link com.fasterxml.jackson.databind.ObjectWriter}s.
 *
 * @return utility that will allow client to serialize wrapper contents as json
 */
public static ObjectWriter getObjectWriter(boolean filterMeta) {
    DefaultIndenter withLinefeed = new DefaultIndenter("  ", "\n");
    DefaultPrettyPrinter printer = new DefaultPrettyPrinter();
    printer.indentObjectsWith(withLinefeed);
    ObjectMapper om = new ObjectMapper();

    if (filterMeta) {
        outfitMetadataFilter(om);
    }

    return om.writer().with(printer);
}

public JacksonPrettyPrinter(int indent) {
    super();
    StringBuilder indentSpaces = new StringBuilder();
    while (indentSpaces.length() < indent)
        indentSpaces.append(" ");
    super._objectIndenter = new DefaultIndenter(indentSpaces.toString(), DefaultIndenter.SYS_LF);
    super._arrayIndenter = DefaultIndenter.SYSTEM_LINEFEED_INSTANCE;
}

public NpmJsonPrettyPrinter() {
    this._objectFieldValueSeparatorWithSpaces = ": ";

    Indenter indenter = new DefaultIndenter("  ", System.lineSeparator());
    this.indentObjectsWith(indenter);
    this.indentArraysWith(indenter);
}

@Override
public void afterPropertiesSet() {
    super.afterPropertiesSet();

    DefaultIndenter indenter = new DefaultIndenter(StringUtils.repeat(StringUtils.SPACE, this.indentSpaces), StringUtils.LF);

    CrigttPrettyPrinter prettyPrinter = new CrigttPrettyPrinter(indenter.getIndent());
    prettyPrinter.indentArraysWith(indenter);
    prettyPrinter.indentObjectsWith(indenter);

    this.getObject().setDefaultPrettyPrinter(prettyPrinter);
}

private String serialize(JsonGraph jsonGraph) {
  DefaultPrettyPrinter prettyPrinter = new DefaultPrettyPrinter()
      .withObjectIndenter(new DefaultIndenter("  ", "\n"));

  ObjectWriter writer = this.objectMapper.writer(prettyPrinter);
  StringWriter jsonWriter = new StringWriter();
  try {
    writer.writeValue(jsonWriter, jsonGraph);
  } catch (IOException e) {
    // should never happen with StringWriter
    throw new IllegalStateException(e);
  }

  return jsonWriter.toString();
}

public StandardJsonPrettyPrinter(String indent, String eol) {
    this.indent = indent;
    this.eol = eol;
    final DefaultIndenter indenter = new DefaultIndenter(indent, eol);
    this._arrayIndenter = indenter;
    this._objectIndenter = indenter;
}

/**
 * This constructor creates a new smart object mapper for the specified modules.
 *
 * @param modules The modules to be registered.
 */
SmartObjectMapper(Module... modules) {
    super();

    // indent the output
    enable(SerializationFeature.INDENT_OUTPUT);

    // allow empty beans
    disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);

    // don't serialize nulls
    disable(SerializationFeature.WRITE_NULL_MAP_VALUES);
    setSerializationInclusion(Include.NON_NULL);

    // don't fail on unknown properties
    configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

    // write dates out as string (not milliseconds since epoch <- timestamp)
    disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

    // handle joda types
    registerModule(new JodaModule());

    // handle primitive types that can generate strings
    addMixIn(craterdog.primitives.BinaryString.class, UseToStringAsValueMixIn.class);
    addMixIn(craterdog.primitives.Tag.class, UseToStringAsValueMixIn.class);
    addMixIn(craterdog.primitives.TextString.class, UseToStringAsValueMixIn.class);
    addMixIn(java.net.URI.class, UseToStringAsValueMixIn.class);

    // handle primitive types that can generate doubles
    addMixIn(craterdog.primitives.Angle.class, UseToDoubleAsValueMixIn.class);
    addMixIn(craterdog.primitives.Probability.class, UseToDoubleAsValueMixIn.class);

    // add any additional modules passed in
    for (Module module : modules) {
        registerModule(module);
    }

    setDefaultPrettyPrinter(new BetterPrettyPrinter().withArrayIndenter(new DefaultIndenter()));
}

/**
 * Sole constructor of the pretty printer.
 */
/* default */ JsonPrettyPrinter() {
    this._arrayIndenter = new DefaultIndenter(" ", "\n");
}

private PrettyPrintMappingJsonFactory() {
  this.pp = new DefaultPrettyPrinter();
  pp.indentArraysWith(new DefaultIndenter());
}

private void setupIndenters() {
    Indenter indenter = new DefaultIndenter();
    indentObjectsWith(indenter);
    indentArraysWith(indenter);
}

public ConfiguratePrettyPrinter(int indent, FieldValueSeparatorStyle style) {
    this._objectIndenter = indent == 0 ? NopIndenter.instance : DefaultIndenter.SYSTEM_LINEFEED_INSTANCE.withIndent(Strings.repeat(" ", indent));
    this.style = style;
}

public ConfiguratePrettyPrinter(int indent, FieldValueSeparatorStyle style) {
    this._objectIndenter = indent == 0 ? NopIndenter.instance : DefaultIndenter.SYSTEM_LINEFEED_INSTANCE.withIndent(Strings.repeat(" ", indent));
    this.style = style;
}

public static PrettyPrinter getPrettyPrinter() {
    CustomPrettyPrinter prettyPrinter = new CustomPrettyPrinter();
    prettyPrinter.indentArraysWith(DefaultIndenter.SYSTEM_LINEFEED_INSTANCE);
    return prettyPrinter;
}

public ArraysOnNewLinePrettyPrinter() {
    _arrayIndenter = DefaultIndenter.SYSTEM_LINEFEED_INSTANCE;
}

/**
 * This method behaves similarly to the <code>writeValueAsString(Object value)</code> method
 * except that it includes an indentation prefix that will be prepended to each line of the
 * resulting string (except the first line).
 *
 * @param value The smart object to be written out as a string.
 * @param indentation The indentation string to be prepended to each line.
 * @return The formatted string.
 * @throws JsonProcessingException The JSON object mapper was not able to serialize the object.
 */
String writeValueAsString(Object value, String indentation) throws JsonProcessingException {
    PrettyPrinter printer = new BetterPrettyPrinter(indentation).withArrayIndenter(new DefaultIndenter());
    return writer(printer).writeValueAsString(value);
}