JSON (JavaScript Object Notation) is text-based lightweight technology. Nowadays it is a dominant and much-expected way of communication in the form of key-value pairs. It is an easier way of transmitting data as it is having nice formatted way. We can nest the objects and also can provide JSON arrays also.
Implementation steps for a maven project
“jsonp” is the reference implementation for Java JSON Processing API. In a maven project, the required dependency has to be specified in pom.xml
XML
<dependency> <groupId>org.glassfish</groupId> <artifactId>javax.json</artifactId> <version>1.0.2</version></dependency> |
JSON processing can be done in 2 ways. They are provided by JSON API
| Object Model API | Features are similar to DOM Parser and it holds good for small objects. |
| Streaming API | Features are similar to StAX Parser and it holds good for large objects. Here we no need to keep the whole object in memory. |
Interfaces of Java JSON API:
| javax.json.JsonReader | To read a JsonObject or an array of JsonObject JsonReader is used. It is available from JSON class or JsonReaderFactory |
| javax.json.JsonWriter | Write JSON object to the output stream |
| javax.json.stream.JsonParser | Working functionality is a pull parser type and can provide support for reading JSON objects in a streaming way. |
| javax.json.stream.JsonGenerator | To write JSON objects in a streaming way. |
| javax.json.Json | This class has a variety of methods for creating these objects and their factories. |
| javax.json.JsonObject | This is the representation of immutable JSON object value. |
Let us see the above functionalities one by one. First let us take a sample JSON object. It may be stored in a file named “gfgwriterfile.txt”. Key-value pair, the data is available.
Example: “id” is the key and its value is 123
{
"id":123,
"writerName":"GeekWriterA",
"status":true,
"address":{
"street":"MG Road",
"city":"Bangalore",
"zipcode":560100
},
"phoneNumbers":[1122334455, 1234567890],
"role":"HitechWriter"
}
We need to have Java bean classes to represent the above JSON format. Let us have 2 Java bean classes namely “Address.java” and “GFGWriter.java”
Address.java
Java
public class Address { // attributes for address private String street; private String city; private int zipcode; // necessary getters and setters public String getStreet() { return street; } public void setStreet(String street) { this.street = street; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } public int getZipcode() { return zipcode; } public void setZipcode(int zipcode) { this.zipcode = zipcode; } @Override public String toString() { return getStreet() + ", " + getCity() + ", " + getZipcode(); }} |
We are going to use Address.java inside “GFGWriter.java”
GFGWriter.java
Java
import java.util.Arrays; public class GFGWriter { private int id; private String writerName; private boolean status; private Address address; private long[] phoneNumbers; private String role; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getWriterName() { return writerName; } public void setWriterName(String writerName) { this.writerName = writerName; } public boolean getStatus() { return status; } public void setStatus(boolean status) { this.status = status; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } public long[] getPhoneNumbers() { return phoneNumbers; } public void setPhoneNumbers(long[] phoneNumbers) { this.phoneNumbers = phoneNumbers; } public String getRole() { return role; } public void setRole(String role) { this.role = role; } @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append( "***** GFG Portal Writer Details *****\n"); sb.append("ID=" + getId() + "\n"); sb.append("Writer Name=" + getWriterName() + "\n"); sb.append("Status=" + getStatus() + "\n"); sb.append("Role=" + getRole() + "\n"); sb.append("Phone Numbers=" + Arrays.toString(getPhoneNumbers()) + "\n"); sb.append("Address=" + getAddress()); sb.append("\n*****************************"); return sb.toString(); }} |
toString() method can be overridden as per our requirement and here, just a human-readable way it is written. Now let us see by using Java bean methods, let us see how to read the Java JSON
GFGWriterJSONReader.java (Here from gfgwriter.txt, we are going to read and display the data)
Java
import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream; import javax.json.Json;import javax.json.JsonArray;import javax.json.JsonObject;import javax.json.JsonReader;import javax.json.JsonValue; import com.gfg.model.Address;import com.gfg.model.GFGWriter; public class GFGWriterJSONReader { public static final String JSON_FILE="gfgwriter.txt"; public static void main(String[] args) throws IOException { InputStream fis = new FileInputStream(JSON_FILE); // create JsonReader object JsonReader jsonReader = Json.createReader(fis); // get JsonObject from JsonReader JsonObject jsonObject = jsonReader.readObject(); // we can close IO resource and JsonReader now jsonReader.close(); fis.close(); // Retrieve data from JsonObject and create Employee bean GFGWriter gfgWriter = new GFGWriter(); gfgWriter.setId(jsonObject.getInt("id")); gfgWriter.setWriterName(jsonObject.getString("writerName")); gfgWriter.setStatus(jsonObject.getBoolean("status")); gfgWriter.setRole(jsonObject.getString("role")); // reading arrays from json JsonArray jsonArray = jsonObject.getJsonArray("phoneNumbers"); long[] numbers = new long[jsonArray.size()]; int index = 0; for(JsonValue value : jsonArray){ numbers[index++] = Long.parseLong(value.toString()); } gfgWriter.setPhoneNumbers(numbers); // reading inner object from json object JsonObject innerJsonObject = jsonObject.getJsonObject("address"); Address address = new Address(); address.setStreet(innerJsonObject.getString("street")); address.setCity(innerJsonObject.getString("city")); address.setZipcode(innerJsonObject.getInt("zipcode")); gfgWriter.setAddress(address); // print GFGWriter bean information System.out.println(gfgWriter); } } |
JsonReaderFactory implements Factory Design Pattern. Implementation is straightforward. On running the file, we will get the output as follows
Let us see the ways to write the JSON
GFGWriterCreation.java
Java
import com.gfg.model.Address;import com.gfg.model.GFGWriter;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.OutputStream;import javax.json.Json;import javax.json.JsonArrayBuilder;import javax.json.JsonObject;import javax.json.JsonObjectBuilder;import javax.json.JsonWriter; public class GFGWriterCreation { public static void main(String[] args) throws FileNotFoundException { GFGWriter gfgWriter = createGFGWriter(); JsonObjectBuilder writerBuilder = Json.createObjectBuilder(); JsonObjectBuilder addressBuilder = Json.createObjectBuilder(); JsonArrayBuilder phoneNumberBuilder = Json.createArrayBuilder(); for (long phone : gfgWriter.getPhoneNumbers()) { phoneNumberBuilder.add(phone); } addressBuilder .add("street", gfgWriter.getAddress().getStreet()) .add("city", gfgWriter.getAddress().getCity()) .add("zipcode", gfgWriter.getAddress().getZipcode()); writerBuilder.add("id", gfgWriter.getId()) .add("writerName", gfgWriter.getWriterName()) .add("status", gfgWriter.getStatus()) .add("role", gfgWriter.getRole()); writerBuilder.add("phoneNumbers", phoneNumberBuilder); writerBuilder.add("address", addressBuilder); JsonObject gfgWriterJsonObject = writerBuilder.build(); System.out.println("GFGWriter JSON String\n" + gfgWriterJsonObject); // write to file OutputStream os = new FileOutputStream("gfgwriter.txt"); JsonWriter jsonWriter = Json.createWriter(os); jsonWriter.writeObject(gfgWriterJsonObject); jsonWriter.close(); } public static GFGWriter createGFGWriter() { GFGWriter gfgWriter = new GFGWriter(); gfgWriter.setId(100); gfgWriter.setWriterName("GeekA"); gfgWriter.setStatus(false); gfgWriter.setPhoneNumbers( new long[] { 123456, 987654 }); gfgWriter.setRole("Beginner"); Address add = new Address(); add.setCity("Bangalore"); add.setStreet("MG Road"); add.setZipcode(560100); gfgWriter.setAddress(add); return gfgWriter; }} |
The JSON object is also getting saved in the ‘gfgwriter.txt’ file via the above code. JsonObjectBuilder implements builder pattern. On running the above program, we will be getting the output as
Java JSON Parser Example
GFGWriterJSONParser.java
Java
import com.gfg.model.Address;import com.gfg.model.GFGWriter;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.util.ArrayList;import java.util.List;import javax.json.Json;import javax.json.stream.JsonParser;import javax.json.stream.JsonParser.Event; public class GFGWriterJSONParser { public static final String FILE_NAME = "gfgwriterfile.txt"; public static void main(String[] args) throws IOException { InputStream fis = new FileInputStream(FILE_NAME); JsonParser jsonParser = Json.createParser(fis); GFGWriter gfgWriter = new GFGWriter(); Address address = new Address(); String keyName = null; List<Long> phoneNums = new ArrayList<Long>(); while (jsonParser.hasNext()) { Event event = jsonParser.next(); switch (event) { case KEY_NAME: keyName = jsonParser.getString(); break; case VALUE_STRING: setStringValues(gfgWriter, address, keyName, jsonParser.getString()); break; case VALUE_NUMBER: setNumberValues(gfgWriter, address, keyName, jsonParser.getLong(), phoneNums); break; case VALUE_FALSE: setBooleanValues(gfgWriter, address, keyName, false); break; case VALUE_TRUE: setBooleanValues(gfgWriter, address, keyName, true); break; case VALUE_NULL: // don't set anything break; default: // we are not looking for other events } } gfgWriter.setAddress(address); long[] nums = new long[phoneNums.size()]; int index = 0; for (Long l : phoneNums) { nums[index++] = l; } gfgWriter.setPhoneNumbers(nums); System.out.println(gfgWriter); // close resources fis.close(); jsonParser.close(); } private static void setNumberValues(GFGWriter gfgWriter, Address address, String keyName, long value, List<Long> phoneNumbers) { switch (keyName) { case "zipcode": address.setZipcode((int)value); break; case "id": gfgWriter.setId((int)value); break; case "phoneNumbers": phoneNumbers.add(value); break; default: System.out.println("Unknown element with key=" + keyName); } } private static void setBooleanValues(GFGWriter gfgWriter, Address address, String key, boolean value) { if ("status".equals(key)) { gfgWriter.setStatus(value); } else { System.out.println("Unknown element with key=" + key); } } private static void setStringValues(GFGWriter gfgWriter, Address address, String key, String value) { switch (key) { case "writerName": gfgWriter.setWriterName(value); break; case "role": gfgWriter.setRole(value); break; case "city": address.setCity(value); break; case "street": address.setStreet(value); break; default: System.out.println("Unkonwn Key=" + key); } }} |
On running, we will get the same output as JSON Reader. That is similar output what we get during JSON reader. Complexity will be more if we need to parse complex JSON. Next, let us see JsonGeneratorExample
GFGWriterJSONGenerator.java
Java
import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStream; import javax.json.Json;import javax.json.stream.JsonGenerator; import com.gfg.model.GFGWriter; public class GFGWriterJSONGenerator { public static void main(String[] args) throws IOException { OutputStream fos = new FileOutputStream("gfgwriter_stream.txt"); JsonGenerator jsonGenerator = Json.createGenerator(fos); GFGWriter gfgWriter = GFGWriterCreation.createGFGWriter(); jsonGenerator.writeStartObject(); // { jsonGenerator.write("id", gfgWriter.getId()); // "id":100 jsonGenerator.write("writerName", gfgWriter.getWriterName()); jsonGenerator.write("role", gfgWriter.getRole()); jsonGenerator.write("status", gfgWriter.getStatus()); jsonGenerator.writeStartObject("address") // start of address object .write("street", gfgWriter.getAddress().getStreet()) .write("city",gfgWriter.getAddress().getCity()) .write("zipcode",gfgWriter.getAddress().getZipcode()) .writeEnd(); // end of address object jsonGenerator.writeStartArray("phoneNumbers"); // start of phone num array for(long num : gfgWriter.getPhoneNumbers()){ jsonGenerator.write(num); } jsonGenerator.writeEnd(); // end of phone num array jsonGenerator.writeEnd(); // } jsonGenerator.close(); } } |
On running the above program, we can see the contents written in “gfgwriter_stream.txt”, “JsonGenerator” is very easy to use and its specialty is it provides good performance for large data.
