Convert JSON String to Pretty Print JSON output using Jackson

问题

This is the JSON string I have:

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

I need to convert the above JSON String into Pretty Print JSON Output (using Jackson), like below:

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

Can anyone provide me an example based on my example above? How to achieve this scenario? I know there are lot of examples, but I am not able to understand those properly. Any help will be appreciated with a simple example.

Updated:

Below is the code I am using:

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

But this doesn\'t works with the way I needed the output as mentioned above.

Here\'s is the POJO I am using for the above JSON:

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

Can anyone tell me whether I got the right POJO for the JSON or not?

Updated:

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

Below line prints out something like this:

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

which is the way I needed to be shown. But when I add it to model like this:

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

And then shows it out in a resultform jsp page like below:

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

    </fieldset>

I get something like this:

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

which I don\'t need. I needed the way it got printed out above. Can anyone tell me why it happened this way?

回答1:

To indent any old JSON, just bind it as Object, like:

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

and then write it out with indentation:

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

this avoids your having to define actual POJO to map data to.

Or you can use JsonNode (JSON Tree) as well.

回答2:

The simplest and also the most compact solution (for v2.3.3):

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

回答3:

The new way using Jackson 1.9+ is the following:

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

The output will be correctly formatted!

回答4:

For Jackson 1.9, We can use the following code for pretty print.

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

回答5:

I think, this is the simplest technique to beautify the json data,

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

where Response is a String.

Simply pass the 4(indentSpaces) in toString() method.

Note: It works fine in the android without any library. But in java you have to use the org.json library.

回答6:

This looks like it might be the answer to your question. It says it's using Spring, but I think that should still help you in your case. Let me inline the code here so it's more convenient:

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

回答7:

You can achieve this using bellow ways:

1. Using Jackson from Apache

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

Import bellow class:

import com.fasterxml.jackson.databind.ObjectMapper;

It's gradle dependency is :

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. Using Gson from Google

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

Import bellow class:

import com.google.gson.Gson;

It's gradle is:

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

Here, you can download correct updated version from repository.

来源：https://stackoverflow.com/questions/14515994/convert-json-string-to-pretty-print-json-output-using-jackson