indent - Pretty-Print JSON en Java

print pojo as json

Question

Estoy usando json-simple y necesito imprimir bastante datos JSON (hacerlo más legible para los humanos).

No he podido encontrar esta funcionalidad dentro de esa biblioteca. ¿Cómo se logra esto comúnmente?

Answer 1

Ahora esto se puede lograr con la biblioteca JSONLib:

http://json-lib.sourceforge.net/apidocs/net/sf/json/JSONObject.html

Si (y solo si) usa el método sobrecargado toString(int indentationFactor) y no el método estándar toString() .

Lo he verificado en la siguiente versión de la API:

<dependency>
  <groupId>org.json</groupId>
  <artifactId>json</artifactId>
  <version>20140107</version>
</dependency>

Answer 2

Bonita impresión con GSON en una línea:

System.out.println(new GsonBuilder().setPrettyPrinting().create().toJson(new JsonParser().parse(jsonString)));

Además de enlining, esto es equivalente a la respuesta aceptada .

Answer 3

Con Jackson ( com.fasterxml.jackson.core ):

ObjectMapper mapper = new ObjectMapper();
System.out.println(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(jsonObject))

De: Cómo habilitar impresión bonita salida JSON (Jackson)

Sé que esto ya está en las respuestas, pero quiero escribirlo aquí por separado, porque es probable que ya tengas a Jackson como dependencia y, por lo tanto, lo único que necesitarás será una línea adicional de código

Answer 4

En JSONLib puede usar esto:

String jsonTxt = JSONUtils.valueToString(json, 8, 4);

Desde el Javadoc :

Answer 5

En una línea:

String niceFormattedJson = JsonWriter.formatJson(jsonString)

El json-io libray ( https://github.com/jdereg/json-io ) es una biblioteca pequeña (75K) sin más dependencias que el JDK.

Además de imprimir bastante JSON, puede serializar objetos de Java (gráficos enteros de objetos de Java con ciclos) en JSON, y también leerlos.

Answer 6

Esto funcionó para mí, usando Jackson:

mapper.writerWithDefaultPrettyPrinter().writeValueAsString(JSONString)

Answer 7

Mi situación es que mi proyecto utiliza un analizador JSON heredado (no JSR) que no admite una impresión bonita. Sin embargo, necesitaba producir muestras JSON bastante impresas; esto es posible sin tener que agregar ninguna biblioteca adicional siempre que use Java 7 o superior:

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine scriptEngine = manager.getEngineByName("JavaScript");
scriptEngine.put("jsonString", jsonStringNoWhitespace);
scriptEngine.eval("result = JSON.stringify(JSON.parse(jsonString), null, 2)");
String prettyPrintedJson = (String) scriptEngine.get("result");

Answer 8

Parece que GSON lo admite, aunque no sé si quiere cambiar de la biblioteca que está utilizando.

De la guía del usuario:

Gson gson = new GsonBuilder().setPrettyPrinting().create();
String jsonOutput = gson.toJson(someObject);

Answer 9

Puedes usar Gson como abajo

Gson gson = new GsonBuilder().setPrettyPrinting().create();
String jsonString = gson.toJson(object);

Del post JSON bonito imprimir usando Gson

Alternativamente, puedes usar Jackson como a continuación

ObjectMapper mapper = new ObjectMapper();
String perttyStr = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);

Del post Pretty print JSON en Java (Jackson)

¡Espero que esto ayude!

Answer 10

Si está utilizando una API Java para la implementación de JSON Processing (JSR-353), puede especificar la propiedad JsonGenerator.PRETTY_PRINTING cuando crea una JsonGeneratorFactory .

El siguiente ejemplo se publicó originalmente en mi publicación de blog .

import java.util.*;
import javax.json.Json;
import javax.json.stream.*;

Map<String, Object> properties = new HashMap<String, Object>(1);
properties.put(JsonGenerator.PRETTY_PRINTING, true);
JsonGeneratorFactory jgf = Json.createGeneratorFactory(properties);
JsonGenerator jg = jgf.createGenerator(System.out);

jg.writeStartObject()                    // {
    .write("name", "Jane Doe")           //    "name":"Jane Doe",
    .writeStartObject("address")         //    "address":{
        .write("type", 1)                //        "type":1,
        .write("street", "1 A Street")   //        "street":"1 A Street",
        .writeNull("city")               //        "city":null,
        .write("verified", false)        //        "verified":false
    .writeEnd()                          //    },
    .writeStartArray("phone-numbers")    //    "phone-numbers":[
        .writeStartObject()              //        {
            .write("number", "555-1111") //            "number":"555-1111",
            .write("extension", "123")   //            "extension":"123"
        .writeEnd()                      //        },
        .writeStartObject()              //        {
            .write("number", "555-2222") //            "number":"555-2222",
            .writeNull("extension")      //            "extension":null
        .writeEnd()                      //        }
    .writeEnd()                          //    ]
.writeEnd()                              // }
.close();

Answer 11

Siguiendo las especificaciones de JSON-P 1.0 ( JSR-353 ), una solución más actual para una JsonStructure ( JsonObject o JsonArray ) podría verse así:

import java.io.StringWriter;
import java.util.HashMap;
import java.util.Map;

import javax.json.Json;
import javax.json.JsonStructure;
import javax.json.JsonWriter;
import javax.json.JsonWriterFactory;
import javax.json.stream.JsonGenerator;

public class PrettyJson {

    private static JsonWriterFactory FACTORY_INSTANCE;

    public static String toString(final JsonStructure status) {

        final StringWriter stringWriter = new StringWriter();

        final JsonWriter jsonWriter = getPrettyJsonWriterFactory()
                .createWriter(stringWriter);

        jsonWriter.write(status);
        jsonWriter.close();

        return stringWriter.toString();
    }

    private static JsonWriterFactory getPrettyJsonWriterFactory() {
        if (null == FACTORY_INSTANCE) {
            final Map<String, Object> properties = new HashMap<>(1);
            properties.put(JsonGenerator.PRETTY_PRINTING, true);
            FACTORY_INSTANCE = Json.createWriterFactory(properties);
        }
        return FACTORY_INSTANCE;
    }

}

Answer 12

Utilicé métodos incorporados org.json para imprimir bastante los datos.

JSONObject json = new JSONObject(jsonString); // Convert text to object
System.out.println(json.toString(4)); // Print it with specified indentation

El orden de los campos en JSON es aleatorio por definición. Un orden específico está sujeto a la implementación del analizador.

Answer 13

GSON puede hacer esto de una manera agradable:

Gson gson = new GsonBuilder().setPrettyPrinting().create();
JsonParser jp = new JsonParser();
JsonElement je = jp.parse(uglyJSONString);
String prettyJsonString = gson.toJson(je);