Pretty-Print JSON en Java

j'ai utilisé org.JSON méthodes intégrées pour imprimer les données.

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

l'ordre des champs dans JSON est aléatoire par définition. Une commande spécifique est sujette à la mise en œuvre de l'analyseur.

il semble que Gson supporte ceci, bien que je ne sais pas si vous voulez passer de la bibliothèque que vous utilisez.

du guide de l'utilisateur:

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

si vous utilisez une API Java pour l'implémentation JSON Processing (JSR-353), vous pouvez spécifier la propriété JsonGenerator.PRETTY_PRINTING lorsque vous créez une JsonGeneratorFactory .

l'exemple suivant a été publié à l'origine sur mon blog post .

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

Jolie impression avec GSON en une seule ligne:

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

en plus de la stabilité, cela équivaut à la réponse acceptée .

Ma situation est que mon projet utilise un analyseur JSON legacy (non-JSR) qui ne supporte pas l'impression pretty. Cependant, j'avais besoin de produire de jolis échantillons JSON imprimés; ceci est possible sans avoir à ajouter de bibliothèques supplémentaires tant que vous utilisez Java 7 et au-dessus:

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

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

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

De: Comment faire pour activer pretty print sortie JSON (Jackson)

je sais que c'est déjà dans les réponses, mais je veux l'écrire séparément ici parce que les chances sont, vous avez déjà Jackson comme une dépendance et donc tout ce que vous aurez besoin serait une ligne supplémentaire de code

dans JSONLib vous pouvez utiliser ceci:

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

De la Javadoc :

sur une ligne:

String niceFormattedJson = JsonWriter.formatJson(jsonString)

The json-io libray ( https://github.com/jdereg/json-io ) est une petite bibliothèque (75K) sans autres dépendances que JDK.

en plus de pretty-printing JSON, vous pouvez sérialiser les objets Java (entier Java object graphs avec des cycles) à JSON, ainsi que les lire dans.

maintenant, cela peut être réalisé avec la bibliothèque JSONLib:

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

si (et seulement si) vous utilisez la méthode surchargée toString(int indentationFactor) et non la méthode standard toString() .

j'ai vérifié sur la version suivante de L'API:

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

suivant les spécifications JSON-P 1.0 ( JSR-353 ) une solution plus courante pour une JsonStructure ( JsonObject ou JsonArray ) donnée pourrait ressembler à ceci:

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

}

vous pouvez utiliser Gson comme ci-dessous

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

De la poste JSON jolie impression à l'aide de Gson

alternativement, vous pouvez utiliser Jackson comme ci-dessous

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

De la poste Pretty print JSON en Java (Jackson)

Espérons que cette aide!

la plupart des réponses existantes dépendent d'une bibliothèque externe ou nécessitent une version Java spéciale. Voici un code simple pour imprimer une chaîne JSON, en utilisant seulement les API Java générales (disponibles en Java 7 pour les versions plus élevées; n'ont pas essayé la version plus ancienne bien que).

l'idée de base est de Tiger le formatage basé sur des caractères spéciaux dans JSON. Par exemple, si un ' {''[ ' , le code va créer une nouvelle ligne et d'augmenter le niveau de retrait.

clause de non-responsabilité: je n'ai testé cela que pour quelques cas simples de JSON (paire clé-valeur de base, Liste, JSON imbriqué), donc il peut avoir besoin de quelques travaux pour un texte JSON plus général, comme la valeur de la chaîne avec des guillemets à l'intérieur, ou des caractères spéciaux (\n, \t, etc.).

/**
 * 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("  ");
  }
}

cela a fonctionné pour moi, en utilisant Jackson:

mapper.writerWithDefaultPrettyPrinter().writeValueAsString(JSONString)