gsonAan de slag met gson


Opmerkingen

Gson is een Open Source Java-bibliotheek die kan worden gebruikt om Java-objecten om te zetten in hun JSON-weergave. Het kan ook worden gebruikt om een JSON-string te converteren naar een equivalent Java-object.

Doelen voor Gson

  • Bied eenvoudig te gebruiken mechanismen zoals toString () en constructor (fabrieksmethode) om Java naar JSON te converteren en vice versa

  • Sta toe dat reeds bestaande niet-wijzigbare objecten naar en van JSON worden geconverteerd

  • Aangepaste representaties voor objecten toestaan

  • Ondersteuning van willekeurig complexe objecten

  • Genereer compacte en leesbare JSON-uitvoer

De broncode van Gson is beschikbaar op Github .

Gebruikershandleiding

arrays

JSON:

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

Person.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) + " ]";
    }
}
 

Gebruik:

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

Output:

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

Converteer String naar JsonObject zonder 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();
 

Installatie

Om Gson te gebruiken, moet u het in uw project opnemen. U kunt dit doen door de volgende afhankelijkheid van de Gson-versie toe te voegen die beschikbaar is in Maven Central:

Maven

Toevoegen aan pom.xml

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

Gradle :

Toevoegen aan build.gradle

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

Serialisatie en deserialisatie

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
 

Eenvoudig voorbeeld

De Gson-bibliotheek biedt Gson.class die alle conversies tussen Java- en JSON-objecten afhandelt. Een exemplaar van deze klasse kan worden gemaakt door de standaardconstructor aan te roepen. U wilt meestal één Gson-exemplaar hebben voor het grootste deel van de bewerkingen in uw programma.

Gson gson = new Gson();
 

Eerst moeten we klasse creëren van ons object waarmee we zullen werken

class Person {
   public String name;
   public int age;

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

De klasse Gson biedt methoden toJson en fromJson die de belangrijkste toegangspunten zijn voor JSON- en Java-objecten

Laten we proberen het Java-object te converteren naar JSON en terug naar het Java-object

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}
 

En nu weer terug

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"
 

GSON gebruiken met overerving

GSON ondersteunt geen erfenis van de doos. Laten we zeggen dat we de volgende klassenhiërarchie hebben:

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

En nu willen we een exemplaar van DerivedClass1 naar een json-string

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

Nu, op een andere plaats, ontvangen we deze json-string en willen we deze deserialiseren - maar tijdens het compileren weten we alleen dat het een instantie van BaseClass :

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

Maar GSON weet niet dat derivedClass1Json oorspronkelijk een instantie was van DerivedClass1 , dus dit zal 10 afdrukken.

Hoe dit op te lossen?

U moet uw eigen JsonDeserializer bouwen, die dergelijke gevallen afhandelt. De oplossing is niet perfect schoon, maar ik kon geen betere bedenken.

Voeg eerst het volgende veld toe aan uw basisklasse

@SerializedName("type")
private String typeName;
 

En initialiseer het in de constructeur van de basisklasse

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

Voeg nu de volgende klasse toe:

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

U hoeft alleen nog maar alles aan te sluiten -

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

En nu, met de volgende code-

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

Wordt afgedrukt 5.