web-dev-qa-db-fra.com

Conversion d'une chaîne JSON en sortie JSON avec Pretty Print à l'aide de Jackson

Voici la chaîne JSON que j'ai:

{"attributes":[{"nm":"ACCOUNT","lv":[{"v":{"Id":null,"State":null},"vt":"Java.util.Map","cn":1}],"vt":"Java.util.Map","status":"SUCCESS","lmd":13585},{"nm":"PROFILE","lv":[{"v":{"Party":null,"Ads":null},"vt":"Java.util.Map","cn":2}],"vt":"Java.util.Map","status":"SUCCESS","lmd":41962}]}

J'ai besoin de convertir le JSON String ci-dessus en une sortie Pretty Print JSON (à l'aide de Jackson), comme ci-dessous:

{
    "attributes": [
        {
            "nm": "ACCOUNT",
            "lv": [
                {
                    "v": {
                        "Id": null,
                        "State": null
                    },
                    "vt": "Java.util.Map",
                    "cn": 1
                }
            ],
            "vt": "Java.util.Map",
            "status": "SUCCESS",
            "lmd": 13585
        },
        {
            "nm": "PROFILE
            "lv": [
                {
                    "v": {
                        "Party": null,
                        "Ads": null
                    },
                    "vt": "Java.util.Map",
                    "cn": 2
                }
            ],
            "vt": "Java.util.Map",
            "status": "SUCCESS",
            "lmd": 41962
        }
    ]
}

Quelqu'un peut-il me fournir un exemple basé sur mon exemple ci-dessus? Comment réaliser ce scénario? Je sais qu'il y a beaucoup d'exemples, mais je ne suis pas capable de les comprendre correctement. Toute aide sera appréciée avec un exemple simple.

Mise à jour:

Ci-dessous le code que j'utilise:

ObjectMapper mapper = new ObjectMapper();
System.out.println(mapper.defaultPrettyPrintingWriter().writeValueAsString(jsonString));

Mais cela ne fonctionne pas avec la façon dont j'avais besoin de la sortie comme mentionné ci-dessus.

Voici le POJO que j'utilise pour le JSON ci-dessus:

public class UrlInfo implements Serializable {

    private List<Attributes> attribute;

}

class Attributes {

    private String nm;
    private List<ValueList> lv;
    private String vt;
    private String status;
    private String lmd;

}


class ValueList {
    private String vt;
    private String cn;
    private List<String> v;
}

Quelqu'un peut-il me dire si j'ai le bon POJO pour le JSON ou non?

Mise à jour:

String result = restTemplate.getForObject(url.toString(), String.class);

ObjectMapper mapper = new ObjectMapper();
Object json = mapper.readValue(result, Object.class);

String indented = mapper.defaultPrettyPrintingWriter().writeValueAsString(json);

System.out.println(indented);//This print statement show correct way I need

model.addAttribute("response", (indented));

La ligne ci-dessous affiche quelque chose comme ceci:

System.out.println(indented);


{
  "attributes" : [ {
    "nm" : "ACCOUNT",
    "error" : "null SYS00019CancellationException in CoreImpl fetchAttributes\n Java.util.concurrent.CancellationException\n\tat Java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.Java:231)\n\tat Java.util.concurrent.FutureTask.",
    "status" : "ERROR"
  } ]
}

c'est la façon dont je devais être montré. Mais quand je l'ajoute au modèle comme ceci:

model.addAttribute("response", (indented));

Et puis le montre dans une page de resultform jsp comme ci-dessous:

    <fieldset>
        <legend>Response:</legend>
            <strong>${response}</strong><br />

    </fieldset>

Je reçois quelque chose comme ça:

{ "attributes" : [ { "nm" : "ACCOUNT", "error" : "null    
SYS00019CancellationException in CoreImpl fetchAttributes\n 
Java.util.concurrent.CancellationException\n\tat 
Java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.Java:231)\n\tat 
Java.util.concurrent.FutureTask.", "status" : "ERROR" } ] }

dont je n'ai pas besoin. J'avais besoin de la façon dont il a été imprimé ci-dessus. Quelqu'un peut-il me dire pourquoi c'est arrivé de cette façon?

javajsonjacksonpretty-print
142
arsenal

Pour mettre en retrait un ancien JSON, associez-le simplement à Object, comme suit:

Object json = mapper.readValue(input, Object.class);

puis écrivez-le avec l'indentation:

String indented = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(json);

cela vous évite de devoir définir un POJO réel sur lequel mapper des données.

Vous pouvez également utiliser JsonNode (arborescence JSON).

216
StaxMan

La solution la plus simple mais aussi la plus compacte (pour v2.3.3):

ObjectMapper mapper = new ObjectMapper();
mapper.enable(SerializationFeature.INDENT_OUTPUT);
115
Marcelo C.

La nouvelle méthode utilisant Jackson 1.9+ est la suivante:

Object json = OBJECT_MAPPER.readValue(diffResponseJson, Object.class);
String indented = OBJECT_MAPPER.writerWithDefaultPrettyPrinter()
                               .writeValueAsString(json);

La sortie sera correctement formatée!

22
Marcello de Sales

Pour Jackson 1.9, nous pouvons utiliser le code suivant pour de jolies impressions.

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.enable(SerializationConfig.Feature.INDENT_OUTPUT);
14
scalauser

Je pense que c’est la technique la plus simple pour embellir les données JSON,

String indented = (new JSONObject(Response)).toString(4);

où Réponse est une chaîne.

Passez simplement la méthode 4(indentSpaces) in toString().

Remarque: Cela fonctionne très bien dans le Android sans bibliothèque. Mais dans Java, vous devez utiliser la bibliothèque org.json .

9
Aman Gupta - ShOoTeR

On dirait que cela pourrait être la réponse à votre question . Il dit qu'il utilise Spring, mais je pense que cela devrait quand même vous aider dans votre cas. Laissez-moi insérer le code ici pour que ce soit plus pratique:

import Java.io.FileReader;

import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.ObjectWriter;

public class Foo
{
  public static void main(String[] args) throws Exception
  {
    ObjectMapper mapper = new ObjectMapper();
    MyClass myObject = mapper.readValue(new FileReader("input.json"), MyClass.class);
    // this is Jackson 1.x API only: 
    ObjectWriter writer = mapper.defaultPrettyPrintingWriter();
    // ***IMPORTANT!!!*** for Jackson 2.x use the line below instead of the one above: 
    // ObjectWriter writer = mapper.writer().withDefaultPrettyPrinter();
    System.out.println(writer.writeValueAsString(myObject));
  }
}

class MyClass
{
  String one;
  String[] two;
  MyOtherClass three;

  public String getOne() {return one;}
  void setOne(String one) {this.one = one;}
  public String[] getTwo() {return two;}
  void setTwo(String[] two) {this.two = two;}
  public MyOtherClass getThree() {return three;}
  void setThree(MyOtherClass three) {this.three = three;}
}

class MyOtherClass
{
  String four;
  String[] five;

  public String getFour() {return four;}
  void setFour(String four) {this.four = four;}
  public String[] getFive() {return five;}
  void setFive(String[] five) {this.five = five;}
}
3
Daniel Kaplan

Vous pouvez y parvenir en utilisant les méthodes suivantes:

1. Utilisation de Jacson

    String formattedData=new ObjectMapper().writerWithDefaultPrettyPrinter()
.writeValueAsString(YOUR_JSON_OBJECT);

Importer la classe ci-dessous:

import com.fasterxml.jackson.databind.ObjectMapper;

Sa dépendance à l'échelle est:

compile 'com.fasterxml.jackson.core:jackson-core:2.7.3'
compile 'com.fasterxml.jackson.core:jackson-annotations:2.7.3'
compile 'com.fasterxml.jackson.core:jackson-databind:2.7.3'

2. Utilisation de Google Gson

String formattedData=new GsonBuilder().setPrettyPrinting()
    .create().toJson(YOUR_OBJECT);

Importer la classe ci-dessous:

import com.google.gson.Gson;

Son grade est:

compile 'com.google.code.gson:gson:2.8.2'

Ici, vous pouvez télécharger la version mise à jour correcte du référentiel.

J'espère que cela vous aidera.

Merci :)

1
Md. Sajedul Karim