Empezando con gson

matrices

JSON:

[
  {
    "id": 8484,
    "name": "David",
    "height": 173.2,
    "weight": 75.42
  },
  {
    "id": 8485,
    "name": "Ronald",
    "height": 183.73,
    "weight": 83.1
  }
]

Persona.java

public class Person {
    public int id;
    public String name;
    public double height;
    public double weight;

    @Override
    public String toString() {
        return "[ id: " + String.valueOf(id) + ", name: " + name + ", height: " + String.valueOf(height) + ", weight: " + String.valueOf(weight) + " ]";
    }
}

Uso:

Gson gson = new Gson();
Person[] persons = gson.fromJson(json, Person[].class);
for(Person person : persons)
    System.out.println(person.toString());

Producción:

[ id: 8484, name: David, height: 173.2, weight: 75.42 ]
[ id: 8485, name: Ronald, height: 183.73, weight: 83.1 ]

Ejemplo sencillo

La biblioteca Gson proporciona Gson.class que maneja todas las conversiones entre objetos Java y JSON. Se puede crear una instancia de esta clase invocando al constructor predeterminado. Por lo general, le gustaría tener una instancia de Gson para la mayor parte de las operaciones en su programa.

Gson gson = new Gson();

Primero, necesitamos crear la clase de nuestro objeto con el que trabajaremos.

class Person {
   public String name;
   public int age;

   public Person(String name, int age){
       this.name = name;
       this.age = age;
   }
}

La clase Gson proporciona métodos toJson y fromJson, que son los principales puntos de entrada para objetos JSON y Java.

Intentemos convertir el objeto Java a JSON y volver al objeto Java

Person person = new Person("Jason", 29);
//using gson object which we created earlier
String json = gson.toJson(person);
System.out.println(json);
//Outputs: {"name": "Jason", "age": 29}

Y ahora de vuelta otra vez

String json = "{\"name\": \"Jason\", \"age\": 29}";
Person person = gson.fromJson(json, Person.class);
System.out.println(person.age + "yo " + person.name + " walks into a bar");
//Outputs "29 yo Jason walks into a bar"

Instalación

Para usar Gson, debe incluirlo en su proyecto. Puede hacerlo agregando la siguiente dependencia de la versión de Gson disponible en Maven Central:

Maven

Agregar a pom.xml

<dependencies>
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.0</version>
      <scope>compile</scope>
    </dependency>
</dependencies>

Gradle:

Agregar a build.gradle

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

Convertir String a JsonObject sin POJO

String jsonStr = "{\"name\" : \"Abcd\", \"greeting\": \"Hello\", }"; //Sample Json String

Gson gson = new Gson(); // Creates new instance of Gson
JsonElement element = gson.fromJson (jsonStr, JsonElement.class); //Converts the json string to JsonElement without POJO 
JsonObject jsonObj = element.getAsJsonObject(); //Converting JsonElement to JsonObject

String name = jsonObj.get("name").getAsString(); //To fetch the values from json object
String greeting = jsonObj.get("greeting").getAsString();

Serialización y deserialización

Gson gson = new Gson(); //Create a Gson object
MyType target = new MyType(); //This is the object you want to convert to JSON   
String json = gson.toJson(target); // serializes target to Json
MyType target2 = gson.fromJson(json, MyType.class); // deserializes json into target2

Usar GSON con herencia

GSON no admite la herencia de la caja. Digamos que tenemos la siguiente jerarquía de clases:

public class BaseClass {
    int a;
 
    public int getInt() {
        return a;
   }
}
 
public class DerivedClass1 extends BaseClass {
     int b;
 
     @Override
     public int getInt() {
         return b;
     }
 }
 
public class DerivedClass2 extends BaseClass {
    int c;
 
    @Override
    public int getInt() {
        return c;
    }
}

Y ahora queremos serializar una instancia de DerivedClass1 en una cadena json

DerivedClass1 derivedClass1 = new DerivedClass1();
derivedClass1.b = 5;
derivedClass1.a = 10;
 
Gson gson = new Gson();
String derivedClass1Json = gson.toJson(derivedClass1);

Ahora, en otro lugar, recibimos esta cadena json y queremos deserializarla, pero en tiempo de compilación solo sabemos que se supone que es una instancia de BaseClass:

BaseClass maybeDerivedClass1 = gson.fromJson(derivedClass1Json, BaseClass.class);
System.out.println(maybeDerivedClass1.getInt());

Pero GSON no sabe que derivedClass1Json fue originalmente una instancia de DerivedClass1, por lo que imprimirá 10.

¿Cómo resolver esto?

Necesita construir su propio JsonDeserializer, que maneje tales casos. La solución no es perfectamente limpia, pero no se me ocurrió una mejor.

Primero, agregue el siguiente campo a su clase base

@SerializedName("type")
private String typeName;

E inicialízalo en el constructor de la clase base.

public BaseClass() {
    typeName = getClass().getName();
}

Ahora agrega la siguiente clase:

public class JsonDeserializerWithInheritance<T> implements JsonDeserializer<T> {
 
 @Override
 public T deserialize(
     JsonElement json, Type typeOfT, JsonDeserializationContext context)
     throws JsonParseException {
     JsonObject jsonObject = json.getAsJsonObject();
     JsonPrimitive classNamePrimitive = (JsonPrimitive) jsonObject.get("type");
 
     String className = classNamePrimitive.getAsString();
 
     Class<?> clazz;
     try {
     clazz = Class.forName(className);
     } catch (ClassNotFoundException e) {
     throw new JsonParseException(e.getMessage());
     }
     return context.deserialize(jsonObject, clazz);
 }
}

Todo lo que queda por hacer es conectar todo -

GsonBuilder builder = new GsonBuilder();
 builder
 .registerTypeAdapter(BaseClass.class, new JsonDeserializerWithInheritance<BaseClass>());
 Gson gson = builder.create();

Y ahora, ejecutando el siguiente código:

 DerivedClass1 derivedClass1 = new DerivedClass1();
 derivedClass1.b = 5;
 derivedClass1.a = 10;
 String derivedClass1Json = gson.toJson(derivedClass1);
 
 BaseClass maybeDerivedClass1 = gson.fromJson(derivedClass1Json, BaseClass.class);
 System.out.println(maybeDerivedClass1.getInt());

Imprimirá 5.