Convierta una cadena JSON en una salida JSON de Pretty Print usando Jackson

Esta es la cadena JSON que tengo:

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

Necesito convertir el JSON anterior Stringen Salida JSON de Pretty Print (usando Jackson), como a continuación:

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

¿Alguien puede proporcionarme un ejemplo basado en mi ejemplo anterior? ¿Cómo lograr este escenario? Sé que hay muchos ejemplos, pero no puedo entenderlos correctamente. Cualquier ayuda será apreciada con un simple ejemplo.

Actualizado:

A continuación se muestra el código que estoy usando:

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

Pero esto no funciona de la manera que necesitaba la salida como se mencionó anteriormente.

Aquí está el POJO que estoy usando para el JSON anterior:

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

¿Alguien puede decirme si obtuve el POJO correcto para el JSON o no?

Actualizado:

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 siguiente línea imprime algo como esto:

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

así es como necesitaba que me mostraran. Pero cuando lo agrego al modelo así:

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

Y luego lo muestra en una página jsp de formulario de resultados como a continuación:

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

    </fieldset>

Me sale algo como esto:

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

que no necesito Necesitaba la forma en que se imprimió arriba. ¿Alguien puede decirme por qué sucedió de esta manera?

Para sangrar cualquier JSON antiguo, solo agréguelo como Object, como:

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

y luego escríbelo con sangría:

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

esto evita que tenga que definir POJO real para asignar datos.

O también puede usar JsonNode(Árbol JSON).

La solución más simple y también más compacta (para v2.3.3):

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

La nueva forma de usar Jackson 1.9+ es la siguiente:

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

¡La salida se formateará correctamente!

Para Jackson 1.9, podemos usar el siguiente código para una bonita impresión.

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

Creo que esta es la técnica más simple para embellecer los datos json,

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

donde Response es una cadena.

Simplemente pase el 4 (indentSpaces) en el toString()método.

Nota: Funciona bien en Android sin ninguna biblioteca. Pero en Java tienes que usar la biblioteca org.json .

Parece que podría ser la respuesta a tu pregunta . Dice que está usando Spring, pero creo que eso debería ayudarte en tu caso. Permítanme incluir el código aquí para que sea más conveniente:

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

Puede lograr esto de la siguiente manera:

1. Usando Jackson de Apache

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

Importar clase abajo:

import com.fasterxml.jackson.databind.ObjectMapper;

Su dependencia de Gradle es:

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. Usando Gson de Google

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

Importar clase abajo:

import com.google.gson.Gson;

Es gradle es:

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

Aquí, puede descargar la versión actualizada correcta del repositorio.

ObjectMapper.readTree() puede hacer esto en una línea:

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