[Java] Convertir JSON en Java et Java en JSON-Comment utiliser GSON et Jackson-

Aperçu

Je vais résumer les méthodes de JSON → Java, Java → JSON qui sont souvent utilisées lors de l'utilisation de l'API Web en Java En outre, comment HTTP POST et HTTP GET JSON sera résumé dans le prochain article.

Cours le plus court-Réflexion avec JSON-

Considérez le cours le plus court lorsque la chaîne de caractères JSON que vous souhaitez analyser existe déjà, par exemple lorsque vous accédez à une API externe. Puisque la classe de modèle ** Site généré automatiquement ** est utilisée, c'est OK s'il y a une chaîne de caractères JSON (le schéma JSON est encore meilleur).

Exemple de chaîne JSON: exemple.json


{
    "person": {
        "firstName": "John",
        "lastName": "Doe",
        "address": "NewYork",
        "pets": [
            {"type": "Dog", "name": "Jolly"},
            {"type": "Cat", "name": "Grizabella"},
            {"type": "Fish", "name": "Nimo"}
        ]
    }
}

GSON et Jackson

Quand il s'agit d'opérations JSON en Java, j'utilise souvent deux bibliothèques, ** GSON ** et ** Jackson **. Je ne peux pas dire lequel est le meilleur, alors je vais vous expliquer les deux.

GSON [Bibliothèque] créée par Google (https://github.com/google/gson) image.png

Jackson [Bibliothèque] axée sur les performances (https://github.com/FasterXML/jackson) image.png

Édition GSON

Mappez JSON vers Java en utilisant ** GSON **

Commençons par GSON. Si vous souhaitez créer un analyseur Java à partir de chaînes JSON brutes, il est facile d'utiliser jsonschema2pojo, je vais donc l'essayer.

Cliquez ici pour le code source de ce chapitre https://github.com/riversun/java-json-gson-jackson-http/tree/master/src/main/java/com/example/gson

Dépendances de la bibliothèque GSON

La méthode de spécification de la bibliothèque GSON est la suivante

■ La dernière bibliothèque de GSON (référentiel maven) https://mvnrepository.com/artifact/com.google.code.gson/gson

■ Exemple de réglage GSON ** maven **

pom.xml


<dependency>
	<groupId>com.google.code.gson</groupId>
	<artifactId>gson</artifactId>
	<version>2.8.5</version>
</dependency>

■ Exemple de réglage GSON ** gradle **

build.gradle


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

(1) Générer automatiquement une classe de modèle (POJO) en utilisant jsonschema2pojo

Accédez au site suivant et collez le JSON ci-dessus http://www.jsonschema2pojo.org/

  • Si vous n'êtes pas à l'aise avec un site externe, vous pouvez le faire vous-même en utilisant Library.

image.png

■ Définissez comme suit sur le site et appuyez sur ** Zip ** pour générer automatiquement une classe de modèle

Package: ** com.example.gson ** (nom du package, peu importe, mais la source est automatiquement générée avec ce nom de package) Nom de la classeN: ** Modèle ** (nom de classe supérieure de Pojo) Target language:Java Type de source: ** JSON ** (classe de modèle d'estimation à partir de la chaîne JSON elle-même) Style d'annotation: ** Gson ** (utilisez GSON pour l'analyseur) ☑ ** Autoriser des propriétés supplémentaires ** (JSON peut être mélangé avec des propriétés inconnues)

Un fichier ** Zip ** est généré, donc lorsque vous le téléchargez et l'ouvrez, trois fichiers java sont automatiquement générés comme indiqué ci-dessous.

(2) ** Vérifiez la classe de modèle générée automatiquement ** (POJO)

■ ** Model.java ** ・ ・ ・ Classe la plus élevée

Model.java


package com.example.gson;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;
public class Model {
    @SerializedName("person")
    @Expose
    public Person person;
}

■ ** Person.java ** ・ ・ ・ ** "pets": [] ** qui est spécifié comme un tableau devient ** List **

Person.java


package com.example.gson;
import java.util.List;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;
public class Person {
    @SerializedName("firstName")
    @Expose
    public String firstName;
    @SerializedName("lastName")
    @Expose
    public String lastName;
    @SerializedName("address")
    @Expose
    public String address;
    @SerializedName("pets")
    @Expose
    public List<Pet> pets = null;
}

■ Pet.java

Pet.java


package com.example.gson;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;
public class Pet {
    @SerializedName("type")
    @Expose
    public String type;
    @SerializedName("name")
    @Expose
    public String name;
}

(3) Convertir ** JSON en Java ** à l'aide de GSON

Convertir de JSON en Java, c'est-à-dire charger une chaîne JSON dans une classe de modèle Java à l'aide de GSON Le code clé est le suivant

Gson gson = new Gson();
Model model = gson.fromJson(json, Model.class);

Le code entier ressemble à ceci

■ GsonJson2Java.java

GsonJson2.java


package com.example.gson;

import com.google.gson.Gson;

public class GsonJson2Java {
    public static void main(String[] args) {
        String json = 
                "{" +
                "    \"person\": {" +
                "        \"firstName\": \"John\"," +
                "        \"lastName\": \"Doe\"," +
                "        \"address\": \"NewYork\"," +
                "        \"pets\": [" +
                "            {\"type\": \"Dog\", \"name\": \"Jolly\"}," +
                "            {\"type\": \"Cat\", \"name\": \"Grizabella\"}," +
                "            {\"type\": \"Fish\", \"name\": \"Nimo\"}" +
                "        ]" +
                "    }" +
                "}";

        Gson gson = new Gson();
        Model model = gson.fromJson(json, Model.class);

        System.out.println("firstName:" + model.person.firstName);
        System.out.println("lastName:" + model.person.lastName);
        System.out.println("address:" + model.person.address);
        System.out.println("1st pet:" + model.person.pets.get(0).name);
    }
}

Résultat d'exécution


firstName:John
lastName:Doe
address:NewYork
1st pet:Jolly

(4) Convertir ** Java → JSON ** à l'aide de GSON

Maintenant, faisons JSON à partir de Java. Convertissez la classe de modèle Java (POJO) en JSON.

Gson gson = new Gson();
String json = gson.toJson(model);

GsonJava2Json.java

GsonJava2Json.java


package com.example.gson;

import java.util.ArrayList;
import com.google.gson.Gson;

public class GsonJava2Json {
    public static void main(String[] args) {

        Model model = new Model();
        model.person = new Person();
        model.person.firstName = "John";
        model.person.lastName = "Faire";
        model.person.address = "New York";

        model.person.pets = new ArrayList<Pet>();

        Pet pet1 = new Pet();
        pet1.type = "chien";
        pet1.name = "Gai";
        model.person.pets.add(pet1);

        Pet pet2 = new Pet();
        pet2.type = "Chat";
        pet2.name = "Grizabella";
        model.person.pets.add(pet2);

        Pet pet3 = new Pet();
        pet3.type = "poisson";
        pet3.name = "Nimo";
        model.person.pets.add(pet3);

        Gson gson = new Gson();
        String json = gson.toJson(model);

        System.out.println(json);
    }
}

Lorsque cela a été exécuté, JSON pouvait être sorti de la classe de modèle comme suit.

Résultat d'exécution


{"person":{"firstName":"John","lastName":"Faire","address":"New York","pets":[{"type":"chien","name":"Gai"},{"type":"Chat","name":"Grizabella"},{"type":"poisson","name":"Nimo"}]}}

(5) Format (Pretty Printing) et sortie JSON en utilisant GSON

Si vous faites cela, le JSON sera indenté et bien formaté et sortira.

Gson gson2 = new GsonBuilder().setPrettyPrinting().create();
String prettyJson = gson2.toJson(model);
System.out.println(prettyJson);

Résultat d'exécution

{
  "person": {
    "firstName": "John",
    "lastName": "Faire",
    "address": "New York",
    "pets": [
      {
        "type": "chien",
        "name": "Gai"
      },
      {
        "type": "Chat",
        "name": "Grizabella"
      },
      {
        "type": "poisson",
        "name": "Nimo"
      }
    ]
  }
}

Édition Jackson

Jackson a des séries 1.x et 2.x, mais utilise des séries 2.x

Mappez JSON vers Java en utilisant ** Jackson **

Cliquez ici pour le code source de ce chapitre https://github.com/riversun/java-json-gson-jackson-http/tree/master/src/main/java/com/example/jackson

Dépendances de la bibliothèque Jackson

La méthode de spécification de la bibliothèque de Jackson est la suivante

■ La dernière bibliothèque de Jackson (référentiel maven) https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind

■ Exemple de réglage ** maven ** de Jackson

pom.xml


<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.9.8</version>
</dependency>

■ Exemple de réglage ** gradle ** de Jackson

build.gradle


compile 'com.fasterxml.jackson.core:jackson-databind:2.9.8'

(1) Générer automatiquement une classe de modèle (POJO) en utilisant jsonschema2pojo

Accédez au site suivant et collez le JSON ci-dessus http://www.jsonschema2pojo.org/

image.png

■ Définissez comme suit sur le site et appuyez sur ** Zip ** pour générer automatiquement une classe de modèle

Package: ** com.example. jackson </ font> ** (nom du package, peu importe, mais la source est automatiquement générée avec ce nom de package) Nom de la classeN: ** Modèle ** (nom de classe supérieure de Pojo) Target language:Java Type de source: ** JSON ** (classe de modèle d'estimation à partir de la chaîne JSON elle-même) Style d'annotation: ** jackson 2.x ** </ font> (utilisez Jackson 2.x comme analyseur) ☑ ** Autoriser des propriétés supplémentaires ** (JSON peut être mélangé avec des propriétés inconnues)

Un fichier ** Zip ** est généré, donc lorsque vous le téléchargez et l'ouvrez, trois fichiers java sont automatiquement générés comme indiqué ci-dessous.

(2) ** Vérifiez la classe de modèle générée automatiquement ** (POJO)

■ ** Modèle .java ** ・ ・ ・ La classe la plus élevée. Il est caractéristique que ** @JsonAnyGetter ** accepte des propriétés supplémentaires. Aussi, pour cette raison, il devient plus redondant que GSON.

Model.java


package com.example.jackson;
import java.util.HashMap;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
    "person"
})
public class Model {
    @JsonProperty("person")
    public Person person;
    @JsonIgnore
    private Map<String, Object> additionalProperties = new HashMap<String, Object>();
    @JsonAnyGetter
    public Map<String, Object> getAdditionalProperties() {
        return this.additionalProperties;
    }
    @JsonAnySetter
    public void setAdditionalProperty(String name, Object value) {
        this.additionalProperties.put(name, value);
    }
}

■ ** Person.java ** ・ ・ ・ ** @JsonPropertyOrder ** peut être utilisé pour contraindre l'ordre d'apparition. Un tableau spécifié comme ** "pets": [] ** devient ** List **.

Person.java


package com.example.jackson;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
    "firstName",
    "lastName",
    "address",
    "pets"
})
public class Person {
    @JsonProperty("firstName")
    public String firstName;
    @JsonProperty("lastName")
    public String lastName;
    @JsonProperty("address")
    public String address;
    @JsonProperty("pets")
    public List<Pet> pets = null;
    @JsonIgnore
    private Map<String, Object> additionalProperties = new HashMap<String, Object>();
    @JsonAnyGetter
    public Map<String, Object> getAdditionalProperties() {
        return this.additionalProperties;
    }
    @JsonAnySetter
    public void setAdditionalProperty(String name, Object value) {
        this.additionalProperties.put(name, value);
    }
}

■ Pet.java

Pet.java


package com.example.jackson;
import java.util.HashMap;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
    "type",
    "name"
})
public class Pet {
    @JsonProperty("type")
    public String type;
    @JsonProperty("name")
    public String name;
    @JsonIgnore
    private Map<String, Object> additionalProperties = new HashMap<String, Object>();
    @JsonAnyGetter
    public Map<String, Object> getAdditionalProperties() {
        return this.additionalProperties;
    }
    @JsonAnySetter
    public void setAdditionalProperty(String name, Object value) {
        this.additionalProperties.put(name, value);
    }
}

(3) Utilisez Jackson pour convertir ** JSON en Java **

Convertir de JSON en Java, c'est-à-dire utiliser Jackson pour charger une chaîne JSON dans une classe de modèle Java Le code clé est le suivant

ObjectMapper mapper = new ObjectMapper();
Model model = mapper.readValue(json, Model.class);

Le code entier ressemble à ceci

■ JacksonJson2Java.java

JacksonJson2Java.java


package com.example.jackson;

import java.io.IOException;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonJson2Java {
    public static void main(String[] args) throws JsonParseException, JsonMappingException, IOException {
        String json = "{" +
                "    \"person\": {" +
                "        \"firstName\": \"John\"," +
                "        \"lastName\": \"Doe\"," +
                "        \"address\": \"NewYork\"," +
                "        \"pets\": [" +
                "            {\"type\": \"Dog\", \"name\": \"Jolly\"}," +
                "            {\"type\": \"Cat\", \"name\": \"Grizabella\"}," +
                "            {\"type\": \"Fish\", \"name\": \"Nimo\"}" +
                "        ]" +
                "    }" +
                "}";

        ObjectMapper mapper = new ObjectMapper();
        Model model = mapper.readValue(json, Model.class);

        System.out.println("firstName:" + model.person.firstName);
        System.out.println("lastName:" + model.person.lastName);
        System.out.println("address:" + model.person.address);
        System.out.println("1st pet:" + model.person.pets.get(0).name);
    }
}

(4) Convertir ** Java → JSON ** en utilisant Jackson

Maintenant, faisons JSON à partir de Java. Convertissez la classe de modèle Java (POJO) en JSON.

ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(model);

JacksonJava2Json.java

JacksonJava2Json.java


package com.example.jackson;
import java.util.ArrayList;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonJava2Json {
    public static void main(String[] args) throws JsonProcessingException {

        Model model = new Model();
        model.person = new Person();
        model.person.firstName = "John";
        model.person.lastName = "Faire";
        model.person.address = "New York";
        model.person.pets = new ArrayList<Pet>();
        Pet pet1 = new Pet();
        pet1.type = "chien";
        pet1.name = "Gai";
        model.person.pets.add(pet1);
        Pet pet2 = new Pet();
        pet2.type = "Chat";
        pet2.name = "Grizabella";
        model.person.pets.add(pet2);
        Pet pet3 = new Pet();
        pet3.type = "poisson";
        pet3.name = "Nimo";
        model.person.pets.add(pet3);

        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(model);
        System.out.println(json);
    }
}

Lorsque cela a été exécuté, JSON pouvait être sorti de la classe de modèle comme suit.

Résultat d'exécution


{"person":{"firstName":"John","lastName":"Faire","address":"New York","pets":[{"type":"chien","name":"Gai"},{"type":"Chat","name":"Grizabella"},{"type":"poisson","name":"Nimo"}]}}

(5) Format (Pretty Printing) et sortie JSON en utilisant Jackson

Si vous faites cela, le JSON sera indenté et bien formaté et sortira.

ObjectMapper mapper2 = new ObjectMapper();
String prettyJson = mapper2.writerWithDefaultPrettyPrinter().writeValueAsString(model);
System.out.println(prettyJson);

Résultat d'exécution

{
  "person" : {
    "firstName" : "John",
    "lastName" : "Faire",
    "address" : "New York",
    "pets" : [ {
      "type" : "chien",
      "name" : "Gai"
    }, {
      "type" : "Chat",
      "name" : "Grizabella"
    }, {
      "type" : "poisson",
      "name" : "Nimo"
    } ]
  }
}

Résumé

  • J'ai expliqué comment exécuter facilement JSON → Java et Java → JSON en utilisant GSON.

  • Le code source utilisant GSON est ici

  • J'ai expliqué la même chose pour Jackson.

  • Le code source utilisant Jackson est ici

  • La méthode de POST et GET JSON via la communication HTTP est résumée dans ici.

Recommended Posts