Gson Tojson et Fromjson pour JSON

Sérialisation et désérialisation

Un fichier peut être enregistré sur le disque ou envoyé sur le réseau en envoyant simplement le fichier tel qu'il est, octet par octet, depuis le début (comme code source, bytecode ou code binaire). Ce n'est pas la sérialisation. La sérialisation est le processus de conversion d'un objet en un flux d'octets, pour le stockage ou la transmission, toujours comme l'objet. Ce n'est pas la même chose que la simple lecture des octets depuis le début et l'envoi ou l'enregistrement. L'opposé de la sérialisation est la désérialisation. Pas la sérialisation de la bouillie, en tant que processus, se fait avec eux-mêmes avec des objets primitifs.

JSON représente la notation d'objet JavaScript. JSON est un format de sérialisation. Un objet Java (défini) peut être converti en une représentation JSON (chaîne) pour la transmission ou la sauvegarde. Pour réutiliser, la représentation JSON est convertie à l'objet Java. GSON est une bibliothèque Java utilisée pour la conversion dans les deux sens.

Pour sérialiser, utilisez la méthode tojson () de l'objet GSON. Pour désérialiser, utilisez la méthode Fromjson () de l'objet GSON. Cet article explique les bases de la sérialisation des objets Java à la représentation JSON, avec la méthode Tojson (), et la désérialisation de la représentation JSON (String), à l'objet Java, avec la méthode Fromjson ().

Contenu de l'article

• Télécharger et configurer la bibliothèque GSON
• Objets Java primitifs
• Déployer
• Objet
• Conclusion

Télécharger et configurer la bibliothèque GSON

La bibliothèque GSON est un fichier de pot. Une bibliothèque comme GSON est appelée dépendance. C'est gratuit à télécharger. Le reste de cette section explique ce que l'auteur a fait avec son ordinateur hôte Ubuntu OS. Le lecteur peut répéter ou modifier l'approche.

Il a créé un répertoire, appelé dépendances, dans / home / utilisateur / pour avoir: / home / utilisateur / dépendances, où un utilisateur doit être remplacé par le nom d'utilisateur.

Il a téléchargé le fichier de bibliothèque, GSON-2.8.9.pot, de l'hyperlien:

https: // Recherche.maven.org / remotecontent?filepath = com / google / code / gson / gson / 2.8.9 / gson-2.8.9.pot

et l'a enregistré, tel qu'il est, dans le répertoire des dépendances.

Ensuite, à l'invite de commande, il a configuré (entré) une variable de classe, comme suit:

exporter classpath = / home / utilisateur / dépendances

Le programme Java devrait avoir, au minimum, ce qui suit:

Importer com.Google.gon.GSON;
classe publique TheClass
public static void main (String [] args)
Gsongson = new gson ();
/ * reste du code * /

Le nom du fichier de code source est la classe.Java. Remarque le nom du package importé, qui se trouve dans le GSON-2.8.9.dossier. La ligne de commande suivante a été utilisée pour compiler le programme en code d'octets:

javac -classpath / home / utilisateur: / home / user / dépendances / gson-2.8.9.bocal theclass.Java

Notez l'interrupteur, -classpath . Il y a deux chemins ici, séparés par un côlon (pas d'espace autour du côlon). Le premier est le chemin d'accès au fichier principal, la classe.Java; Et le second est le chemin d'accès au fichier de bibliothèque, GSON-2.8.9.pot.

Le bytecode résultant est exécuté avec la ligne de commande suivante:

java -classpath / home / utilisateur: / home / user / dépendances / gson-2.8.9.bocal theclass

L'interrupteur et les deux chemins sont toujours là, dans leurs positions, pour les mêmes raisons. Le bytecode devrait fonctionner avec succès, tout étant égal.

Objets Java primitifs

Cette section illustre quelle valeur un objet primitif aura après la sérialisation, en tant que chaîne JSON, et quelle valeur elle aura après la désérialisation. Pour utiliser les méthodes ToJson () et FromjSon (), l'objet GSON doit être créé avec une déclaration comme:

Gson gson = new gson ();

où GSON est l'objet GSON à utiliser avec ses méthodes: tojson () pour la sérialisation, et fromjson () pour la désérialisation.

octet

Considérez le code suivant dans la méthode principale ():

Gsongson = new gson ();
octet bt = 56;
String str = gson.Tojson (BT);
octet btr = gson.Fromjson (Str, octet.classe);
Système.dehors.println (btr);

La sortie est 56. Ce code sérialise et désérialise. Notez le deuxième argument de Fromjson (), qui est l'octet.classe. La sérialisation d'un objet de type devient une chaîne JSON, et la désérialisation devrait revenir au même type. C'est pourquoi octet.La classe est présente.

int

Considérez le code suivant dans la méthode principale ():

Gsongson = new gson ();
int dans = 0;
String str = gson.tojson (in);
int inr = gson.Fromjson (str, int.classe);
Système.dehors.println (inr);

La sortie est 0. Notez le deuxième argument de Fromjson (), qui est int.classe.

double

Considérez le code suivant dans la méthode principale ():

Gsongson = new gson ();
double db = 7.8;
String str = gson.Tojson (DB);
double dbr = gson.Fromjson (str, double.classe);
Système.dehors.println (dbr);

La sortie est 7.8. Notez le deuxième argument pour fromjson (), qui est double.classe.

carboniser

Considérez le code suivant dans la méthode principale ():

Gsongson = new gson ();
char ch = 'e';
String str = gson.tojson (ch);
char chr = gson.Fromjson (Str, Char.classe);
Système.dehors.println (Chr);

La sortie est e. Notez le deuxième argument pour Fromjson (), qui est Char.classe.

booléen

Considérez le code suivant dans la méthode principale ():

Gson gson = new gson ();
booléen bl = false;
String str = gson.Tojson (BL);
booléen blr = gson.Fromjson (Str, Boolean.classe);
Système.dehors.println (blr);

La sortie est fausse. Notez le deuxième argument pour fromjson (), qui est booléen.classe.

nul

Considérez le code suivant dans la méthode principale ():

Gson gson = new gson ();
String nl = null;
String str = gson.Tojson (NL);
String nlr = gson.Fromjson (str, string.classe);
Système.dehors.println (nlr);

La sortie est nul. Notez le deuxième argument pour fromjson (), qui est une chaîne.classe, pour le genre de null.

Déployer

Arrayant littéral

Considérez le code suivant:

Gson gson = new gson ();
double [] dbs = 1.1, 2.2, 3.3, 4.4;
String str = gson.Tojson (DBS);
double [] dbsr = gson.Fromjson (str, double [].classe);
Système.dehors.println (dbsr [0] + "" + dbsr [1] + "" + dbsr [2] + "" + dbsr [3]);

La sortie est:

1.1 2.2 3.3 4.4

Après avoir créé l'objet GSON, un double tableau Java est créé. Ensuite, le littéral du tableau est converti en une chaîne JSON. Oui, bien que le code s'intéresse à un tableau ici et non à un type primitif, la méthode tojson () est toujours utilisée, et en conséquence, fromjson () sera toujours utilisée au récepteur. Le littéral JSON String Array est:

"[1.1, 2.2, 3.3, 4.4] "

Cette piqûre est ce qui est monté dans le flux qui est transmis ou enregistré localement. La méthode Fromjson () convertit la chaîne de tableau JSON littéral au tableau Java (littéral) à l'extrémité de réception.

Considérez le code suivant, qui commence par un tableau Java de chaînes, où chaque chaîne est un élément sur une table de lecture:

Gson gson = new gson ();
String [] strS = "Pen", "Exercice Book", NULL, "Text Book";
String str = gson.Tojson (STR);
String [] strSr = gson.fromjson (str, string [].classe);
Système.dehors.println (strSr [0] + "," + strSr [1] + "," + strSr [2] + "," + strSr [3]);

La sortie est:

stylo, livre d'exercice, nul, manuel

Après avoir créé l'objet GSON, un tableau de chaîne Java est créé. Ensuite, le littéral du tableau est converti en une chaîne JSON. Le littéral JSON String Array est:

"[" stylo "," livre d'exercice ", null," manuel "]"

Cette piqûre est ce qui est monté dans le flux qui est transmis ou enregistré localement. La méthode Fromjson () convertit la chaîne JSON Litteral de cordes à la matrice Java (littéral) à l'extrémité de réception. Notez que le type de classe (String []) est nécessaire pour la conversion vers l'arrière.

Envoi du plateau littéral avec le nom du tableau

Le problème avec le schéma ci-dessus est que, à destination, le tableau est susceptible de recevoir un autre nom pour le code Java reconstruit. Le nom du tableau peut être envoyé, comme un seul tableau de mots, précédant le tableau d'intérêt pour résoudre ce problème. Le programme Java recevra deux tableaux à la fin de réception et les interprétera de manière appropriée.

Objet

Contenu d'objet

Considérez le code suivant:

Importer com.Google.gon.GSON;
classe de classe

int num = 10;
String str1 = null;
String str2;
String str3 = "trois";
int mthd (int it)

rends le;

Il commence par l'importation du package GSON, puis il y a la description d'une classe, appelée Aclass. La classe a quatre champs (propriétés) et une méthode. L'une des valeurs des champs est nul, et une autre n'a aucune valeur. Un code approprié dans la fonction principale () pour cette classe est:

Gsongson = new gson ();
Aclass obj = new aclass ();
String str = gson.Tojson (obj);
Aclassobjr = gson.Fromjson (Str, Aclass.classe);
Système.dehors.println (objr.num + "," + objr.str1 + "," + objr.str2 + "," + objr.str3);
int in = objr.MTHD (5);
Système.dehors.println (in);

La sortie se compose de deux lignes, qui est:

10, null, null, trois
5

Après avoir créé l'objet GSON, un autre objet, OBJ est instancié à partir de la classe, Aclass. Ensuite, le littéral du tableau est converti en une chaîne JSON. Oui, bien que le code s'intéresse à un objet instancié ici et non à un type primitif, la méthode Tojson () est toujours utilisée, et en conséquence, Fromjson () sera toujours utilisée au récepteur. La chaîne de contenu d'objet instanciée JSON (classe) est comme ceci:

"num": 10, "str1": null, "str2: null," str3 ":" trois "," mthd ":" int mthd (int it) return it; "

Notez les accolades de délimitation au lieu des crochets pour les différencier de JSON. Il se compose de paires de clés / valeur. La clé est séparée de sa valeur avec un côlon. Les paires sont séparées les unes des autres par des virgules.

Cela doit être installé dans le flux pour la transmission ou la sauvegarde localement. En fait, la chaîne JSON pour l'objet est:

"num": 10, "str3": "trois"

La paire pour le champ avec valeur nulle est omise. La paire pour le champ avec le nom mais sans valeur est également omise. Le nom de la méthode et sa définition sont également omis. Cela signifie que les informations de classe doivent également être transmises. Cela peut être fait avec un tableau JSON précédent. Rien n'a été transmis dans les échantillons de code de cet article, donc les informations de classe sont toujours disponibles pour être utilisées dans Fromjson () .

La méthode fromjson () convertit la chaîne d'objet instanciée JSON à un objet Java à l'extrémité de réception. Pour avoir le même nom pour l'objet, le nom de l'objet doit être transmis (séparément) à l'extrémité de réception. Une fois l'objet recréé à la fin de réception, les champs et les méthodes sont accessibles (appelés). Dans le code ci-dessus, la méthode est appelée pour entraîner 5.

Conclusion

JSON est un format sérialisé. Les objets Java peuvent être sérialisés au format JSON pour la transmission vers un autre ordinateur ou pour enregistrer localement. À l'autre extrémité, la désérialisation a lieu pour avoir le même objet résidant à la source. La désérialisation ne se déroule pas lorsque l'objet est enregistré. Non seulement les tableaux et les objets instanciés peuvent être sérialisés. D'autres objets tels que les cartes et les collections peuvent être sérialisés et désérialisés. La bibliothèque Java qui peut être utilisée pour ces processus est la bibliothèque GSON. Sa méthode, Tojson () est utilisée pour la sérialisation, et son autre méthode, Fromjson (), est utilisée pour la désérialisation.