validate - Análisis de JSON usando Gson para Java

read json file java

Question

Me gustaría analizar datos de JSON que es de tipo String . Estoy usando Google Gson .

Yo tengo:

jsonLine = "
{
 "data": {
  "translations": [
   {
    "translatedText": "Hello world"
   }
  ]
 }
}
";

y mi clase es:

public class JsonParsing{

   public void parse(String jsonLine) {

      // there I would like to get String "Hello world"

   }

}

Answer 1

Código de una línea:

System.out.println(new Gson().fromJson(jsonLine,JsonObject.class).getAsJsonObject().get("data").getAsJsonObject().get("translations").getAsJsonArray().get(0).getAsJsonObject().get("translatedText").getAsString());

Answer 2

En mi primera aplicación gson, evité el uso de clases adicionales para capturar valores, principalmente porque uso json para config matters

a pesar de la falta de información (incluso en la página gson), eso es lo que encontré y usé:

empezando desde

Map jsonJavaRootObject = new Gson().fromJson("{/*whatever your mega complex object*/}", Map.class)

Cada vez que gson ve un {}, crea un mapa (en realidad, un gson StringMap)

Cada vez que gson ve un '''', crea una cadena

Cada vez que gson ve un número, crea un doble

Cada vez que gson ve a [], crea una ArrayList

Puede usar estos hechos (combinados) para su ventaja

Finalmente este es el código que hace que la cosa

        Map<String, Object> javaRootMapObject = new Gson().fromJson(jsonLine, Map.class);

    System.out.println(
        (
            (Map)
            (
                (List)
                (
                    (Map)
                    (
                        javaRootMapObject.get("data")
                    )
                 ).get("translations")
            ).get(0)
        ).get("translatedText")
    );

Answer 3

Este es un código simple para hacerlo, evité todos los controles, pero esta es la idea principal.

 public String parse(String jsonLine) {
    JsonElement jelement = new JsonParser().parse(jsonLine);
    JsonObject  jobject = jelement.getAsJsonObject();
    jobject = jobject.getAsJsonObject("data");
    JsonArray jarray = jobject.getAsJsonArray("translations");
    jobject = jarray.get(0).getAsJsonObject();
    String result = jobject.get("translatedText").getAsString();
    return result;
}

Para que el uso sea más genérico, verás que los javadocs de Gson son bastante claros y útiles.

Answer 4

Lo más simple por lo general es crear una jerarquía de Objetos que coincida, así:

public class Wrapper {
   public Data data;
}
static class Data {
   public Translation[] translations;
}
static class Translation {
   public String translatedText;
}

y luego unir usando GSON, jerarquía de objeto transversal a través de campos. Agregar getters y setters no tiene sentido para los contenedores de datos básicos.

Entonces algo así como:

Wrapper value = GSON.fromJSON(jsonString, Wrapper.class);
String text = value.data.translations[0].translatedText;

Answer 5

Primero genere Getter And Setter utilizando el siguiente sitio de análisis

http://www.jsonschema2pojo.org/

Ahora usa Gson

GettetSetterClass object=new Gson().fromjson(jsonLine,GettetSetterClass.class);

Ahora usa object para obtener valores como data, translationText

Answer 6

Puede crear clases java correspondientes para los objetos json. El entero, los valores de cadena se pueden asignar como están. Json se puede analizar de esta manera:

Gson gson = new GsonBuilder().create(); 
Response r = gson.fromJson(jsonString, Response.class);

Aquí hay un ejemplo: http://rowsandcolumns.blogspot.com/2013/02/url-encode-http-get-solr-request-and.html

Answer 7

Puede usar una clase separada para representar el objeto JSON y usar @SerializedName anotaciones @SerializedName para especificar el nombre del campo que se debe tomar para cada miembro de datos:

public class Response {

   @SerializedName("data")
   private Data data;

   private static class Data {
      @SerializedName("translations")
      public Translation[] translations;
   }

   private static class Translation {
      @SerializedName("translatedText")
      public String translatedText;
   }

   public String getTranslatedText() {
      return data.translations[0].translatedText;
   }
}

Luego puedes hacer el análisis sintáctico en tu método parse () usando un objeto Gson :

Gson gson = new Gson();
Response response = gson.fromJson(jsonLine, Response.class);

System.out.println("Translated text: " + response.getTranslatedText());

Con este enfoque, puede reutilizar la clase Response para agregar otros campos adicionales para recoger otros miembros de datos que desee extraer de JSON, en caso de que desee realizar cambios para obtener resultados de, por ejemplo, varias traducciones en una sola llamada. , o para obtener una cadena adicional para el idioma de origen detectado.

Answer 8

Puede usar una consulta JsonPath para extraer el valor. ¡Y con JsonSurfer respaldado por Gson, su problema puede resolverse simplemente con dos líneas de código!

    JsonSurfer jsonSurfer = JsonSurfer.gson();
    String result = jsonSurfer.collectOne(jsonLine, String.class, "$.data.translations[0].translatedText");

Answer 9

Usando Gson para resolver
Crearía una clase para el parámetro individual en el json String. Alternativamente, puede crear una clase principal llamada "Datos" y luego crear clases internas de manera similar. Creé clases separadas para mayor claridad.

Las clases son las siguientes.

• Datos
• Traducciones
• TranslatedText

En la clase Json: utilizando el método "parse", llamamos a gson.fromJson(jsonLine, Data.class) que convertirá la cadena en objetos java utilizando Reflection.

Una vez que tenemos acceso al objeto "Datos" podemos acceder a cada parámetro individualmente.

No tuve la oportunidad de probar este código ya que estoy lejos de mi máquina de desarrollo. Pero esto debería ayudar.

Algunos buenos ejemplos y artículos.
http://albertattard.blogspot.com/2009/06/practical-example-of-gson.html
http://sites.google.com/site/gson/gson-user-guide

Código

public class JsonParsing{

       public void parse(String jsonLine) {

           Gson gson = new GsonBuilder().create();
           Data data = gson.fromJson(jsonLine, Data.class);

           Translations translations = data.getTranslation();
           TranslatedText[] arrayTranslatedText = translations.getArrayTranslatedText(); //this returns an array, based on json string

           for(TranslatedText translatedText:arrayTranslatedText )
           {
                  System.out.println(translatedText.getArrayTranslatedText());
           }
       }

    }


    public class Data{
           private  Translations translations;
          public Translations getTranslation()
          {
             return translations;
          }

          public void setTranslation(Translations translations)
           {
                  this.translations = translations;
           }
    }

    public class Translations
    {
        private  TranslatedText[] translatedText;
         public TranslatedText[] getArrayTranslatedText()
         {
             return translatedText;
         }

           public void setTranslatedText(TranslatedText[] translatedText)
           {
                  this.translatedText= translatedText;
           }
    }

    public class TranslatedText
    {
        private String translatedText;
        public String getTranslatedText()
        {
           return translatedText;
        }

        public void setTranslatedText(String translatedText)
        {
           this.translatedText = translatedText;
        }
    }

Answer 10

    JsonParser parser = new JsonParser();
    JsonObject jo = (JsonObject) parser.parse(data);
    JsonElement je = jo.get("some_array");

    //Parsing back the string as Array
    JsonArray ja = (JsonArray) parser.parse(o.get("some_array").getAsString());
    for (JsonElement jo : ja) {
    JsonObject j = (JsonObject) jo;
        // Your Code, Access json elements as j.get("some_element")
    }

Un ejemplo simple para analizar un JSON como este

{"some_array": "[/" some_element / ": 1, /" some_more_element / ": 2]", "some_other_element": 3}