Java

Gson toJson and fromJson for JSON

3 years ago
by Chrysanthus Forcha

Serialization and Deserialization

A file can be saved to the disk or sent over the network by just sending the file as it is, byte by byte, from the beginning (as source code, bytecode or binary code). That is not serialization. Serialization is the process of converting an object into a stream of bytes, for storage or transmission, still as the object. This is not the same as just reading the bytes from the beginning and sending or saving. The opposite of serialization is deserialization. Not mush serialization, as a process, is done with primitive objects on their own.

JSON stands for JavaScript Object Notation. JSON is a format for serialization. A Java object (defined) can be converted to a JSON representation (string) for transmission or saving. For reuse, the JSON representation is converted back to the Java object. Gson is a Java library used for conversion in either direction.

To serialize, use the toJson() method of the Gson object. To deserialize, use the fromJson() method of the Gson object. This article explains the basics of serialization of Java objects to JSON representation, with the toJson() method, and deserialization of JSON representation (string), to Java object, with the fromJson() method.

Article Content

Downloading and Setting Up the Gson Library

The Gson library comes as a JAR file. A library like Gson is referred to as a dependency. It is free to download. The rest of this section explains what the author did with his host Ubuntu OS computer. The reader can repeat or modify the approach.

He created a directory, called dependencies, in /home/user/ to have: /home/user/dependencies, where a user should be replaced by the user-name.

He downloaded the library file, gson-2.8.9.jar, from the hyperlink:

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

and saved it, as it is, in the dependencies directory.

Next, at the command prompt, he set up (entered) a class variable, as follows:

export CLASSPATH=/home/user/dependencies

The Java program should have, as a minimum, the following:

    import com.google.gson.Gson;
    public class TheClass {
        public static void main(String[] args) {

Gsongson = new Gson();
            /*rest of code */
        }
    }

The name of the source code file is TheClass.java. Note the name of the imported package, which is in the gson-2.8.9.jar file. The following command line was used to compile the program into byte code:

javac -classpath /home/user:/home/user/dependencies/gson-2.8.9.jar TheClass.java

Note the switch, -classpath . There are two paths here, separated by a colon (no space around the colon). The first is the path to the main file, TheClass.java; and the second is the path to the library file, gson-2.8.9.jar.

The resulting bytecode is run with the following command line:

java -classpath /home/user:/home/user/dependencies/gson-2.8.9.jar TheClass

The switch and the two paths are still there, in their positions, for the same reasons. The bytecode should run successfully, everything being equal.

Primitive Java Objects

This section illustrates what value a primitive object will have after serialization, as JSON string, and what value it will have after deserialization. To use the toJson() and the fromJson() methods, the Gson object has to be created with a statement like:

Gson gson = new Gson();

where gson is the Gson object to be used with its methods: toJson() for serialization, and fromJson() for deserialization.

byte

Consider the following code within the main() method:

Gsongson = new Gson();
            byte bt = 56;
            String str = gson.toJson(bt);
            byte btr = gson.fromJson(str, byte.class);
System.out.println(btr);

The output is 56. This code serializes and deserializes. Note the second argument from fromJson(), which is byte.class. Serialization of a type object becomes a JSON string, and deserialization should go back to the same type. That is why byte.class is present.

int

Consider the following code within the main() method:

Gsongson = new Gson();
            int in = 0;
            String str = gson.toJson(in);
            int inr = gson.fromJson(str, int.class);
System.out.println(inr);

The output is 0. Note the second argument from fromJson(), which is int.class.

double

Consider the following code within the main() method:

Gsongson = new Gson();
            double db = 7.8;
            String str = gson.toJson(db);
            double dbr = gson.fromJson(str, double.class);
System.out.println(dbr);

The output is 7.8. Note the second argument for fromJson(), which is double.class.

char

Consider the following code within the main() method:

Gsongson = new Gson();
            char ch = 'E';
            String str = gson.toJson(ch);
            char chr = gson.fromJson(str, char.class);
System.out.println(chr);

The output is E. Note the second argument for fromJson(), which is char.class.

boolean

Consider the following code within the main() method:

Gson gson = new Gson();

boolean bl = false;

String str = gson.toJson(bl);

boolean blr = gson.fromJson(str, boolean.class);

System.out.println(blr);

The output is false. Note the second argument for fromJson(), which is boolean.class.

null

Consider the following code within the main() method:

Gson gson = new Gson();

String nl = null;

String str = gson.toJson(nl);

String nlr = gson.fromJson(str, String.class);

System.out.println(nlr);

The output is null. Note the second argument for fromJson(), which is String.class, for the kind of null.

Array

Array Literal

Consider the following code:

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[].class);

System.out.println(dbsR[0]+" "+dbsR[1]+" "+dbsR[2]+" "+dbsR[3]);

The output is:

1.1 2.2 3.3 4.4

After creating the Gson object, a Java double array is created. Next, the array literal is converted into a JSON string. Yes, though the code is concerned with an array here and not a primitive type, the toJson() method is still used, and correspondingly, fromJson() will still be used at the receiver. The JSON string array literal is:

"[1.1, 2.2, 3.3, 4.4]"

This sting is what is fitted into the stream that is transmitted or saved locally. The fromJson() method converts the JSON array string literal to the Java array (literal) at the receiving end.

Consider the following code, which commences with a Java array of strings, where each string is an item on a reading table:

Gson gson = new Gson();

String[] strs = {"pen", "exercise book", null, "text book"};

String str = gson.toJson(strs);

String[] strsR = gson.fromJson(str, String[].class);

System.out.println(strsR[0]+", "+strsR[1]+", "+strsR[2]+", "+strsR[3]);

The output is:

pen, excercise book, null, text book

After creating the Gson object, a Java string array is created. Next, the array literal is converted into a JSON string. The JSON string array literal is:

"["pen", "exercise book", null, "text book"]"

This sting is what is fitted into the stream that is transmitted or saved locally. The fromJson() method converts the JSON array string literal of strings back to the Java array (literal) at the receiving end. Note that the class type (String[]) is needed for backward conversion.

Sending Array Literal with Name of array

The problem with the above scheme is that, at the destination, the array is likely to be given another name for the reconstructed Java code. The array name can be sent, as a single word array, preceding the array of interest to solve this problem. The Java program will receive two arrays at the receiving end and interpret them appropriately.

Object

Object Content

Consider the following code:

    import com.google.gson.Gson;
    class AClass
    {
        int num = 10;
        String str1 = null;
        String str2;
        String str3 = "three";

        int mthd (int it)
            {
                return it;
            }
    }

It begins with the importation of the Gson package, and then there is the description of a class, called AClass. The class has four fields (properties) and one method. One of the values of the fields is null, and another does not have any value. A suitable code in the main() function for this class is:

Gsongson = new Gson();
AClass obj = new AClass();
            String str = gson.toJson(obj);
AClassobjR = gson.fromJson(str, AClass.class);
System.out.println(objR.num+", "+objR.str1+", "+objR.str2+", "+objR.str3);

            int in = objR.mthd(5);
System.out.println(in);

The output consists of two lines, which is:

10, null, null, three

5

After creating the Gson object, another object, obj is instantiated from the class, AClass. Next, the array literal is converted into a JSON string. Yes, though the code is concerned with an instantiated object here and not a primitive type, the toJson() method is still used, and correspondingly, fromJson() will still be used at the receiver. The JSON instantiated (class) object content string is like this:

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

Note the delimiting braces instead of square brackets to differentiate them from JSON. It consists of key/value pairs. The key is separated from its value with a colon. The pairs are separated from one another by commas.

This should be fitted into the stream for transmission or saving locally. Actually, the JSON string for the object is:

{"num":10,"str3":"three"}

The pair for the field with null value is omitted. The pair for the field with the name but without a value is also omitted. The method name and its definition is also omitted. This means that the class information has to be transmitted as well. This can be done with a preceding JSON array. Nothing has been transmitted in the code samples of this article, so the class information is still available to be used in fromJson() .

The fromJson() method converts the JSON instantiated object string back to a Java object at the receiving end. To have the same name for the object, the object’s name has to be transmitted (separately) at the receiving end. After the object has been recreated at the receiving end, the fields and methods can be accessed (called). In the above code, the method is called to result in 5.

Conclusion

JSON is a serialized format. Java objects can be serialized to JSON format for transmission to another computer or to save locally. At the other end, deserialization takes place to have the same object residing at the source. Deserialization does not take place when the object is saved. Not only arrays and instantiated objects can be serialized. Other objects such as maps and collections can be serialized and deserialized. The Java library that can be used for these processes is the Gson library. Its method, toJson() is used for serialization, and its other method, fromJson(), is used for deserialization.

About the author

Chrysanthus Forcha

Discoverer of mathematics Integration from First Principles and related series. Master’s Degree in Technical Education, specializing in Electronics and Computer Software. BSc Electronics. I also have knowledge and experience at the Master’s level in Computing and Telecommunications. Out of 20,000 writers, I was the 37th best writer at devarticles.com. I have been working in these fields for more than 10 years.

View all posts