Sérialisation en JSON

« Salut Amigo ! »

« Salut, Élie ! »

"Puisque vous avez déjà été initié à JSON, parlons-en davantage aujourd'hui."

« OK. Où est-il habituellement utilisé ? »

"Voici comment cela fonctionne généralement. Quelqu'un (le client) demande des données à un programme Java (le serveur). Le programme crée des objets Java et les remplit avec les informations de la base de données. Il les convertit ensuite dans un format que le demandeur (le client ) peut comprendre, comme JSON, et les renvoie."

"Laissez-moi vous dire comment travailler avec JSON en Java. Essentiellement, nous n'avons qu'à faire deux choses : sérialiser les objets Java au format JSON et désérialiser les objets Java à partir du format JSON."

"En d'autres termes, JSON est une norme pour envoyer des messages/données d'un programme à un autre. Il existe de nombreuses normes de ce type. Mais si le programme est écrit en JavaScript, il essaie généralement d'utiliser JSON."

"OK, je suis prêt."

"Génial. Alors commençons."

"Comme vous le savez déjà, Java a des outils de sérialisation standard intégrés. Mais ils ne prennent pas en charge JSON. Ainsi, si vous avez besoin de sérialiser un objet en JSON, vous pouvez utiliser l'un des frameworks populaires (bibliothèques) qui savent comment fais ça."

« Quelle est la différence entre ces différents frameworks ? »

"Ils diffèrent généralement par leur niveau de complexité : il existe des frameworks qui ne peuvent faire que les bases, mais ils sont très petits et simples. Et il existe de grands frameworks complexes qui peuvent faire beaucoup plus."

"Jackson est l'un des frameworks les plus populaires. Nous l'utiliserons comme exemple lorsque nous verrons comment travailler avec JSON."

"Tout d'abord, vous devez télécharger ce framework et l'ajouter à votre projet. Vous devez le faire directement dans IntelliJ IDEA. Vous pouvez télécharger le framework en utilisant ce lien ."

"Fait."

"Génial. Continuons, alors."

"Convertir un objet Java en JSON est à peu près aussi simple que de le sérialiser. Pour ce faire, il existe une classe ObjectMapper spéciale (com.fasterxml.jackson.databind.ObjectMapper)."

"Laissez-moi vous montrer un exemple concret, puis nous l'analyserons :"

public static void main(String[] args) throws IOException
{
 // Create an object to be serialized into JSON
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 // Write the result of the serialization to a StringWriter
 StringWriter writer = new StringWriter();

 // This is the Jackson object that performs the serialization
 ObjectMapper mapper = new ObjectMapper();

 // And here's the serialization itself: the first argument is where, and the second is what
 mapper.writeValue(writer, cat);

 // Convert everything written to the StringWriter into a String
 String result = writer.toString();
 System.out.println(result);
}

@JsonAutoDetect
class Cat
{
 public String name;
 public int age;
 public int weight;
Cat(){}
}

{"name":"Missy", "age":5, "weight":4}

"Voici comment cela fonctionne:"

"Dans les lignes 4 à 7, nous créons un objet Cat et le remplissons avec des données."

"À la ligne 10, nous créons un objet Writer dans lequel nous écrirons une représentation de chaîne JSON de l'objet."

"À la ligne 13, nous créons un objet ObjectMapper qui effectuera toute la sérialisation."

"À la ligne 16, nous écrivons la représentation JSON de l' objet chat dans writer ."

"Dans les lignes 19-20, nous affichons le résultat à l'écran."

"Tout semble assez simple. Pas plus difficile que la sérialisation native en Java."

"A quoi ressemblerait la désérialisation ?"

"C'est presque pareil, juste plus court :"

public static void main(String[] args) throws IOException
{
 String jsonString = "{ \"name\":\"Missy\", \"age\":5, \"weight\":4}";
 StringReader reader = new StringReader(jsonString);

 ObjectMapper mapper = new ObjectMapper();

 Cat cat = mapper.readValue(reader, Cat.class);
}

@JsonAutoDetect
class Cat
{
 public String name;
 public int age;
 public int weight;

 Cat() { }
}

"C'est encore plus simple. Nous prenons ObjectMapper et lui transmettons une chaîne ou un StringReader avec JSON, ainsi que la classe de l'objet à désérialiser . Ensuite, nous appelons la méthode readValue , et en sortie, nous obtenons un objet Java prêt à l'emploi avec toutes les données."

"Eh bien, c'est exactement comme la désérialisation en Java."

"Presque. Il existe plusieurs exigences imposées aux objets sérialisés dans ou désérialisés à partir de JSON :"

" 1)  les champs doivent être visibles : ils doivent soit être publics soit avoir des getters et des setters"

" 2)  il doit y avoir un constructeur par défaut (un sans paramètres)"

"Je vois. Ce n'est pas trop surprenant. Mais Java a tout sérialisé, même les champs privés."

"Eh bien, c'était Java. Il a accès à des données cachées. Vous ne pouvez pas vous cacher."

"Il y a un troisième aspect ici. J'espère que vous avez remarqué l'annotation @JsonAutoDetect sur la classe Cat ?"

"Ouais. J'étais sur le point de demander ce que c'était."

"Il s'agit d'une annotation : des informations de gestion interne pour le framework Jackson. En utilisant les bonnes annotations, vous disposez d'un contrôle assez flexible sur les résultats de la sérialisation en JSON."

« Cool ! Quel genre d'annotations y a-t-il ? »

"Voici quelques exemples:"

« Comme c'est intéressant ! Y en a-t-il d'autres ?

"Il y en a beaucoup. Mais nous ne les couvrirons pas pour le moment. Maintenant, retravaillons légèrement notre premier exemple :"

public static void main(String[] args) throws IOException
{
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 StringWriter writer = new StringWriter();

 ObjectMapper mapper = new ObjectMapper();

 mapper.writeValue(writer, cat);

 String result = writer.toString();
 System.out.println(result);
}

@JsonAutoDetect
class Cat
{
 @JsonProperty("alias")
 public String name;
 public int age;
 @JsonIgnore
 public int weight;

 Cat() {
 }
}

{"age":5, "alias":"Missy"}

"Le code reste le même, mais j'ai modifié les annotations : j'ai spécifié un autre nom pour le champ de nom : alias. J'ai également marqué le champ de poids comme Ignorer, ce qui a entraîné la modification de l'objet JSON."

"C'est bien que vous puissiez tout personnaliser comme ça. Je pense que je trouverai certainement cela utile."

"Et la désérialisation comprendra comment fonctionner avec cela ? Lors de la désérialisation de JSON vers un objet Java, la valeur du champ alias sera écrite dans le champ de nom de l'objet Cat ?"

"Oui, la désérialisation fonctionnera comme il se doit. C'est intelligent."

« De quoi ne pas être content alors.

"Merci pour cette leçon intéressante, Ellie."