JSON Pretty Print en Java
J'utilise json-simple et j'ai besoin d'imprimer joliment les données JSON (de les rendre plus lisibles par l'homme).
Je n'ai pas été en mesure de trouver cette fonctionnalité dans cette bibliothèque ..___ Comment cela est-il généralement réalisé?
GSON peut le faire de façon agréable:
Gson gson = new GsonBuilder().setPrettyPrinting().create();
JsonParser jp = new JsonParser();
JsonElement je = jp.parse(uglyJSONString);
String prettyJsonString = gson.toJson(je);
J'ai utilisé org.json des 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. Un ordre spécifique est soumis à l'implémentation de l'analyseur.
Il semble que GSON le supporte, bien que je ne sache pas si vous souhaitez changer de bibliothèque.
À partir du guide de l'utilisateur:
Gson gson = new GsonBuilder().setPrettyPrinting().create();
String jsonOutput = gson.toJson(someObject);
Si vous utilisez une implémentation d'API Java pour le traitement JSON (JSR-353), vous pouvez spécifier la propriété JsonGenerator.PRETTY_PRINTING lorsque vous créez un 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 ligne:
System.out.println(new GsonBuilder().setPrettyPrinting().create().toJson(new JsonParser().parse(jsonString)));
En plus d'inline, cela équivaut à la réponse acceptée .
Ma situation est que mon projet utilise un analyseur JSON hérité (non-JSR) qui ne prend pas en charge les jolies impressions. Cependant, j'avais besoin de produire de jolis échantillons JSON; Cela est possible sans avoir à ajouter de bibliothèques supplémentaires tant que vous utilisez Java 7 et versions ultérieures:
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))
Depuis: Comment activer la jolie sortie JSON (Jackson)
Je sais que cela est déjà dans les réponses, mais je veux l'écrire séparément ici car il y a des chances que vous ayez déjà une dépendance de Jackson et que tout ce dont vous aurez besoin serait une ligne de code supplémentaire.
Dans JSONLib, vous pouvez utiliser ceci:
String jsonTxt = JSONUtils.valueToString(json, 8, 4);
Depuis le Javadoc :
En une ligne:
String niceFormattedJson = JsonWriter.formatJson(jsonString)
La bibliothèque json-io ( https://github.com/jdereg/json-io ) est une petite bibliothèque (75 Ko) sans autre dépendance que le JDK.
En plus d’imprimer joliment JSON, vous pouvez sérialiser des objets Java (graphiques d’objets Java complets avec cycles) en JSON, ainsi que les lire.
Maintenant, ceci 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 toString(int indentationFactor) surchargée et non la méthode toString() standard.
J'ai vérifié cela 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 récente 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;
}
}
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 uniquement les API Java générales (disponible dans Java 7 pour les versions plus récentes; je n'ai pas essayé l'ancienne version, bien que).
L'idée de base est de déclencher la mise en forme en fonction des caractères spéciaux en JSON. Par exemple, si un '{' ou '' 'est observé, le code créera une nouvelle ligne et augmentera le niveau d'indentation.
Clause de non-responsabilité: je n’ai testé cela que pour certains cas JSON simples (paire clé-valeur de base, liste, JSON imbriquée). Il peut donc être nécessaire de travailler sur du texte JSON plus général, comme une chaîne de caractères avec des guillemets 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(" ");
}
}
Vous pouvez utiliser Gson comme ci-dessous
Gson gson = new GsonBuilder().setPrettyPrinting().create();
String jsonString = gson.toJson(object);
De la poste JSON jolie impression en utilisant Gson
Alternativement, vous pouvez utiliser Jackson comme ci-dessous
ObjectMapper mapper = new ObjectMapper();
String perttyStr = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);
De la poste JSON en Java en Java (Jackson)
J'espère que cette aide!
Cela a fonctionné pour moi, en utilisant Jackson:
mapper.writerWithDefaultPrettyPrinter().writeValueAsString(JSONString)