Konvertieren Sie JSON-Zeichenfolgen mit Jackson in Pretty Print JSON-Ausgaben

Dies ist die JSON-Zeichenfolge, die ich habe:

{"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}]}

Ich muss den obigen JSON Stringin Pretty Print JSON Output (mit Jackson) konvertieren , wie unten:

{
    "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
        }
    ]
}

Kann mir jemand ein Beispiel geben, das auf meinem obigen Beispiel basiert? Wie kann dieses Szenario erreicht werden? Ich weiß, dass es viele Beispiele gibt, aber ich kann diese nicht richtig verstehen. Jede Hilfe wird anhand eines einfachen Beispiels geschätzt.

Aktualisiert:

Unten ist der Code, den ich benutze:

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

Dies funktioniert jedoch nicht so, wie ich die Ausgabe wie oben erwähnt benötigt habe.

Hier ist das POJO, das ich für den obigen JSON verwende:

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

Kann mir jemand sagen, ob ich das richtige POJO für den JSON habe oder nicht?

Aktualisiert:

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

Die folgende Zeile druckt ungefähr so ​​aus:

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"
  } ]
}

So musste ich gezeigt werden. Aber wenn ich es zu einem Modell wie diesem hinzufüge:

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

Und zeigt es dann auf einer Ergebnisformular-JSP-Seite wie unten:

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

    </fieldset>

Ich bekomme so etwas:

{ "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" } ] }

was ich nicht brauche. Ich brauchte die Art und Weise, wie es oben ausgedruckt wurde. Kann mir jemand sagen, warum es so passiert ist?

Um einen alten JSON einzurücken, binden Sie ihn einfach wie Objectfolgt:

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

und dann schreibe es mit Einrückung aus:

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

Dadurch müssen Sie kein tatsächliches POJO definieren, dem Daten zugeordnet werden sollen.

Oder Sie können auch JsonNode(JSON Tree) verwenden.

Die einfachste und zugleich kompakteste Lösung (für v2.3.3):

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

Der neue Weg mit Jackson 1.9+ ist der folgende:

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

Die Ausgabe wird korrekt formatiert!

Für Jackson 1.9 können wir den folgenden Code für hübschen Druck verwenden.

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

Ich denke, dies ist die einfachste Technik, um die JSON-Daten zu verschönern.

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

Dabei ist Response ein String.

Geben Sie einfach die 4 (indentSpaces) ein toString() Methode.

Hinweis: Es funktioniert gut in Android ohne Bibliothek. In Java müssen Sie jedoch die Bibliothek org.json verwenden.

Dies scheint die Antwort auf Ihre Frage zu sein . Es heißt, es wird Spring verwendet, aber ich denke, das sollte Ihnen in Ihrem Fall trotzdem helfen. Lassen Sie mich den Code hier einfügen, damit er bequemer ist:

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

Sie können dies auf folgende Weise erreichen:

1. Verwenden von Jackson von Apache

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

Folgende Klasse importieren:

import com.fasterxml.jackson.databind.ObjectMapper;

Die Gradle-Abhängigkeit ist:

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. Verwenden von Gson von Google

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

Folgende Klasse importieren:

import com.google.gson.Gson;

Es ist gradle ist:

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

Hier können Sie die richtige aktualisierte Version aus dem Repository herunterladen.

ObjectMapper.readTree() kann dies in einer Zeile tun:

mapper.writerWithDefaultPrettyPrinter().writeValueAsString(mapper.readTree(json));