webentwicklung-frage-antwort-db.com.de

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

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 String in Pretty Print JSON Output konvertieren (mit Jackson), 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 sie nicht richtig verstehen. Jede Hilfe wird mit einem einfachen Beispiel 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 oben erwähnte Ausgabe 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 gibt so etwas 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"
  } ]
}

auf diese Weise musste ich gezeigt werden. Aber wenn ich es so zum Modell hinzufüge:

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

Und zeigt es dann auf einer resultform 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?

142
arsenal

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

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

und schreibe es dann mit Einzug aus:

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

auf diese Weise müssen Sie kein tatsächliches POJO definieren, dem die Daten zugeordnet werden sollen.

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

216
StaxMan

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

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

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!

22

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

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

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.

Übergeben Sie einfach die Methode 4(indentSpaces) in toString().

Hinweis: Es funktioniert gut in der Android ohne Bibliothek. Aber in Java = Sie müssen die org.json Bibliothek benutzen.

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 weiterhelfen. 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;}
}
3
Daniel Kaplan

Sie können dies auf folgende Arten erreichen:

1. Mit Jacson

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

Balgklasse importieren:

import com.fasterxml.jackson.databind.ObjectMapper;

Es ist 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. Mit Google Gson

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

Balgklasse importieren:

import com.google.gson.Gson;

Es ist gradle ist:

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

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

Hoffe das wird dir helfen.

Vielen Dank :)

1