JSON Pretty Print in Java

sto usando JSON-semplice e ho bisogno di stampare graziosamente i dati JSON (renderli più leggibili dall'uomo).

Non sono stato in grado di trovare questa funzionalità all'interno di quella libreria. Come si ottiene questo comunemente?

GSON può farlo in un modo carino:

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

Ho usato i metodi integrati org.json per stampare in modo grazioso i dati.

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

L'ordine dei campi in JSON è casuale per definizione. Un ordine specifico è soggetto all'implementazione del parser.

Sembra che GSON lo supporti, anche se non so se si desidera passare dalla libreria in uso.

Dalla guida per l'utente:

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

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

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

Da: Come abilitare l'output JSON di Pretty Print (Jackson)

So che questo è già nelle risposte, ma voglio scriverlo separatamente qui perché è probabile che tu abbia già Jackson come dipendenza e quindi tutto ciò di cui hai bisogno sarebbe una riga di codice aggiuntiva

Se si utilizza un'implementazione dell'API Java per l'elaborazione JSON (JSR-353), è possibile specificare la JsonGenerator.PRETTY_PRINTINGproprietà quando si crea un JsonGeneratorFactory.

Il seguente esempio è stato originariamente pubblicato sul mio post sul 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();

La mia situazione è che il mio progetto utilizza un parser JSON legacy (non JSR) che non supporta la stampa piuttosto. Tuttavia, dovevo produrre campioni JSON piuttosto stampati; questo è possibile senza dover aggiungere ulteriori librerie purché si utilizzi Java 7 e versioni successive:

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");

Bella stampa con GSON su una riga:

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

Oltre a sottolineare, questo equivale alla risposta accettata .

Ora questo può essere ottenuto con la libreria JSONLib:

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

Se (e solo se) usi il toString(int indentationFactor)metodo sovraccarico e non il toString()metodo standard .

Ho verificato questo sulla seguente versione dell'API:

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

La maggior parte delle risposte esistenti dipende da alcune librerie esterne o richiede una versione speciale di Java. Ecco un semplice codice per stampare piuttosto una stringa JSON, usando solo API Java generali (disponibile in Java 7 per versioni successive; non ho provato la versione precedente però).

L'idea di base è attivare la formattazione basata su caratteri speciali in JSON. Ad esempio, se si osserva un '{' o '[', il codice creerà una nuova riga e aumenterà il livello di rientro.

Dichiarazione di non responsabilità: ho provato questo solo per alcuni semplici casi JSON (coppia chiave-valore di base, elenco, JSON nidificato), quindi potrebbe essere necessario un po 'di lavoro per un testo JSON più generale, come il valore di stringa con virgolette all'interno o caratteri speciali (\ n, \ t ecc.).

/**
 * A simple implementation to pretty-print JSON file.
 *
 * @param unformattedJsonString
 * @return
 */
public static String prettyPrintJSON(String unformattedJsonString) {
  StringBuilder prettyJSONBuilder = new StringBuilder();
  int indentLevel = 0;
  boolean inQuote = false;
  for(char charFromUnformattedJson : unformattedJsonString.toCharArray()) {
    switch(charFromUnformattedJson) {
      case '"':
        // switch the quoting status
        inQuote = !inQuote;
        prettyJSONBuilder.append(charFromUnformattedJson);
        break;
      case ' ':
        // For space: ignore the space if it is not being quoted.
        if(inQuote) {
          prettyJSONBuilder.append(charFromUnformattedJson);
        }
        break;
      case '{':
      case '[':
        // Starting a new block: increase the indent level
        prettyJSONBuilder.append(charFromUnformattedJson);
        indentLevel++;
        appendIndentedNewLine(indentLevel, prettyJSONBuilder);
        break;
      case '}':
      case ']':
        // Ending a new block; decrese the indent level
        indentLevel--;
        appendIndentedNewLine(indentLevel, prettyJSONBuilder);
        prettyJSONBuilder.append(charFromUnformattedJson);
        break;
      case ',':
        // Ending a json item; create a new line after
        prettyJSONBuilder.append(charFromUnformattedJson);
        if(!inQuote) {
          appendIndentedNewLine(indentLevel, prettyJSONBuilder);
        }
        break;
      default:
        prettyJSONBuilder.append(charFromUnformattedJson);
    }
  }
  return prettyJSONBuilder.toString();
}

/**
 * Print a new line with indention at the beginning of the new line.
 * @param indentLevel
 * @param stringBuilder
 */
private static void appendIndentedNewLine(int indentLevel, StringBuilder stringBuilder) {
  stringBuilder.append("\n");
  for(int i = 0; i < indentLevel; i++) {
    // Assuming indention using 2 spaces
    stringBuilder.append("  ");
  }
}

In una riga:

String niceFormattedJson = JsonWriter.formatJson(jsonString)

La libray json-io ( https://github.com/jdereg/json-io ) è una piccola libreria (75K) senza altre dipendenze rispetto al JDK.

Oltre a stampare piuttosto JSON, è possibile serializzare oggetti Java (interi grafici di oggetti Java con cicli) su JSON, nonché leggerli in.

Seguendo le specifiche JSON-P 1.0 ( JSR-353 ) una soluzione più attuale per un dato JsonStructure( JsonObjecto JsonArray) potrebbe apparire così:

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;
    }

}

In JSONLib puoi usare questo:

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

Dal Javadoc :

Puoi usare Gson come di seguito

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

Dal post bella stampa JSON usando Gson

In alternativa, puoi usare Jackson come di seguito

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

Dal post Pretty print JSON in Java (Jackson)

Spero che questo aiuto!

Usando org json. Link di riferimento

JSONObject jsonObject = new JSONObject(obj);
String prettyJson = jsonObject.toString(4);

Usando Gson. Link di riferimento

Gson gson = new GsonBuilder().setPrettyPrinting().create();
String json = gson.toJson(obj);

Usando Jackson. Link di riferimento

ObjectMapper mapper = new ObjectMapper();
mapper.enable(SerializationFeature.INDENT_OUTPUT);
String json = mapper.writeValueAsString(obj);

Usando Genson. Link di riferimento .

Genson prettyGenson = new GensonBuilder().useIndentation(true).create();
String prettyJson = prettyGenson.serialize(obj);

Questo ha funzionato per me, usando Jackson:

mapper.writerWithDefaultPrettyPrinter().writeValueAsString(JSONString)

Puoi usare una piccola libreria json

String jsonstring = ....;
JsonValue json = JsonParser.parse(jsonstring);
String jsonIndendedByTwoSpaces = json.toPrettyString("  ");

Underscore-java ha un metodo statico U.formatJson(json). Sono supportati cinque tipi di formato: 2, 3, 4, schede e compatto. Sono il manutentore del progetto. Esempio dal vivo

import com.github.underscore.lodash.U;

import static com.github.underscore.lodash.Json.JsonStringBuilder.Step.TABS;
import static com.github.underscore.lodash.Json.JsonStringBuilder.Step.TWO_SPACES;

public class MyClass {

    public static void main(String args[]) {
        String json = "{\"Price\": {"
        + "    \"LineItems\": {"
        + "        \"LineItem\": {"
        + "            \"UnitOfMeasure\": \"EACH\", \"Quantity\": 2, \"ItemID\": \"ItemID\""
        + "        }"
        + "    },"
        + "    \"Currency\": \"USD\","
        + "    \"EnterpriseCode\": \"EnterpriseCode\""
        + "}}";
        System.out.println(U.formatJson(json, TWO_SPACES)); 
        System.out.println(U.formatJson(json, TABS)); 
    }
}

Produzione:

{
  "Price": {
    "LineItems": {
      "LineItem": {
        "UnitOfMeasure": "EACH",
        "Quantity": 2,
        "ItemID": "ItemID"
      }
    },
    "Currency": "USD",
    "EnterpriseCode": "EnterpriseCode"
  }
}
{
    "Price": {
        "LineItems": {
            "LineItem": {
                "UnitOfMeasure": "EACH",
                "Quantity": 2,
                "ItemID": "ItemID"
            }
        },
        "Currency": "USD",
        "EnterpriseCode": "EnterpriseCode"
    }
}