online - parsear json java

Convierta cadena JSON en impresión JSON con impresión bonita utilizando Jackson

Question

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 la cadena JSON anterior en Pretty Print JSON Output (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 una base de ejemplo 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 está el código que estoy usando

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

Pero esto no funciona con la forma en que necesitaba la salida como se mencionó anteriormente

Aquí está el POJO que estoy usando para el anterior 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;
}

¿Alguien puede decirme si obtuve el POJO adecuado 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));

Debajo de la 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"
  } ]
}

que es la forma en que necesitaba ser mostrado. Pero cuando lo agrego a un modelo como este-

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

Y luego lo muestra en una página de resultados jsp 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ó anteriormente. ¿Alguien puede decirme por qué sucedió así?

Answer 1

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 método toString() .

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

Answer 2

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 estará formateada correctamente!

Answer 3

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

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

Answer 4

Para Jackson 1.9, podemos usar el siguiente código para imprimir bonito.

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

Answer 5

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

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

y luego escríbalo con sangría:

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

esto evita tener que definir POJO real para mapear datos.

O puede usar JsonNode (JSON Tree) también.

Answer 6

Parece que podría ser la respuesta a tu pregunta . Dice que está usando Spring, pero creo que todavía debería ayudarte en tu caso. Permítanme poner en línea el código aquí, así que es 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;}
}