JSON Tutorials and Guide

Creating JSON Data Using The Java JSON API (JSR 353)

October 14, 2013 by Mohamed Sanaulla Leave a Comment

JSON has been around for quite sometime now and lot of languages are offering out of the box support for parsing and creating JSON data. The JDK didn’t have support for parsing and creating JSON data out of the box. One had to make use of libraries for parsing and creating JSON data like Google GSON among others. With JSR 353 and its reference implementation we can hope that it becomes a part of JDK so that we are less dependent on 3rd party libraries. JavaEE 7 reference implementation that comes with Glassfish 4 already contains the reference implementation for JSR 353 and I have already covered few post which show how to parse JSON data in JavaEE 7.

In this post I will make use of the reference implementation of JSR 353 outside of the JavaEE 7 i.e outside of a server application deployed on Glassfish 4. Firstly you can get access to the reference implementation from here. As this JSR reference implementation is still not part of JDK we would have to download the external jars for this implementation and use it like the way we used 3rd party libraries i.e add them to your application’s or project’s classpath. You will have to download the following 2 jars and add them to your project’s class path before proceeding with the rest of the post:

This post is divided into 2 parts namely:

Creating JSON data using the JSON Streaming API.
Creating JSON data using the JSON Object Model API.

But before that you should have the 2 jars mentioned above in you classpath.

JSON data to be created

In this post my aim is to show you all how to create the following JSON data using the JSON Streaming API and JSON Object Model API.

Creating JSON Data Using The JSON Streaming API

We have already seen how to parse the JSON data using the JSON Streaming API. Lets now look at how to create the JSON data using the JSON Streaming API. The following classes from the API will be used for creating the data:

JsonGenerator: Writes JSON data to an output source in a streaming way. The class Json contains methods to create generators for character or output streams (Writer and OutputStream).
Json: Factory class for creating JSON processing objects. This class provides the most commonly used methods for creating these objects and their corresponding factories. The factory classes provide all the various ways to create these objects.
StringWriter: A character stream that collects its output in a string buffer, which can then be used to construct a string.

One can write the JSON data to any character stream or a byte stream. In this sample I will be using a StringWriter to buffer up the JSON data and then generate the string representing the JSON data. The below method is used to create JSON data using the Streaming API. If you see the code below you can find out some kind of a pattern appearing while you invoke different methods to create the data, the pattern some what appears like an language. Yes, if you have guessed it as an DSL you are right. Its actually an Internal DSL and the technique is called Method Chaining. This is the term used by Martin Fowler in his DSL book.

[code lang=”java”]
private static void buildJsonUsingStreamingApi() {

//Create a StringWriter instance to buffer the JSON data.
StringWriter writer = new StringWriter();

//Create a JSON generator backed by the StringWriter instance created above.
JsonGenerator generator = Json.createGenerator(writer);

//Start building the JSON Data- Uses Method chaining technique.
//The JSON data gets streamed in the buffer as and when the
//different methods are invoked.
generator.writeStartArray()
.writeStartObject()//Indicates the start of an JSON object
.write("parentid", 23424900)
.write("name","Mexico City")
.write("url", "http://where.yahooapis.com/v1/place/116545")
.writeStartObject("placeType")//Creating a nested object i.e an JSON object withing another object
.write("name","Town")
.write("code", 7)
.writeEnd()
.write("woeid", 116545)
.writeEnd()//Indicates the end of an JSON object
.writeStartObject()
.write("name","Jackson")
.write("url", "http://where.yahooapis.com/v1/place/2428184")
.writeStartObject("placeType")
.write("name","Town")
.write("code", 7)
.writeEnd()
.write("parentid", 23424977)
.write("woeid", 2428184)
.writeEnd()
.writeEnd();//Indicates the end of the JSON array.
//Writes the data in the buffer to the String buffer.
generator.flush();

//Prints the JSON data onto the console.
System.out.println(writer.toString());
}
[/code]

In the above code you have seen the write() being invoked with different data types namely: Integer, String. If we happen to look at the API supported by JsonGenerator, we can see that it supports the following data types namely: BigDecimal, BigInteger, boolean, double, int, long, String, null and any other JsonValue like JsonObject, JsonArray, JsonString, JsonNumber, JsonValue.TRUE, JsonValue.FASLE, JsonValue.NULL. And these are the data types supported by the JSR 353 JSON API.

The above code should produce the following output:

[code lang=”javascript”]
//Start of JSON Array.
[
//Start of JSON Object
{"parentid":23424900,"name":"Mexico City","url":"http://where.yahooapis.com/v1/place/116545","placeType":
//Start of nested JSON Object
{"name":"Town","code":7},"woeid":116545},
//End of nested JSON Object
//End of JSON Object

//Start of another JSON Object
{"name":"Jackson","url":"http://where.yahooapis.com/v1/place/2428184","placeType":{"name":"Town","code":7},"parentid":23424977,"woeid":2428184}
//End of another JSON Object

]
//End of JSON Array
[/code]

Creating JSON Data Using The JSON Object Model API

We have already seen how to parse the JSON data using the JSON Object Model API. Lets now look at how to create the JSON data using the JSON Object Model API. The following classes and interfaces from the API will be used for creating the data:

Json: Factory class for creating JSON processing objects. This class provides the most commonly used methods for creating these objects and their corresponding factories. The factory classes provide all the various ways to create these objects.
JsonArray: JsonArray represents an immutable JSON array (an ordered sequence of zero or more values). It also provides an unmodifiable list view of the values in the array.
JsonObject: JsonObject class represents an immutable JSON object value (an unordered collection of zero or more name/value pairs). It also provides unmodifiable map view to the JSON object name/value mappings.
JsonArrayBuilder: A builder for creating JsonArray models from scratch. This interface initializes an empty JSON array model and provides methods to add values to the array model and to return the resulting array. The methods in this class can be chained to add multiple values to the array.
JsonObjectBuilder: A builder for creating JsonObject models from scratch. This interface initializes an empty JSON object model and provides methods to add name/value pairs to the object model and to return the resulting object. The methods in this class can be chained to add multiple name/value pairs to the object.
JsonWriter: Writes a JSON object or array structure to an output source.

If you happen to read the article on parsing the JSON data using Object Model API you will notice that the classes used in both the places are exactly similar and the only difference being that in the parsing scenario we make use of the readers and in the creating scenario we make use of the builders. This API also uses the approach of Method chaining which is also similar to the Builder Pattern to create the object tree representing the JSON data. Unlike the Streaming API where we have the JSON data being buffered in the stream, in this Object Model API we are continuously building the object tree in the memory which represents the JSON data. We need to make use of a JsonWriter to produce the JSON data an output stream. And this Object Model API supports the same data types supported by the Streaming API. Lets look at the code which is used to create the JSON data using Object Model API:

[code lang=”java”]
private static void buildJsonUsingObjectModelApi() {
System.out.println("Json Building using Object Model API");
JsonArray jsonArray =
//Create an Array Builder to build an JSON Array
Json.createArrayBuilder()
.add(Json.createObjectBuilder()//Create an Object builder to build JSON Object
.add("parentid", 23424900)
.add("name","Jackson")
.add("url", "http://where.yahooapis.com/v1/place/2428184")
.add("placeType", Json.createObjectBuilder()//Another nested JSON Object
.add("name", "Town")
.add("code",7)
)
.add("woeid", 116545)
.build()//The JSON Object completely constructed.
)
.add(Json.createObjectBuilder()//Another object builder to build JSON Object.
.add("name","Mexico City")
.add("url", "http://where.yahooapis.com/v1/place/116545")
.add("placeType", Json.createObjectBuilder()
.add("name", "Town")
.add("code",7)
)
.add("parentid", 23424977)
.add("woeid", 2428184)
.build()
)
.build();
StringWriter writer = new StringWriter();

//Extracting the JSON data from the JSON object tree into the string.
Json.createWriter(writer).writeArray(jsonArray);

System.out.println(writer.toString());

}
[/code]

The output produced by the above code is:

[code lang=”javascript”]
Json Building using Object Model API
[{"parentid":23424900,"name":"Jackson","url":"http://where.yahooapis.com/v1/place/2428184","placeType":{"name":"Town","code":7},"woeid":116545},{"name":"Mexico City","url":"http://where.yahooapis.com/v1/place/116545","placeType":{"name":"Town","code":7},"parentid":23424977,"woeid":2428184}]
[/code]

When To Use Streaming API and Object Model API

If you want the JSON data to be written to a character stream like a file or to a byte stream then the Streaming API will be the best choice as it directly perform the writing operation into the buffer without constructing the object tree in the memory i.e there is not intermediate form generated before the final JSON data is created.
If you want to hold the JSON data as an object tree in the memory i.e not write to any stream but store the tree in the memory so that one can reuse the JSON data without need to reparse it or one can also serialize the object tree to persist/save the JSON data. Here the JSON data will be represented in the form of an object tree.

The Java JSON API (JSR 353) Example Source code

The complete executable source code for the above example without the comments is:

[code lang=”java”]
import java.io.StringWriter;
import javax.json.Json;
import javax.json.JsonArray;
import javax.json.stream.JsonGenerator;

public class JsonApiDemo {

public static void main(String[] args) {

buildJsonUsingStreamingApi();
buildJsonUsingObjectModelApi();
}

private static void buildJsonUsingStreamingApi() {

StringWriter writer = new StringWriter();
JsonGenerator generator = Json.createGenerator(writer);

generator.writeStartArray()
.writeStartObject()
.write("parentid", 23424900)
.write("name","Mexico City")
.write("url", "http://where.yahooapis.com/v1/place/116545")
.writeStartObject("placeType")
.write("name","Town")
.write("code", 7)
.writeEnd()
.write("woeid", 116545)
.writeEnd()
.writeStartObject()
.write("name","Jackson")
.write("url", "http://where.yahooapis.com/v1/place/2428184")
.writeStartObject("placeType")
.write("name","Town")
.write("code", 7)
.writeEnd()
.write("parentid", 23424977)
.write("woeid", 2428184)
.writeEnd()
.writeEnd();
generator.flush();
System.out.println(writer.toString());
}

private static void buildJsonUsingObjectModelApi() {
System.out.println("Json Building using Object Model API");
JsonArray jsonArray =
Json.createArrayBuilder()
.add(Json.createObjectBuilder()
.add("parentid", 23424900)
.add("name","Jackson")
.add("url", "http://where.yahooapis.com/v1/place/2428184")
.add("placeType", Json.createObjectBuilder()
.add("name", "Town")
.add("code",7))
.add("woeid", 116545)
.build())
.add(Json.createObjectBuilder()
.add("name","Mexico City")
.add("url", "http://where.yahooapis.com/v1/place/116545")
.add("placeType", Json.createObjectBuilder()
.add("name", "Town")
.add("code",7))
.add("parentid", 23424977)
.add("woeid", 2428184)
.build())
.build();
StringWriter writer = new StringWriter();
Json.createWriter(writer).writeArray(jsonArray);
System.out.println(writer.toString());

}
}

[/code]

And the output is:

[code lang=”javascript”]
[{"parentid":23424900,"name":"Mexico City","url":"http://where.yahooapis.com/v1/place/116545","placeType":{"name":"Town","code":7},"woeid":116545},{"name":"Jackson","url":"http://where.yahooapis.com/v1/place/2428184","placeType":{"name":"Town","code":7},"parentid":23424977,"woeid":2428184}]
Json Building using Object Model API
[{"parentid":23424900,"name":"Jackson","url":"http://where.yahooapis.com/v1/place/2428184","placeType":{"name":"Town","code":7},"woeid":116545},{"name":"Mexico City","url":"http://where.yahooapis.com/v1/place/116545","placeType":{"name":"Town","code":7},"parentid":23424977,"woeid":2428184}]
[/code]

JSON Processing in JavaEE 7- Using Object Model API

October 11, 2013 by Mohamed Sanaulla Leave a Comment

In my previous post about JSON processing I introduced you to the sample application and then showed how one can make use of the Streaming API to parse the JSON data. The JSON Streaming API was not suited for scenarios explained in my previous post. In such scenarios one can make use of the Object Model API to parse the JSON data.

Sample JSON Data for reference

Lets consider the JSON data we had generated in our previous post:

[code lang=”javascript”]
[
{
"key":"sticky_1381306898171",
"value":"how aout his"
},
{
"key":"sticky_1381306902222",
"value":"Another one"
},
{
"key":"sticky_1381309254661",
"value":"adding few more …"
}
]
[/code]

And consider the websocket code from the previous post:

[code lang=”java”]
import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

/**
* Demo for parsing the JSON using Streaming API.
*/
@ServerEndpoint("/saveStickNotes")
public class TodoApplicationEndPoint {

private Map<String, String> stickyNotes;

@OnMessage
public void receiveMessage(String message, Session session){
parseUsingStreamingAPI(message);
parseUsingObjectAPI(message);
}

private void parseUsingStreamingAPI(String message) {
//Parsing JSON data using Streaming API
//Check the previous post in this series to get implementation of this method.
}

private void parseUsingObjectAPI(String message) {
//TODO: Parsing the JSON data using Object Model API
//This method implementation will be shown in this post.
}
}
[/code]

In the above code I have removed the implementation of the method parseUsingStreamingAPI and the same can be seen in the previous post. In this article the focus will be on implementing the method parseUsingObjectAPI.

Important classes to be aware of to understand Object Model API

The various classes which one should be familiar with to understand and using the Object Model API to parse JSON data are:(Here I am only going to list classes for parsing, in my next post I will show how one can create JSON data and also list the classes used for it)

JsonReader: Reads a JSON object or an array structure from an input source. The class Json contains methods to create readers from input sources (InputStream and Reader).
JsonArray: JsonArray represents an immutable JSON array (an ordered sequence of zero or more values). It also provides an unmodifiable list view of the values in the array.
JsonObject: JsonObject class represents an immutable JSON object value (an unordered collection of zero or more name/value pairs). It also provides unmodifiable map view to the JSON object name/value mappings.

In the sample shown in this article I am going to make use of the above three classes to parse the JSON data.

Parsing the JSON Data using Object Model API

Now that you have seen the structure of our JSON data as well as the various classes we would be using, lets get to the actual code which does the parsing. If you look at the JSON data shown above (If you are not familiar with JSON please read What is JSON?) you can see that its an array of different JSON Objects. So when we start parsing the JSON data we should extract the JSON Array and then iterate through that list to extract individual JSON objects. The individual JSON object contain the name-value pair data which can be extracted using the getXXX(key) methods defined in the JsonObject class.

The code below shows how to parse the Object Model API:

[code lang=”java” highlight=”26,27,31,32″]
import java.io.StringReader;
import java.util.HashMap;
import java.util.Map;
import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonObject;
import javax.json.JsonReader;
import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

/**
* Demo for parsing the JSON using Streaming API.
*/
@ServerEndpoint("/saveStickNotes")
public class TodoApplicationEndPoint {

private Map<String, String> stickyNotes;

@OnMessage
public void receiveMessage(String message, Session session){
parseUsingObjectAPI(message);
}

private void parseUsingObjectAPI(String message) {
JsonReader reader = Json.createReader(new StringReader(message));
JsonArray array = reader.readArray();
stickyNotes = new HashMap<>();

for(int i = 0 ; i < array.size(); i++){
JsonObject jObj = array.getJsonObject(i);
stickyNotes.put(jObj.getString("key"), jObj.getString("value"));
}

//Printing the sticky note data to verify that we have correctly parsed the data.
for(String k : stickyNotes.keySet()){
System.out.println(k+": "+ stickyNotes.get(k));
}
}
}
[/code]

In the above code the highlighted lines of code do the following:

Create a JsonReader to read from the input source i.e the string message.
Extract the JsonArray from the input source
Iterate through the JsonArray which is nothing but an implementation of Java List.
Fetch the JsonObject and then extract the required key and value data.

If you want to try this code, please replace the method parseUsingStreamingAPI in my previous post with the method parseUsingObjectAPI implemented in this post. After reading this article, you must be familiar with JSON Processing in JavaEE 7- Using Object Model API. If you have any questions on this topic, please write it in the comments section.

JSON Processing in JavaEE 7- Using Streaming API

October 10, 2013 by Mohamed Sanaulla Leave a Comment

If you are wondering what JSON is (Read : What is JSON?), you might want to read this article of mine. Java didn’t have a support for JSON processing out of the box. Developers had to include external libraries to enable JSON processing. But with JSR 353 we have support for JSON processing in Java and this has been included in the latest JavaEE version i.e JavaEE 7. There are 2 variants on offer for JSON Processing those are:

Streaming API
Object Model API

Both the variants offer JSON Parsing as well as JSON construction. In this post we will look at the JSON Streaming API support in JavaEE 7. In Head First HTML5 there is a chapter on Web Storage where in the authors develop a sample application to explain the concept. I am making use of the same sample application and adding to it the support for sending the client side data to the server for further processing.

The sample application allows creation and deletion of sticky notes which are saved in the browsers local storage. This is the same example provided in Head First HTML5 book. I am enhancing the same sample application to allow syncing the sticky notes to the server. Syncing to the server in this sample application includes the following:

Creating a JSON string for all the sticky notes stored locally in the browser.
Sending the JSON string created in (1) above to the server via the WebSocket communication channel.
The server end point parsing the JSON string to extract the sticky notes and store it in a Map.

With a brief introduction about the sample being discussed in the post, let me outline the various areas or concepts I am going to cover in this post, namely:

Storing the sticky notes in the browser local storage.
Creating JSON representation of all the sticky notes.
Parsing the JSON data in the server.

Storing the sticky notes in the browser local storage

As I mentioned at the beginning of this post that the sample which allows creating, storing and deleting of sticky notes in browser local storage is taken from the Head First HTML5 book and its source code for all the chapters in the book can be downloaded from here. But if you just want to try out the sample discussed in this post, then you need not download anything as I am going to post the relevant code here. The main focus of this post is to show the JSON processing capability in JavaEE 7 and not the HTML5 local storage feature. But I am sure this will be a very handy sample to understand and try out the HTML5 local storage feature as well.

Lets look at the JSP which declares the HTML components required for Adding Sticky notes, displaying sticky notes and deleting the sticky notes:

[code lang=”xml”]
<%–
Document : notetoself.jsp
–%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<title>Note to Self</title>
<meta charset=”utf-8”>
<link rel="stylesheet" href="notetoself.css">
<script src="notetoself.js"></script>
</head>
<body>
<form>
<input type="text" id="note_text">
<input type="button" id="add_button" value="Add Sticky Note to Self">
<input type="button" id="sync_button" value="Sync sticky notes to server">
<div id="sync_status"></div>
</form>
<!– Listing all the sticky notes below –>
<ul id="stickies">
</ul>
</body>
</html>
[/code]

The above code is very straight forward: It creates 2 buttons and an input text box. The buttons add sticky notes to the local storage and sync the sticky notes to the server respectively. Lets look at the Javascript code which binds the buttons with the event handlers and stores the stick notes into the local storage:

[code lang=”javascript”]
//File name: notetoself.js
window.onload = init;

var websocket;
function init() {

var button = document.getElementById("add_button");
button.onclick = createSticky;

//Loading all the sticky notes in the local storage and adding it to HTML DOM.
var stickiesArray = getStickiesArray();
for (var i = 0; i < stickiesArray.length; i++) {
var key = stickiesArray[i];
var value = localStorage.getItem(key);
addStickyToDom(key, value);
}
}

/**
* Event handler for the button which adds the notes.
*/
function createSticky() {
var value = document.getElementById("note_text").value;
var currentDate = new Date();
var time = currentDate.getTime();

//Creating the key for the sticky note
var key = "sticky_" + time;
//Storing the sticky note with the key in the local storage.
localStorage.setItem(key, value);

var stickiesArray = getStickiesArray();
//Only the key is stored in the stickies array.
stickiesArray.push(key);
//And the array of sticky note keys is stored in local storage.
localStorage.setItem("stickiesArray", JSON.stringify(stickiesArray));

addStickyToDom(key, value);

}

/**
* Function to add the sticky data to the HTML DOM.
*/
function addStickyToDom(key, value) {
var stickies = document.getElementById("stickies");
var sticky = document.createElement("li");
sticky.setAttribute("id", key);
var span = document.createElement("span");
span.setAttribute("class", "sticky");
span.innerHTML = value;
sticky.appendChild(span);
stickies.appendChild(sticky);
sticky.onclick = deleteSticky;
}

/**
* Function to load the sticky note data from the local storage.
*/
function getStickiesArray() {
var stickiesArray = localStorage.getItem("stickiesArray");
if (!stickiesArray) {
stickiesArray = [];
localStorage.setItem("stickiesArray", JSON.stringify(stickiesArray));
}
else {
stickiesArray = JSON.parse(stickiesArray);
}

return stickiesArray;
}
/**
* Function to delete the sticky note from the local storage.
*/
function deleteSticky(e) {
var key = e.target.id;
if (e.target.tagName.toLowerCase() == "span") {
key = e.target.parentNode.id;
}
localStorage.removeItem(key);
var stickiesArray = getStickiesArray();
if (stickiesArray) {
for (var i = 0; i < stickiesArray.length; i++) {
if (key == stickiesArray[i]) {
stickiesArray.splice(i, 1);
}
}
localStorage.setItem("stickiesArray", JSON.stringify(stickiesArray));
removeStickyFromDom(key);
}
}

/**
* Function to remove the sticky note element present in the HTML DOM.
*/
function removeStickyFromDom(key) {
var sticky = document.getElementById(key);
sticky.parentNode.removeChild(sticky);
}
[/code]

And we need to add the CSS file as well so that the sticky notes really appear like the sticky notes!! The CSS code is given below:

[code lang=”css”]
/*
notetoself.css

Tested in: Firefox4RC, Safari 5, Opera 11, Chrome 10
Transition (ease-in) doesn’t work in Firefox 3.

body {
background-color: #dbdbdb;
font-size: 100%;
}

form input#note_text {
width: 350px;
}

/* sticky note */

ul#stickies li {
display: block;
list-style: none;
z-index: 1;
float: left;
margin: 30px;
padding: 15px 15px 50px 15px;
width: 200px;
height: 200px;
border: 1px solid #bfbfbf;
background-color: LightGoldenRodYellow; /* use #fafad2 if name doesn’t work */
color: black;
text-decoration: none;
-webkit-box-shadow: 2px 2px 4px rgba(0, 0, 0, 0.4);
-moz-box-shadow: 2px 2px 4px rgba(0, 0, 0, 0.4);
-o-box-shadow: 2px 2px 4px rgba(0, 0, 0, 0.4);
box-shadow: 2px 2px 4px rgba(0, 0, 0, 0.4);
-webkit-transition: all 0.5s ease-in;
-moz-transition: all 0.5s ease-in;
-o-transition: all 0.5s ease-in;
-ms-transition: all 0.5s ease-in;
transition: all 0.5s ease-in;
overflow: hidden;
}

ul#stickies li span.sticky {
font-family: Verdana, Helvetica, sans-serif;
font-size: 200%;
}

/*
* rotation
*/
ul#stickies li:nth-child(even) {
-webkit-transform: rotate(2deg);
-moz-transform: rotate(2deg);
-o-transform: rotate(2deg);
-ms-transform: rotate(2deg);
transform: rotate(2deg);
}

ul#stickies li:nth-child(odd) {
-webkit-transform: rotate(-1deg);
-moz-transform: rotate(-1deg);
-o-transform: rotate(-1deg);
-ms-transform: rotate(-1deg);
transform: rotate(-1deg);
}

ul#stickies li:nth-child(3n) {
-webkit-transform: rotate(1deg);
-moz-transform: rotate(1deg);
-o-transform: rotate(1deg);
-ms-transform: rotate(1deg);
transform: rotate(1deg);
}

/*
Transform demo
Uses the transition (defined above) to ease in.
*/
ul#stickies li:hover {
-webkit-box-shadow: 5px 5px 6px rgba(0, 0, 0, 0.4);
-moz-box-shadow: 5px 5px 6px rgba(0, 0, 0, 0.4);
-o-box-shadow: 5px 5px 6px rgba(0, 0, 0, 0.4);
-webkit-transform: rotate(0deg) scale(1.25);
-moz-transform: rotate(0deg) scale(1.25);
-o-transform: rotate(0deg) scale(1.25);
-ms-transform: rotate(0deg) scale(1.25);
transform: rotate(0deg) scale(1.25);
z-index: 10;
}
[/code]

You need not worry too much about the CSS code as the main focus of this article is not the CSS code. The Head First series call such code as “Ready Bake code”, so lets take this code as is and use it in our sample. Also note that we haven’t added any event handler to the “Sync Sticky notes to server” button, as this will be taken up in the next section.

Once you deploy the JSP, the Javascript and the CSS and load the JSP in the browser (in my case the URL will be: http://localhost:8080/DemoApplication/notetoself.jsp) and add few sticky notes you would be able to see something similar to below:

Creating JSON representation of all the sticky notes

Now that we have the client side application running, we need to be adding in the support at the client side to convert all the sticky notes into a JSON representation which could then be sent to the server. The below javascript code includes the code for creating JSON representation as well as communicating with the server using WebSocket. If you are not familiar with WebSocket and its JavaEE 7 support then I would highly recommend you to read this post. The below javascript code contains the updated code along with the code provided above. The highlighted lines are the new additions to the code which deal with: Creating WebSocket connection to the server, Creating JSON representation of the data and sending the JSON representation to the server.

[code lang=”javascript” highlight=”18-20,23-56″]
//File Name: notetoself.js
window.onload = init;

var websocket;
function init() {

var button = document.getElementById("add_button");
button.onclick = createSticky;

var syncButton = document.getElementById("sync_button");
syncButton.onclick = syncNotesToServer;
initWebSocket();
}

/**
* Function to init the WebSocket connection to the server endpoint
*/
function initWebSocket(){
//If the websocket is not intialized, then create a new one.
if (websocket == null) {
websocket = new WebSocket("ws://localhost:8080/DemoApplication/saveStickNotes");
}
else if (websocket != null) {
//The websocket might have been closed, so reconnect to the server.
if (websocket.readyState != WebSocket.OPEN) {
websocket = new WebSocket("ws://localhost:8080/DemoApplication/saveStickNotes");
}
}
}
/**
* Function to sync the sticky notes to the server.
*/
function syncNotesToServer() {
if (websocket != null && websocket.readyState == WebSocket.OPEN)
{
var stickiesArray = getStickiesArray();
var stickyNotesArray = [];
for (var i = 0; i < stickiesArray.length; i++) {
var key = stickiesArray[i];
var value = localStorage.getItem(key);
stickyNotesArray.push({key: key, value: value});
}
console.log(JSON.stringify(stickyNotesArray));
websocket.send(JSON.stringify(stickyNotesArray));
var syncStatusDiv = document.getElementById("sync_status");
syncStatusDiv.innerHTML = "Last sync to server: "+(new Date());
}
}

//Creating the key for the sticky note
var key = "sticky_" + time;
//Storing the sticky note with the key in the local storage.
localStorage.setItem(key, value);

addStickyToDom(key, value);

}

The JSON representation created by the above highlighted code is:

[code lang=”javascript”]
[{"key":"sticky_1381306898171","value":"how aout his"},{"key":"sticky_1381306902222","value":"Another one"},{"key":"sticky_1381309254661","value":"adding few more …"}]
[/code]

Now that we have the JSON data in place and also WebSocket client end point done, we will look at creating the WebSocket server end point and parsing the JSON data at the server.

Parsing the JSON data in the server

The JSR 353 adds support for JSON processing in Java. As I said in the beginning that in this post I will cover parsing JSON using Streaming API. The Streaming API is exactly similar to StAX parser for XML. The JSON parser goes through each line of the JSON data and generates different events depending on whether the data in the given line is START_ARRAY, END_ARRAY, START_OBJECT, END_OBJECT, KEY_NAME, VALUE_STRING, VALUE_NUMBER, VALUE_TRUE, VALUE_FALSE, VALUE_NULL. And we capture what ever event we are interested in and PULL the required data like the key name and the value against the key. If you are left wondering about JSON then I would HIGHLY recommend you read this post which explains in brief about JSON. The code below creates a web socket and then parses the JSON data:

[code lang=”java” highlight=”20,25,26, 31-58″]

import java.io.StringReader;
import java.util.HashMap;
import java.util.Map;
import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonObject;
import javax.json.JsonReader;
import javax.json.JsonValue;
import javax.json.stream.JsonParser;
import static javax.json.stream.JsonParser.Event.END_OBJECT;
import static javax.json.stream.JsonParser.Event.KEY_NAME;
import static javax.json.stream.JsonParser.Event.VALUE_STRING;
import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

/**
* Demo for parsing the JSON using Streaming API.
*/
@ServerEndpoint("/saveStickNotes")
public class TodoApplicationEndPoint {

private Map<String, String> stickyNotes;

@OnMessage
public void receiveMessage(String message, Session session){
parseUsingStreamingAPI(message);
}

private void parseUsingStreamingAPI(String message) {
JsonParser parser = Json.createParser(new StringReader(message));
String keyType = null;
String key = null, value = null;
stickyNotes = new HashMap<>();
while(parser.hasNext()){
//Identify the type of event i.e type of JSON element.
switch (parser.next()){
//If the JSON element is the "KEY", then record the key type.
case KEY_NAME:
keyType = parser.getString();
break;
//If the JSON element is a value string then extract the value
//and decide if the value is a sticky note key or sticky note data.
case VALUE_STRING:
switch(keyType){
case "key":
key = parser.getString();
case "value":
value = parser.getString();
}
break;
//Once we encounter the end of the sticky note object, update the
//map with the sticky note key and sticky note value.
case END_OBJECT:
stickyNotes.put(key, value);
break;
}
}
//Printing the sticky note data to verify that we have correctly parsed the data.
for(String k : stickyNotes.keySet()){
System.out.println("Key: "+k+": "+ stickyNotes.get(k));
}
}
}

[/code]

If you are confused or left wondering about Line 20, Line 25, Line 26 then I would highly recommend you to read the article about websockets. Then coming to the code in Line 31-58 it all deals with the JSON parsing. If you have worked with StAX parser before then this should all be very similar but if you haven’t then no issues I will try to explain it here. Let me annotate our JSON data with the different event types supported so that we can easily understand the above code:

[code lang=”javascript”]
[//START_ARRAY
{//START_OBJECT
"key"//KEY_NAME
:
"sticky_1381306898171",//VALUE_STRING

"value"//KEY_NAME
:
"how aout his"//VALUE_STRING

},//END_OBJECT

{//START_OBJECT
"key" //KEY_NAME
:
"sticky_1381306902222",//VALUE_STRING

"value"//KEY_NAME
:
"Another one"//VALUE_STRING
},//END_OBJECT

{//START_OBJECT
"key"//KEY_NAME
:
"sticky_1381309254661",//VALUE_STRING

"value"//KEY_NAME
:
"adding few more …"//VALUE_STRING

}//END_OBJECT
]//END_ARRAY
[/code]

Line 39 – We capture the event of encountering the name of the property or the key and store the name of the property into the variable keyType which is then used later.
Line 44-50 – We capture the event of encountering a String value. Now we make use of the name of the property captured in keyType to decide if the value which we have is either the “key” value or the “value” or “sticky note” value. And we according store the value in different variables namely key and value.
Line 54-56 – We capture the event of encountering the end of object. And once the we come to the end of the object we have by now captured the required data for 1 sticky note, the required data being the “key” and “value” of the sticky note and then update the Map with this “key” and “value”.

And when you click on the “Sync sticky notes to server” button you should be able to see the below output in your application server console:

This has been a really code heavy post. So if you are stuck somewhere then do drop in comments and I will try to help you out. But the code discussed in this post covers a lot of concepts and will be really helpful if you are able to grasp the complete code. I have uploaded the code to the Github repository so that you can easily refer to the code if you find any issues with the code provided here.

Jackson – Java JSON Processor

June 16, 2013 by Suresh Mohan Leave a Comment

JSON stands for Java Script Object Notation. JSON is a format for efficient transfer of data across Platform. To manipulate JSON in Java, we have many processors. One of such JSON processor in Java is Jackson. Jackson is a high performance JSON processor. Reading, Writing and modifying contents is made easy in Java using the Jackson. Jackson provides with classes and methods to perform these operations. There are so many programmers who want to learn and implement a JSON program in Java. This is a step-by-step guide to read from and write into a JSON file from Java using Jackson.

JSON & Jackson

JSON is based on Java Script. JSON works well with objects. These two factors shall be the spear-head for JSON to gain entry in to the web world, where interoperability is the key to sustain. Since it resembles a JavaScript object, we can use functions like eval() to create or parse the JSON values. In the JSON web site, it is claimed that,

JSON is built on two structures,

A collection of name/value pairs. In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array
An ordered list of values. In most languages, this is realized as an array, vector, list, or sequence

Reference : http://www.json.org/

The JSON, as it is evolving in to a giant in this new web world, where it is used from simple AJAX response to RESTful web services, we must also look into how the programming languages handle and generate these files. Jackson easily fits into this requirement. Jackson has capability to read and write into a JSON file from Java, and most stunningly it is capable of creating a JSON from a Java object and read a JSON file back into a Java object. Jackson is packaged in to a jar file which contains all necessary data required for using JSON. We shall discuss about a couple of important classes and its methods to write and read a JSON file in Jackson.

How to read a JSON fil?

Reading a JSON file is far simpler in Jackson. All we need is the Jackson-all-1.8.5.jar file. Let us take a simple JSON file as below and see how Jackson processor is able to read from it.

[java]
<strong>CountryFile.json</strong>
{
"Name":"United States of America",
"Capital":"Washington, D.C.",
"States":["California","Maryland","Florida"]
}
[/java]

This JSON has two kinds of data in it. One is a simple data where key values are present and the other is an array data. The Name holds a string value, the Capital holds a string value and the States hold multiple values in it. Let us create a simple Java method named readJSON() to read this file.

In the Jackson library we have a class named as ObjectMapper. This class holds almost all the important methods required for reading and writing a JSON file. This ObjectMapper class has the method readValue(). This method takes various parameters. Typically it takes the file name and the Java collection into which the JSON file must be mapped. Since the data in the JSON are all key value pairs, Map collection would be a better candidate to hold the JSON values in Java, so for this method we shall pass our CountryFile.json as a file and Map.class as our collection. So the code shall look as below.

[java]
ObjectMapper mapper = new ObjectMapper();
Map<String,Object> userData = mapper.readValue(new File("CountryFile.json"), Map.class);
[/java]

As this line executes, the data from the JSON would have been mapped into the userData object. As this is a map, to get the values from it, we can use the entrySet method.

[java]
Set mySet = userData.entrySet();
[/java]

An iterator can be used on this mySet to get each value that is stored inside the file as object which we can use it for processing further.

[java]
for (Iterator iterator = mySet.iterator(); iterator.hasNext();) {
Object object = (Object) iterator.next();
System.out.println(object);
}
[/java]

Now we have successfully read the values from the JSON file and printed it.

Write a JSON file

Let us try to create and write a JSON file from Java. Since all the data are key value pairs in JSON, we shall have our data in a Map and try to write it. So first we will create a map and populate the data into it.

[java]
Map<String,Object> country = new HashMap<String, Object>();

country.put("Name","United States of America");
country.put("Capital", "Washington, D.C.");

Set states = new HashSet();
states.add("Florida");
states.add("Maryland");
states.add("California");

country.put("States",states);
[/java]

In this above snippet, we have created a Map named country and added values to it. Moreover we have also created a Set named as states and added values to it.

To write a map into file all we require is the ObjectMapper class and the writeValue() method of it. The writeValue() method takes two parameters namely the object that must be written and the name of the file in which the data must be written.

[java]
ObjectMapper mapper = new ObjectMapper();
mapper.writeValue(new File("CountryFile.json"), country);
[/java]

On execution the above line we would be getting JSON file created as CountryFile.json and all our data written into it.

It is important to note the all the values in the map was written as key value pair in the JSON file. The value was written as multivalued element in the JSON. This way we can make use of various methods of the Jackson library to create/read different kinds of elements in the JSON file.
So the final output file would look like,
CountryFile.json

[java]
{
"Name":"United States of America",
"Capital":"Washington, D.C.",
"States":["California","Maryland","Florida"]
}
[/java]

Full code

[java]
package demo.jackson;
import java.io.File;
import java.util.HashSet;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.codehaus.jackson.map.ObjectMapper;

public class JacksonDemo {

public void writeJSON() throws Exception {

Map<String,Object> country = new HashMap<String, Object>();

country.put("Name","United States of America");
country.put("Capital", "Washington, D.C.");

Set<String> states = new HashSet<String>();
states.add("Florida");
states.add("Maryland");
states.add("California");

country.put("States",states);

ObjectMapper mapper = new ObjectMapper();
mapper.writeValue(new File("CountryFile.json"), country);

System.out.println("**success***");
}

public void readJSON() throws Exception {

ObjectMapper mapper = new ObjectMapper();
Map<String,Object> userData =
mapper.readValue(new File("CountryFile.json"), Map.class);

Set mySet = userData.entrySet();

for (Iterator iterator = mySet.iterator(); iterator.hasNext();) {
Object object = (Object) iterator.next();
System.out.println(object);
}
}

public static void main(String[] args){
try {
JacksonDemo myPgm = new JacksonDemo();
myPgm.writeJSON();
myPgm.readJSON();
} catch (Exception e) {
e.printStackTrace();
}
}
}
[/java]

Conclusion

We have discussed how to read and write JSON from Java using the Jackson processor. Don’t sit back and assume that this is all Jackson can do, we have just now hit the tip of an iceberg, there are lots of things to explore inside the Jackson, which offers multiple varieties to process JSON files.

Creating JSON using Groovy

June 22, 2012 by Mohamed Sanaulla Leave a Comment

I wrote previously about parsing JSON in Groovy. In this article I show a simple example of creating JSON using Groovy. I had to learn about creating JSON using Groovy as I would be using JSON as the response format in the REST API which might be developed sometime in future.

also read:

Groovy Tutorials

JSON Tutorials

Developing Groovy based web application and deploying to Google App Engine

Creating JSON using Groovy

Groovy 1.8 introduced json package for parsing and building JSON data. JsonSlurper is used for parsing JSON and JsonBuilder is used for creating JSON in Groovy.

Lets see a very simple example of creating a JSON using named arguments:

[code lang=”java”]
def jsonBuilder = new groovy.json.JsonBuilder()
jsonBuilder.book(
isbn: ‘0321774094’,
title: ‘Scala for the Impatient’,
author: ‘Cay S. Horstmann’,
publisher: ‘Addison-Wesley Professional’,
)
println("Using just named arguments")
println(jsonBuilder.toPrettyString())
[/code]

The output:

[code]
Using just named arguments
{
"book": {
"isbn": "0321774094",
"title": "Scala for the Impatient",
"author": "Cay S. Horstmann",
"publisher": "Addison-Wesley Professional"
}
}
[/code]

Creating JSON using an instance of some class
For this lets define a class which would be a container for our data:

[code lang=”java”]
class MyBook{
def isbn
def title
def author
def publisher
}
[/code]

and the code which would create JSON from an instance of MyBook is

[code lang=”java”]
def myBook = new MyBook(isbn: ‘0321774094’,
title: ‘Scala for the Impatient’,
author: ‘Cay S. Horstmann’,
publisher: ‘Addison-Wesley Professional’)
jsonBuilder(book: myBook)
println("Using an object")
println(jsonBuilder.toPrettyString())
[/code]

The output:

[code]
Using an object
{
"book": {
"title": "Scala for the Impatient",
"publisher": "Addison-Wesley Professional",
"isbn": "0321774094",
"author": "Cay S. Horstmann"
}
}
[/code]

Creating JSON using a list of instances

[code lang=”java”]
def myBook = new MyBook(isbn: ‘0321774094’,
title: ‘Scala for the Impatient’,
author: ‘Cay S. Horstmann’,
publisher: ‘Addison-Wesley Professional’)

def myBook2 = new MyBook(isbn: ‘0976694085’,
title: ‘Pragmatic Ajax: A Web 2.0 Primer’,
author: ‘Justin Gehtland, Ben Galbraith, Dion Almaer’,
publisher: ‘Pragmatic Bookshelf’)

def myBook3 = new MyBook(isbn: ‘1934356050’,
title: ‘Pragmatic Thinking and Learning: Refactor Your Wetware’,
author: ‘Andy Hunt’,
publisher: ‘Pragmatic Bookshelf’)

def myBookList = [myBook,myBook2,myBook3]

jsonBuilder(books: myBookList)
println("Using list of objects")
println(jsonBuilder.toPrettyString())
[/code]

The output for this would be:

[code]
Using list of objects
{
"books": [
{
"title": "Scala for the Impatient",
"publisher": "Addison-Wesley Professional",
"isbn": "0321774094",
"author": "Cay S. Horstmann"
},
{
"title": "Pragmatic Ajax: A Web 2.0 Primer",
"publisher": "Pragmatic Bookshelf",
"isbn": "0976694085",
"author": "Justin Gehtland, Ben Galbraith, Dion Almaer"
},
{
"title": "Pragmatic Thinking and Learning: Refactor Your Wetware",
"publisher": "Pragmatic Bookshelf",
"isbn": "1934356050",
"author": "Andy Hunt"
}
]
}
[/code]

For more details visit the API here and a good article here.

Creating JSON document using Java and GSON API

May 5, 2012 by Mohamed Sanaulla Leave a Comment

We saw how to parse JSON using GSON API, in this post we would take a look at how the same GSON API can be used to create JSON from the Java objects. Please read this to get an idea of what GSON is. Diving right into the topic of this example, we would make use of the toJson method of com.google.gson.Gson class. One of the overloaded versions of toJson() takes in an source of type Object and the type information which is of class java.lang.reflect.Type.

also read:

JSON Tutorials

Java EE Tutorials

Design Patterns Tutorials

Java File IO Tutorials

Lets define the model which would hold the data:

[code lang=”java”]
class Book{

@SerializedName("isbn")
String isbn;

@SerializedName("title")
String title;

@SerializedName("publication")
String publication;

@SerializedName("authors")
String authors;

public Book ( String isbn,
String title,
String publication,
String authors)
{
this.isbn = isbn;
this.title = title;
this.publication = publication;
this.authors = authors;
}

}
[/code]

We populate a list with some values for this model bean and this list would be converted to JSON output. Note the use of @SerializedName annotation in the model class. This indicates the name used for the attribute in the json output. We populate the list of books using:

[code lang=”java”]
private static List<Book> populateBooks(){

List<Book> myBooks = new ArrayList<Book>();
Book book = new Book("007163360X",
"Java Programming",
"McGraw-Hill Osborne",
"Dr (Poornachandra) Sarang");
myBooks.add(book);

book = new Book("1849516626",
"Apache Tomcat 7 Essentials",
"Tanuj Khare",
"Packt Press");
myBooks.add(book);

book = new Book("007179431X",
"Web Developer’s Cookbook",
"Robin Nixon",
"McGraw-Hill Osborne");
myBooks.add(book);

book = new Book("9781935182962",
"Practical Unit Testing",
"Ken Rimple & Srini Penchikala",
"Manning");
myBooks.add(book);

return myBooks;
}
[/code]

Once we have a list, we need to serialize it to JSON, for that we need to setup a Type information for generic List, this is not possible out of the box in Java and hence we would make use of com.google.gson.reflect.TypeToken class in the GSON API, to create the type information like:

[code lang=”java”]
// Get the type information for the List<Book>
Type listType = new TypeToken<List<Book>>(){}.getType();
[/code]

Next up is to use this type information along with the list of books and pass it to the toJson method to obtain the JSON output.

The complete code:

[code lang=”java”]
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import com.google.gson.reflect.TypeToken;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

public class JsonCreatorDemo {

/**
* Populate the Books information into a List
* @return
*/
private static List<Book> populateBooks(){

List<Book> myBooks = new ArrayList<Book>();
Book book = new Book("007163360X",
"Java Programming",
"McGraw-Hill Osborne",
"Dr (Poornachandra) Sarang");
myBooks.add(book);

book = new Book("1849516626",
"Apache Tomcat 7 Essentials",
"Tanuj Khare",
"Packt Press");
myBooks.add(book);

book = new Book("007179431X",
"Web Developer’s Cookbook",
"Robin Nixon",
"McGraw-Hill Osborne");
myBooks.add(book);

book = new Book("9781935182962",
"Practical Unit Testing",
"Ken Rimple & Srini Penchikala",
"Manning");
myBooks.add(book);

return myBooks;
}

public static void main(String [] args){

List<Book> myBooks = populateBooks();

Gson myGson = new Gson();

// Get the type information for the List<Book>
Type listType = new TypeToken<List<Book>>(){}.getType();

// Serialize the List of books into JSON
System.out.println(myGson.toJson(myBooks,listType));

}
}

class Book{

@SerializedName("isbn")
String isbn;

@SerializedName("title")
String title;

@SerializedName("publication")
String publication;

@SerializedName("authors")
String authors;

public Book ( String isbn,
String title,
String publication,
String authors)
{
this.isbn = isbn;
this.title = title;
this.publication = publication;
this.authors = authors;
}

}
[/code]

JSON Output:

[code]
[
{
"isbn":"007163360X",
"title":"Java Programming",
"publication":"McGraw-Hill Osborne",
"authors":"Dr (Poornachandra) Sarang"
},
{
"isbn":"1849516626",
"title":"Apache Tomcat 7 Essentials",
"publication":"Tanuj Khare",
"authors":"Packt Press"
},
{
"isbn":"007179431X",
"title":"Web Developeru0027s Cookbook",
"publication":"Robin Nixon",
"authors":"McGraw-Hill Osborne"
},
{
"isbn":"9781935182962",
"title":"Practical Unit Testing",
"publication":"Ken Rimple u0026 Srini Penchikala",
"authors":"Manning"
}
]
[/code]

Using JsonSlurper Groovy API from Java to parse JSON

May 3, 2012 by Mohamed Sanaulla Leave a Comment

We have seen here on how to parse JSON in Java using Gson and here on how to parse JSON in Groovy. I also touched upon in brief about Groovy here. The beauty of these JVM languages is that one can invoke these APIs from Java, the only requirement is that you need to have the language jar on the classpath. In our example below we use JsonSlurper in Groovy to parse the JSON documents from Java. Sounds cool right! In one of the talks on Functional Programming, Venkat showed us how we could exploit the Software Transactional Memory feature in Clojure to create concurrent applications in Java with less pain.

also read:

Groovy Tutorials

JSON Tutorials

Developing Groovy based web application and deploying to Google App Engine

With so many JVM languages coming up i.e languages which run on JVM, developers are more becoming ployglot i.e use multiple langauges in their code. Going on same lines, in the below example I show you how we could exploit the JSON API in Groovy and use it in our Java program. So all you readers out there keep in mind to add the language specific jar to your classpath. This jar tells the compiler where to find the required API information. For Groovy you can download the required Groovy Development Kit from here. Let GROOVY_HOME be the home directory of your Groovy installation. You would find a jar in the GROOVY_HOME/embeddable folder which would be named like: groovy-all-.jar. This is the jar which you need to add it to the classpath for your Java code to find the right APIs.
If you are not familiar with JSON, do stop by to read about it here, if you are not familiar with Json parsing in Groovy, do read it over here.
The json document which I used is:

[code]
[
{
"id":"6253282",
"name":"Twitter API",
"screen_name":"twitterapi",
"url":"http://dev.twitter.com",
"followers_count":1004641,
"friends_count":33,
"favourites_count":24,
"statuses_count":3277
},
{
"id":"15082387",
"name":"Sanaulla",
"screen_name":"sanaulla",
"url":"http://blog.sanaulla.info",
"followers_count":241,
"friends_count":302,
"favourites_count":41,
"statuses_count":1876

}
]
[/code]

The Java code which does the parsing is:

[code lang=”java”]
import groovy.json.JsonSlurper;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.List;
import java.util.Map;

public class JavaJsonParserDemo {

public static void main(String [] args){

String jsonSrouce = "/home/mohamed/twitterUser.json";
JsonSlurper jsonParser = new JsonSlurper();
try {
List&lt;Map&gt; parsedData = (List&lt;Map&gt;)jsonParser.parse( new FileReader(jsonSrouce));
for ( Map aObject : parsedData){
System.out.println(aObject);
System.out.println(aObject.get("screen_name"));
}
}catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
[/code]

If you happen to explore the source of JsonSlurper here, you can see that the parse() method invokes either parseObject() or parseArray(). In our sample JSON it would invoke parseArray(), which would return some List. Looking into parseArray() we can find that the List is actually a List of Maps. Keeping this in mind, the declaration used above is List.
Running this program the output would be:

[code]
{id=6253282, favourites_count=24, friends_count=33, name=Twitter API,
screen_name=twitterapi, statuses_count=3277, followers_count=1004641,
url=http://dev.twitter.com}
twitterapi
{id=15082387, favourites_count=41, friends_count=302, name=Sanaulla,
screen_name=sanaulla, statuses_count=1876, followers_count=241,
url=http://blog.sanaulla.info}
sanaulla
[/code]

Parsing JSON using Groovy

April 30, 2012 by Mohamed Sanaulla Leave a Comment

In our previous post we saw how we used Gson API to parse the Json using Java. Not spending too much time on the introduction, I would want to straight away dive into the same parsing which can be done using Groovy language. Groovy is a scripting language which runs on the JVM. It can inter-operate with the Java APIs and compiles down into byte code which can then be executed on the JVM.

also read:

Groovy Tutorials

Creating JSON using Groovy

Developing Groovy based web application and deploying to Google App Engine

In this example as well we would make use of the same json document described here.
Groovy support for Json was added in the 1.8 version when a new groovy.json package was added. So you dont have to use an external API for parsing the json documents. JsonSlurper parses the given json document into a data structure of lists and maps. Due to this conversion the name=value pairs in the json document can be accessed by object.name notation where object represents the json object and name represents the name of the attribute.
The model bean in this case is defined as:

[code]
class GroovyUser{
def id
def screenName
def name
def url
def followersCount
def friendsCount
def favouritesCount
def statusesCount

GroovyUser(id,
screenName,
name,
url,
followersCount,
friendsCount,
favouritesCount,
statusesCount){
this.id = id
this.screenName = screenName
this.name = name
this.url = url
this.followersCount = followersCount
this.friendsCount = friendsCount
this.favouritesCount = favouritesCount
this.statusesCount = statusesCount

}

def String toString(){
return "Name: "+this.name+"n"+
"ScreenName:"+this.screenName+"n"+
"Followers: "+this.followersCount+"n"+
"Friends: "+this.friendsCount+"n"+
"Favourites: "+this.favouritesCount+"n"+
"Statuses: "+this.statusesCount+"n"
}
}
[/code]

As Groovy can be used a scripting language, the following code need not be compiled instead one could directly run the code by:

[code]$ groovy filename.groovy[/code]

You would have to download and install the required binaries and libraries for running the groovy programs. More can be found at the official site.

[code]
import groovy.json.JsonSlurper

def jsonSlurper = new JsonSlurper();

/*
Read the JSON from the file system
*/
def reader = new BufferedReader(
new FileReader("/home/mohamed/twitterUser.json"))
def parsedData = jsonSlurper.parse(reader)
def usersList = new ArrayList<GroovyUser>()
parsedData.each {
aUser ->
def user = new GroovyUser(aUser.id,
aUser.screen_name,
aUser.name,
aUser.url,
aUser.followers_count,
aUser.friends_count,
aUser.favourites_count,
aUser.statuses_count)
usersList.add(user)
}

usersList.each {aUser -> println aUser}
[/code]

There are few new things to note here:

As Groovy supports closures, we are making use of the methods like “each” which is provided by the Groovy API on collections. The each method would for each element in the collection, execute the block of code provided with the each method. Something like-myCollection.each{ aData -> println aData }
Semi colons are optional
Type details for the variables are optional, so you can see that the variables have been declared by using “def” keyword but no type is declared.
Look at the tremendous decrease in the number of lines of code written above. Parsing Json in Groovy is such a pleasure.

On a closing note, the difference in the lines of code in Java and Groovy might tempt few of them to learn the syntax of the language. I am sure learning groovy is pretty easy as it has a short learning curve. Over the last few years there has been a transition to polyglot programming and with the advent of new languages which run on the JVM, they can inter-operate with an existing java application with no additional overhead.
We would over the coming days try to provide a few getting started like tutorials for Groovy and other JVM languages like Scala.

Parsing JSON using Java and GSON library

April 30, 2012 by Mohamed Sanaulla Leave a Comment

In my previous post here, I gave a brief overview of JavaScript Object Notation (JSON). In this post I would go a bit further and show how one can parse the JSON documents into Java objects using the GSON library. The JSON data for this tutorial was obtained from:

also read:

JSON Tutorials

Java EE Tutorials

Design Patterns Tutorials

Java File IO Tutorials

[code lang="java"] [
{
"id":"6253282",
"name":"Twitter API",
"screen_name":"twitterapi",
"url":"http://dev.twitter.com",
"followers_count":1004641,
"friends_count":33,
"favourites_count":24,
"statuses_count":3277
},
{
"id":"15082387",
"name":"Sanaulla",
"screen_name":"sanaulla",
"url":"http://blog.sanaulla.info",
"followers_count":241,
"friends_count":302,
"favourites_count":41,
"statuses_count":1876
}
][/code]

Let me call this file as twitterUser.json. It is an array of user profile data where each user profile contains: name, id, screen_name, url, followers_count, friends_count, favourites_count and statuses_count. In order to run the following code, you need to download the GSON API jar from here and add it to your classpath. Moving further, we need to create a Model class which would hold the data obtained from JSON document.

[code lang="java"]
/**
* Model class for storing the selected few attributes
* for a Twitter User profile.
*/
class TwitterUser{
private String id;
private String name;
private String screen_name;
private String url;
private int friends_count;
private int followers_count;
private int favourites_count;
private int statuses_count;
public TwitterUser(){
}
@Override
public String toString(){
return "Name: "+this.name+"n" +
"Screen Name: "+this.screen_name+"n" +
"Number of Friends: "+ this.friends_count + "n" +
"Number of Followers: "+ this.followers_count +"n" +
"Number of Status updates: "+this.statuses_count +"n" +
"Number of favorites: "+this.favourites_count +"n";
}
}[/code]

Before putting forth the code, let me brief about the classes where are used for parsing the Json:

com.google.gson.Gson:
This is the main class for using Gson. Gson is typically used by first constructing a Gson instance and then invoking toJson(Object) or fromJson(String, Class) methods on it.
com.google.gson.JsonParser:
A parser to parse Json into a parse tree of JsonElements
com.google.gson.stream.JsonReader:
Reads a JSON encoded value as a stream of tokens. This stream includes both literal values (strings, numbers, booleans, and nulls) as well as the begin and end delimiters of objects and arrays.
com.google.gson.JsonArray:
A class representing an array type in Json. An array is a list of JsonElements each of which can be of a different type.
com.google.gson.JsonElement:
A class representing an element of Json. It could either be a JsonObject, a JsonArray, a JsonPrimitive or a JsonNull.

Reading the JSON document using JsonReader, assuming the document is present in the file systems:

[code lang="java"] JsonReader reader = new JsonReader(
new InputStreamReader(new FileInputStream(this.jsonSource)));[/code]

JsonReader has a constructor which takes in an instance of a Reader, in our case we use the InputStreamReader and pipe it to a FileInputStream.

Once we are able to read the json data, we go ahead and use JsonParser to parse the contents and obtain the array of objects which the json document stores. There is an another way to do this with out using the JsonParser explicitly, but lets stick to this as its more clearer.

[code lang="java"]
JsonParser jsonParser = new JsonParser();
JsonArray userarray= jsonParser.parse(jsonReader).getAsJsonArray();
[/code]

parse(JsonReader) method of the JsonParser, parses the given Json and creates a parse tree of JsonElements. And the method getAsJsonArray() returns the parsed Json as an array of json objects. In our document we are sure that the document is an array of json objects (recall, the [ ] stands for representing the arrays in json). Suppose you were not sure if those are arrays, then you can use isJsonArray() method of the JsonElement class.

Next up, is to traverse through the array and populate the data from the json object in to our model bean TwitterUser which we had defined at the beginning.

[code lang="java"] List twitterUsers = new ArrayList&amp;amp;lt;&amp;amp;gt;();
for ( JsonElement aUser : userArray ) {
TwitterUser aTwitterUser = myGson.fromJson(aUser, TwitterUser.class);
twitterUsers.add(aTwitterUser);
}[/code]

For each element in the JsonArray we use Gson.fromJson() to populate the data in the json object into the type defined by TwitterUser.class. How it works behind the scene is:

It creates a new instance of TwitterUser, by invoking the default constructor.
Sets the values of the attributes in the TwitterUser class with those obtained from the json array element. If you closely look at the names of the attributes in the TwitterUser class and the ones in the Json document- they are exactly similar- something like- screen_name, friends_count, followerr_count and so on.

The fromJson method in Gson has been overloaded to support multiple types of parameters, and from that we are using the fromJson(JsonElement json, Class<T> classOfT) version.

Now just to confirm we have parsed the correct data, iterate through the user list:

[code lang="java"] for ( TwitterUser tUser : twitterUsers)
{
System.out.println(tUser);
}[/code]

The complete source for the code is given below:

[code lang="java"] import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.google.gson.stream.JsonReader;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class JsonParserDemo {

private String jsonSource;
private boolean sourceFromFile;
public JsonParserDemo(String jsonSource, boolean sourceFromFile){
this.jsonSource = jsonSource;
this.sourceFromFile = sourceFromFile;
}
public static void main(String[] args){
JsonParserDemo jsonParserDemo =
new JsonParserDemo("/home/mohamed/twitterUser.json", true);
try(JsonReader jsonReader = jsonParserDemo.getJsonReader()){
Gson myGson = new Gson();
JsonParser jsonParser = new JsonParser();
JsonArray userArray =&amp;amp;nbsp; jsonParser.parse(jsonReader).getAsJsonArray();
List twitterUsers = new ArrayList&amp;amp;lt;&amp;amp;gt;();
for ( JsonElement aUser : userArray ){
TwitterUser aTwitterUser = myGson.fromJson(aUser, TwitterUser.class);
twitterUsers.add(aTwitterUser);
}
for ( TwitterUser tUser : twitterUsers){
System.out.println(tUser);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

/**
* Obtain the JsonReader for the given source details.
* @return the JsonReader instance
* @throws FileNotFoundException
*/
private JsonReader getJsonReader () throws FileNotFoundException{
JsonReader reader = null;
if (sourceFromFile){
reader = new JsonReader(
new InputStreamReader(new FileInputStream(this.jsonSource)));
}
return reader;
}
}

/**
* Model class for storing the selected few attributes
* for a Twitter User profile.
*/
class TwitterUser{
private String id;
private String name;
private String screen_name;
private String url;
private int friends_count;
private int followers_count;
private int favourites_count;
private int statuses_count;

public TwitterUser(){
}

@Override
public String toString(){
return "Name: "+this.name+"n" +
"Screen Name: "+this.screen_name+"n" +
"Number of Friends: "+ this.friends_count + "n" +
"Number of Followers: "+ this.followers_count +"n" +
"Number of Status updates: "+this.statuses_count +"n" +
"Number of favorites: "+this.favourites_count +"n";
}
}[/code]

What is JSON?

April 28, 2012 by Mohamed Sanaulla Leave a Comment

This tutorial explains the use of JSON and how to use it in your programming. This tutorial/webpage regularly updated with latest information about the JSON and Java libraries that are used for parsing the JSON files.

A quick JSON search on Google would yield plenty of results and more specifically the JSON homepage. None the less we wanted to share something brief and something good about JSON. Lot of you are familiar with XML and XML had been the defacto data-transfer language in the area of RESTful webservices, but off late JSON has been gaining popularity for reasons which I would explain a bit further. Before going further into XML versus JSON, let me give a brief overview of the structure of JSON documents. And for those not aware of what JSON stands for, its JavaScript Object Notation. I know the use of “JavaScript” term has more relevance and is not like the use of “Java” in the term “JavaScript”.

JSON Structure

A JSON structure consists of name-value pairs where a collection of such name-value pairs is called an Object, and each value could be an object themselves or be some primitives like Strings, Numbers and so on. Also values can be arrays of objects or primitive values. Sounds confusing right, let me explain with an example, consider a JSON document retrieved from http://api.twitter.com/1/trends/available.json which shows the available twitter trends and their location information. Let me get a small excerpt from that document:

[javascript][
{
"parentid": 23424900,
"name": "Mexico City",
"url": "http://where.yahooapis.com/v1/place/116545",
"country": "Mexico",
"countryCode": "MX",
"placeType": {
"name": "Town",
"code": 7
},
"woeid": 116545
},
{
"name": "Jackson",
"url": "http://where.yahooapis.com/v1/place/2428184",
"country": "United States",
"countryCode": "US",
"placeType": {
"name": "Town",
"code": 7
},
"parentid": 23424977,
"woeid": 2428184
}
][/javascript]

In the above example, the notation [ ] is used to represent the Arrays and anything within { } is considered to be an object literal/ or an object. We can observe that we have an array of two objects where each object represents some twitter trend details. Digging further we can observe that objects have a “name”:value pattern, this is somewhat closer to our Map representations. The “placeType” attribute has another object as its value, similarly attributes like “code”, “woeid” have Numbers as their values.

Just in case you want to learn more about this structure/syntax, you can visit JSON.org for a beautiful diagrammatic explanation.

Origin and Use of JSON

Douglas Crockford of JavaScript Good Parts fame was the earliest promoters of JSON notation and it was named so because it mimics the object notation used in JavaScript. It doesn’t require JavaScript to use but its fairly easy to create JavaScript objects using the JSON data. There are lot of APIs in almost all languages which provide support for parsing and creating JSON documents and languages like Groovy provide such support within their standard APIs. NoSQL databases like CouchDB, MongoDB extensively use JSON for representing the data.

Lot of RESTful Webservice APIs out there support both XML and JSON data formats. And with JavaScript frameworks like Backbone.js it becomes really easy to consume the JSON documents provided by these RESTful APIs and create model objects. An advantage of JSON over XML is that, its really less verbose than XML. And also the JSON representation is more closer to the Object/Key-value kind of notation which lot of us Java programmers are familiar with.

In the coming posts, we would be writing on how one can parse JSON in Java and other JVM languages and also how to use it in parsing the data from a RESTful API. So before that, we thought of giving a brief overview of JSON.

Any of you have more to share about JSON, any good/bad experiences of using JSON, do leave them here as comments, we would be more than happy to update the post to add your comments.

JSON Tutorials

Parsing JSON using Java and GSON library : This post explains how one can parse the JSON documents into Java objects using the GSON library.

Creating JSON using Groovy : This article explains a simple example of creating JSON using Groovy. This article would be using JSON as the response format in the REST API.

Creating JSON Data Using The Java JSON API (JSR 353) : JSON has been around for quite sometime now and lot of languages are offering out of the box support for parsing and creating JSON data. The JDK didn’t have support for parsing and creating JSON data out of the box. One had to make use of libraries for parsing and creating JSON data like Google GSON among others. With JSR 353 and its reference implementation we can hope that it becomes a part of JDK so that we are less dependent on 3rd party libraries.

Using JsonSlurper Groovy API from Java to parse JSON : In this example we use JsonSlurper in Groovy to parse the JSON documents from Java. Sounds cool right! In one of the talks on Functional Programming, Venkat showed us how we could exploit the Software Transactional Memory feature in Clojure to create concurrent applications in Java with less pain.

Creating JSON document using Java and GSON API : We saw how to parse JSON using GSON API, in this post we would take a look at how the same GSON API can be used to create JSON from the Java objects. Please read this to get an idea of what GSON is. Diving right into the topic of this example, we would make use of the toJson method of com.google.gson.Gson class.

JSON Processing in JavaEE 7- Using Object Model API : The JSON Streaming API was not suited for scenarios explained in my previous post. In such scenarios one can make use of the Object Model API to parse the JSON data.