Logging is a common issue for development teams. And right now there are a lot of options on what exactly to use for logging in Java. The most famous frameworks are: Log4j, Logback, Commons-logging, java.util.logging. But what happens if we want to change a logging framework by another one, did we have to change the whole application? If the project is high coupled with the logging framework, there’s no choice.

Here comes the role of The Simple Logging Facade for Java or (SLF4J) who serves as a simple facade or abstraction for various logging frameworks, allowing the end user to plug in the desired logging framework at deployment time. In this post we will discover how SLF4J works by analyzing it by JArchitect.

JArchitect Overview

JArchitect is a static analysis tool for Java codebases that provides interactive GUI(s) and HTML reports for finding overly complex or problematic areas of your code, performing analysis for refactoring and comparing changes over time.

The cool and powerful feature of the JArchitect is the support for Code Query Linq (CQLinq). The CQLinq lets the developers to query the Java code using LINQ queries, for example CQlinq can answer to the following requests:

Which methods create objects of a particular class?

from m in Methods where m.CreateA ("MyPackage.MyClass") select m

Which methods assign a particular field?

from m in Methods

where m.AssignField("MyPackage.MyClass.m_Field") select m

Which complex method is not enough commented?

 

from m in Application.Methods  where m.CyclomaticComplexity >  15 && m.PercentageComment <  10

select new { m, m.CyclomaticComplexity, m.PercentageComment }

JArchitect provides more than 80 metrics that are related to your code organization, code quality and code structure. These metrics could be used in CQLinq to create your coding custom rules, JArchitect could be integrated into your build system to enforce the quality of your codebase.

SLAF4J Analysis

We analyze a solution containing SLF4JSample.jar a sample project using SLF4J, slf4j-api.jar and slf4j-log4j.jar. Here’s the dependency graph after the analysis:

This dependency graph reveals two remarks:

- SLF4JSample is not coupled directly with log4j, it knows only the facade slf4j-api.

- There’s a dependency cycle between slf4j-api and slf-log4j

And to have more infos about dependencies between all jars, the Dependency matrix shows also the dependency weight between them.

For example SLF4JSample use two members from slf4j-api.

To understand better how SLF4J works, let’s discover how all these jars collaborates with each other, and we can begin with SLF4jSample and search which methods it uses, for that we can execute the following CQLinq query:

from m in Methods where m.IsUsedBy ("com.srccodes.examples.SLF4JHello")

select new { m, m.NbBCInstructions }

Here’s the result:

SLF4JHello ask for a logger from slf4j-api by invoking LoggerFactory.getLogger method, and after use it. What’s interesting is that SLF4JHello is not coupled directly with the logger implementation, but pass by the interface Logger.

How SLF4J got the logger?

To discover that let’s see which methods are invocked by LoggerFactory.getLogger

The getLogger method try to get a LoggerFactory from StaticLoggerBinder to ask it for a logger, the StaticLoggerBinder exist in slf4j-log4j.jar, this jar act as a binder between SLF4J and Log4j.

Let’s discover which methods are invoked by LoggerFactory.getILoggerFactory

from m in Methods where m.IsUsedBy ("org.slf4j.LoggerFactory.getILoggerFactory()")

select new { m, m.NbBCInstructions }

So getILoggerFactory search for org.slf4j.impl.StaticLoggerBinder to create the logger factory. What means that if we create a jar containing this method and copy it where slf4j-api exists, this method will be invoked when a logger factory is asked.

And in this case to switch from a logging framework to another we need only to copy the right binder corresponding to the framework used. What explains also the dependency cycle between slf4j-api and slf4j-log4j.

slf4j use a simple technique to act as a logging facade, and permit to have a low coupling between the application and the logging framework, and  we can also change at runtime the logging framework.

Wikipedia here says that:
The consumer producer problem (also known as the bounded-buffer problem) is a classical example of a multi-process synchronization problem. The problem describes two processes, the producer and the consumer, who share a common, fixed-size buffer used as a queue. The producer’s job is to generate a piece of data, put it into the buffer and start again. At the same time, the consumer is consuming the data (i.e., removing it from the buffer) one piece at a time. The problem is to make sure that the producer won’t try to add data into the buffer if it’s full and that the consumer won’t try to remove data from an empty buffer.

The solution for the producer is to either go to sleep or discard data if the buffer is full. The next time the consumer removes an item from the buffer, it notifies the producer, who starts to fill the buffer again. In the same way, the consumer can go to sleep if it finds the buffer to be empty. The next time the producer puts data into the buffer, it wakes up the sleeping consumer. The solution can be reached by means of inter-process communication, typically using semaphores. An inadequate solution could result in a deadlock where both processes are waiting to be awakened. The problem can also be generalized to have multiple producers and consumers.

There are numerous ways to solve a Producer-Consumer problem and in this post I will show one simple way to solve this problem by using the Data Structures and other constructs provided in the JDK. Java 5 introduced a new set of concurrency related APIs in its java.util.concurrent package. As I said here, not many of the developers are aware of these APIs and very few of the make use of it in their code.

There were quite a few new Collection classes which got introduced in Java 5 and one of them is the BlockingQueue.

BlockingQueue in Java

The JavaDoc says:
BlockingQueue is “A Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.” There are multiple methods which are supported to retrieve and add elements to the queue wherein one pair throws an exceptions, one of them waits for some fixed time and one pair which blocks until the queue is full/empty. The methods which blocks the thread are the put(e) and take.

In a typical producer-consumer problem we would want the consumer thread to be blocked until there is something in the queue to be consumed and the producer thread to be blocked until there is some free space in the queue to add some element. With the use of normal collection classes it because quite a bit of work in implementing inter thread communication by waiting and notifying other threads about the status of the queue. The put(e) and take() methods of the BlockingQueue class are the ones which make it very easy to solve producer-consumer like problems.

Lets take a scenario where the producer thread would watch for the files being modified in some directory and add those files to the queue and the consumer thread would print the contents of those files on to the console.

Producer thread

If you are not familiar with implementing the WatchService in Java, you must first read this to get an idea of how it works.

class FileProducer implements Runnable{

  BlockingQueue<Path> filesList;
  Path rootPath;

  public FileProducer(BlockingQueue<Path> filesList, 
                      Path rootPath){
    this.filesList = filesList;
    this.rootPath = rootPath;
  }

  @Override
  public void run() {
    try {
      WatchService service = 
          FileSystems.getDefault().newWatchService();

      rootPath.register(service,
              StandardWatchEventKinds.ENTRY_MODIFY);

      while(true){
        WatchKey key = service.take();

        for (WatchEvent event : key.pollEvents()){

          Path relativePath = (Path)event.context();

          Path absolutePath =
                    Paths.get(rootPath.toString(),
                            relativePath.toString());

          filesList.put(absolutePath);

        }

        //reset is invoked to put the key back to ready
        boolean valid = key.reset();

        //If the key is invalid, just exit.
        if ( !valid){
          break;
        }
      }

    } catch (IOException e) {

      e.printStackTrace();

    } catch (InterruptedException e) {

      e.printStackTrace();

      Thread.currentThread().interrupt();
    }

  }
}

The producer thread above watches a certain directory for file modifications and adds the absolute path of the file into the BlockingQueue collection passed to the producer thread via its constructor.

Consumer Thread

The consumer thread would invoke take() on the BlockingQueue instance and then use the Files API to read the contents. As take() is a blocking call, if the filesList collection is empty then it would just block and wait for the data to be available in the filesList collection.

class FileConsumer implements Runnable{

  BlockingQueue<Path> filesList;
  Path rootPath;

  public FileConsumer(BlockingQueue<Path> filesList, 
                      Path rootPath){
    this.filesList = filesList;
    this.rootPath = rootPath;
  }

  @Override
  public void run(){
    try {
      while(true){

        Path fileToRead = filesList.take();

        List<String> linesInFile = 
            Files.readAllLines(fileToRead, 
                               Charset.defaultCharset());

        System.out.println("reading file: "+fileToRead);

        for ( String line : linesInFile){
          System.out.println(line);
        }

      }
    } catch (InterruptedException e) {

      e.printStackTrace();

      Thread.currentThread().interrupt();
    } catch (IOException e) {

      e.printStackTrace();

    }

  }
}

Note: If you are writing to a file using Vim or some other editors which creates temporary files then you have to make sure you exclude such files being added to the queue.

Invoking the Producer and consumer

public class ProducerConsumerSample {

  public static void main(String[] args) {
 
    BlockingQueue<Path> filesList = 
        new LinkedBlockingQueue<>(10);
 
    Path rootPath = Paths.get("/tmp/nio");
    
    Thread producerThread = 
        new Thread(new FileProducer(filesList, rootPath));
    Thread consumerThread = 
        new Thread(new FileConsumer(filesList, rootPath));
 
    producerThread.start();
    consumerThread.start();
  }

}

Pretty straight forward- create instances of both the threads and then launch them. You can create multiple consumer threads as well! In the above example we make use of the LinkedBlockingQueue which is one of the implementations of the BlockingQueue.

You have to make sure you import corresponding classes in your source code. You can have all the three classes defined in the same file and name the file as ProducerConsumerSample.java and compile and run the code. Once you have the code running, then go to your terminal and type:

/tmp/nio$ touch file1
/tmp/nio$ echo "this is file1" >> file1
/tmp/nio$ touch file2
/tmp/nio$ echo "this is file2" >> file2

and the output you see on the terminal of your java program is:

reading file: /tmp/nio/file1
reading file: /tmp/nio/file1
this is file1
reading file: /tmp/nio/file2
reading file: /tmp/nio/file2
this is file2

Note: This code was compiled and tested on a Linux platform, please find similar ways of creating files on Windows when you run your code.

Download Source Code: New Features in JDBC 3.0 (70)

Defining savepoints

It is possible to programmatically control the creation and releasing of save points through JDBC 3.0. But before doing it, one must check whether the underlying database supports the concepts of savepoints. Save points provide multiple-level-control of database commit or rollback operations within a single transaction. For example, if two unrelated database operations have to happen with a single transaction, these two save points can be created for the very purpose. Then based on various business conditions, commit/rollback can be done to any of these save points within the same transaction. To illustrate the usage, consider the following example,

package net.javabeat.jdbc3.newfeatures.savepoint;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.Savepoint;

import net.javabeat.jdbc3.newfeatures.CommonUtils;

public class SavepointTest {
 public static void main(String[] args) throws Exception{
	Connection connection = CommonUtils.getConnection();
	DatabaseMetaData databaseMetadata = connection.getMetaData();
	if (databaseMetadata.supportsSavepoints()){
		System.out.println("Savepoints supported by
		       the target database");
		processTable(connection);
	}
	}

	private static void processTable(Connection connection)
		throws Exception{
		PreparedStatement pStatement = connection.prepareStatement("
		          INSERT INTO CUSTOMER VALUES (?, ?)");
		pStatement.setInt(1, 1);
		pStatement.setString(2, "New Customer");
		pStatement.execute();
		Savepoint countrySavepoint =
			connection.setSavepoint("country");
		pStatement = connection.prepareStatement("
		          INSERT INTO COUNTRY VALUES (?, ?)");
		pStatement.setInt(1, 1);
		pStatement.setString(2, "India");
		// Make this transaction to fail deliberately
		connection.rollback(countrySavepoint);
		connection.commit();
	}
}

As seen from the above example, the program checks whether save points are supported by the target database by querying methods available in DatabaseMetadata. Note for save points are created by calling the method setSavePoint() defined on the Connection object. A save point can be given a name so that at a later point of time, a transaction can be made to commit or rollback based on the name. In the example code, to illustrate the usage of save point, we deliberately rollback the operation related to customer table, whereas, the changes made to country table are committed.

Parameter Metadata

Construction of queries for statements such as prepared statements might involve specifying dynamic values through ‘?’. Previously, there was no support for the tools or for the applications to identify the parameter information embedded in the queries. Now, support has been added to retrieve the parameter information that is passed to prepared statements. Please refer the below code that illustrates the usage,

package net.javabeat.jdbc3.newfeatures.pmd;

import java.sql.Connection;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;

import net.javabeat.jdbc3.newfeatures.CommonUtils;

public class PMDTest {
	public static void main(String[] args) throws Exception{
		Connection connection = CommonUtils.getConnection();
		PreparedStatement pStatement = connection.prepareStatement(
			"INSERT INTO CUSTOMER VALUES (?, ?)");
		pStatement.setInt(1, 1);
		pStatement.setString(2, "New Customer");
		ParameterMetaData parameterMetadata = pStatement.getParameterMetaData();
		int parameterCount = parameterMetadata.getParameterCount();
		for (int index = 1; index <= parameterCount; index ++){
			String parameterClassName = parameterMetadata.getParameterClassName(index);
			int parameterMode = parameterMetadata.getParameterMode(index);
			String paramterTypeName = parameterMetadata.getParameterTypeName(index);
			System.out.println(parameterClassName + "/" + parameterMode + "/"
				+ "/" + paramterTypeName);
		}
	}
}

Auto Generated Keys

Execution of queries sometimes results in the automatic generation of fields or values for tables. The behavior is entirely dependent on the underlying database implementation. Previously, there was no standard mechanism for retrieving such information once the query is executed. Application developers are forced to use non-standard mechanisms for fetching information that happens outside the scope of query execution. For example, consider a table column containing a particular column, say ‘name’, and an equivalent upper column, let’s say ‘upper_name’. The value for the ‘upper_name’ will be automatically populated as soon as the value is populated for the ‘name’ column. This is one of the examples of auto generation feature and the newer specification supports this feature. Refer the code sample below,

package net.javabeat.jdbc3.newfeatures.autogenkey;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.Statement;

import net.javabeat.jdbc3.newfeatures.CommonUtils;

public class AutoGeneratedKeyTest {
	public static void main(String[] args) throws Exception{
		Connection connection = CommonUtils.getConnection();
		DatabaseMetaData databaseMetadata = connection.getMetaData();
		if (databaseMetadata.supportsGetGeneratedKeys()){
			processAutoGeneratedKeys(connection);
		}
	}

	private static void processAutoGeneratedKeys(Connection connection)
		throws Exception{
		System.out.println("Auto generated keys can be retrived");
		Statement statement = connection.createStatement();
		statement.execute("INSERT INTO ADDRESSINFORMATION (ADDRESSDATA ) " +
			"VALUES ('Address Text')", Statement.RETURN_GENERATED_KEYS);
		ResultSet resultSet = statement.getGeneratedKeys();
		java.sql.ResultSetMetaData rsMetadata = resultSet.getMetaData();
		for (int index = 1; index <= rsMetadata.getColumnCount(); index ++){
			while (resultSet.next()){
				String columnLabel = rsMetadata.getColumnName(index);
				System.out.println(resultSet.getObject(columnLabel));
			}
		}
	}

}

Note that, while executing the statement, the application has to provide indication to the underlying engine that, if any auto generation columns are applicable once the query is executed, those information have to be made available in the equivalent statement object. This is done through the method Statement.execute() where the second parameter specifies this option. Next, the method getGeneratedKeys() is added to the Statement object which returns a ResultSet containing the desired values. Because, this feature may or may not be supported by the database engine, the API supportsGeteGeneratedKeys() can be used to check the feature availability.

Updating clob/blob objects

The support to update clob objects is directly available on the Clob/Blob objects. The method updateClob() is added to the ResultSet object. Previously, there is no standard way to update large data objects. Note to ensure that this works and because the operation is defined on the ResultSet, the underlying ResultSet object should support updating the record. This is possible if the ResultSet is a flavor of CONCUR_UPDATABLE. Please refer the below code,

package net.javabeat.jdbc3.newfeatures.clblupdate;

import java.io.StringReader;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import net.javabeat.jdbc3.newfeatures.CommonUtils;

public class ClobTest {

	public static void main(String[] args) throws Exception{
		Connection connection = CommonUtils.getConnection();
		int key = 1;
		insertClob(connection, key);
		readAndUpdateClob(connection, key);
	}

	private static void insertClob(Connection connection, int key)
		throws Exception{
		String sql = "INSERT INTO CLOBTEST VALUES (?, ?)";
		PreparedStatement pStatement = connection.prepareStatement(sql);
		pStatement.setInt(1, key);
		StringReader reader = new StringReader("som big data");
		pStatement.setClob(2, reader);
		pStatement.execute();
	}

	private static void readAndUpdateClob(Connection connection, int key)
		throws Exception{
		String sql =  "SELECT DATA FROM CLOBTEST WHERE ID = ?";
		PreparedStatement pStatement = connection.prepareStatement(
			sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
		pStatement.setInt(1, key);
		ResultSet resultSet = pStatement.executeQuery();
		if (resultSet.next()){
			Clob clobObject = resultSet.getClob(1);
			clobObject.setString(1, "new big data");
			resultSet.updateClob(1, clobObject);
		}
	}
}

Conclusion

Download Source Code: New Features in JDBC 3.0 (70)

The new features in JDBC 3.0 have addressed most of the common problems that tools or developer community is encountering, thereby providing a unified way of solution. There are other minor updates done to JDBC 3.0, such as ‘configuring connection pools’, ‘adding of new data types as Boolean, Datalink, URL’ etc.

• Exploring the enhancements to the java.nio package as part of Java 7 we wrote about watching a directory for changes and also looked at few methods in the Files class.
• Writing agents in Java to instrument the class files/byte code.
• Using Fork-Join framework introduced as part of Java 7.
• Getting started with Scala.

News and updates:

Languages

• The JFXtras project has been enhanced to support JavaFX 2.0 and they have released an application named JFXTras Ensemble. Do check out the project to start using components which are not provided out of the box by JavaFX.
• Griffon 1.0 is out. Griffon is a framework for building Desktop applications which run on JVM using Groovy language. Think it of as Grails for desktop.
• Gradle 1.0 is released. Gradle is build automation tool which can automate the building, testing, publishing, deployment and more of software packages. Think of it as Ant and Maven on steroids.
• Scala 2.10.0 Milestone 4 is now available.

Cloud:

• Free Tomcat application hosting now supported by OpenShift, read here to know how.
• New OpenShift release and the features have been documented here.

Events:

• JVM Language Summit July 30–August 1, 2012 at Oracle Corporation: Santa Clara campus.
• Dustin writes about the availability of JavaOne 2012 content catalog.
• Google IO 2012- June 27-29, 2012 Moscone Center, San Francisco.

Podcasts:

• Java Spotlight Episode 86: Tony Printezis on Garbage Collection First
• Java Spotlight Episode 85: Migrating from Spring to JavaEE 6
• Java Posse #387 – Roundup ’12 – NoSQL
• Java Posse #386 – Newscast for May 31st 2012- Interesting discussion on handling of Nulls in various languages with special focus on Scala. Discussion about Play framework as well.

OpenShift is a Platform As A Service (Paas) offering from Red Hat joining the likes of Heroku, GAE, Jelastic and others. OpenShift supports Java EE, PHP, Node.js, Ruby, Python and Perl applications. I tried out deploying a simple Java EE application based on ZK Framework, interested people can have a look at the application running live here.

This article would cover:

• Setting up of OpenShift account, Maven and creating an application on cloud
• Developing and deploying the application on cloud

Setting up OpenShift Account, Creating application

First step to setting up of application is to create an account on the OpenShift website here. Once you have registered, you have to download and install the Command line tool for OpenShift cloud control which is Redhat Console(rhc). I used the Ruby gems to install the RHC tool which is as simple as:

$ sudo gem install rhc

Creating a domain and application

All the applications deployed on OpenShift are in a namespace which is nothing but the domain you create. Domain names have to be unique and are part of the URL to access the application.

#Creating a domain
$ rhc domain create -l <login> -n <domain name>
Password: <password>

Once the domain has been successfully created, the next step is to create an application:

#Creating an application
$rhc app create -a <application_name> -l <loginname> -t jbossas-7.0

-t option is used to specify the type of the application, which can be any one of the following:
php-5.3 — for PHP applications
wsgi-3.2 — for Web Server Gateway Interface applications
rack-1.1 — for Ruby Webserver Interface applications
perl-5.10 — for Perl applications
jbossas-7.0 — for JBoss AS applications (used for ZK project)
raw-0.1 — a raw cartridge type used to create applications of no specific type

A Cartridge is the other infrastructure elements that your application would use and these can be added using the same rhc app command. In our application we would not be using any of those and hence not being added.

The same operations can be performed from their web console as well. An advantage of using the command line is that once you create an domain using rhc command line, it adds the necessary ssh-keys, and also while creating the application it sets up the git repository as well. Deploying to OpenShift is as simple and pushing the application to the remote git repository, this is similar to the approach in Heroku.

Setting up Maven

The application is nothing but an Maven project. So if you are interested to run the application locally then you need to setup Maven as well. Download the Maven package from here, and setup the M2_HOME environment variable to the Maven home i.e the folder where the Maven package was extracted and also update the PATH variable to the M2_HOME/bin.

$mvn -version
Apache Maven 3.0.4 (r1232337; 2012-01-17 14:14:56+0530)
Maven home: /home/mohamed/maven
Java version: 1.7.0, vendor: Oracle Corporation
Java home: /home/mohamed/jdk1.7.0/jre

Developing and Deploying the Application

We would be using ZK framework for our sample application. The application reads from a JSON source about the Marathon Events in India and plots them on a Google Map. For reading the JSON source we would be using the GSON library.
We have to update the contents of pom.xml to reflect the ZK, GSON and other dependencies. One can even use Eclipse to develop the application and that is exactly what I did:

$ mvn eclipse:eclipse

and then load the project in eclipse. Also Eclipse should be able to resolve the libraries used in the application i.e all the ZK jars and the GSON jar. If you find any issue where eclipse complains about not finding the jars, then you must add a variable M2_REPO to Eclipse environment variables which would point to the directory where Maven downloads all the jars.
The JSON source for the marathon events is constructed from the details available on RunInfinity website.

There are few things to be done to plot the above data on a map:
1. Construct Gmarker data from the above data.
2. Obtain the Latitude and Longitude data from the location information. For this we make use of the Google Geocoding API.

The Model which holds the Marathon event information is:

public class MarathonEvent {
  @SerializedName("event_url")
  String url;
  String name;
  String date;
  String location;
  Location geoLocation;
  String formattedContent;
  @Override
  public String toString(){
    if ( formattedContent == null ){
      StringBuilder builder = new StringBuilder();
      builder.append("Date: "+date);
      builder.append("<br/>");
      builder.append("<a href=\""+url+"\">"+name+"</a>");
      builder.append("<br/>");
      builder.append(geoLocation.name);
      formattedContent = builder.toString();  
    }
    return formattedContent;
  }
}

Parsing the JSON source for Marathon Events list where the JSON source is marathon_events.json:

InputStream marathonEvenJsonSource = 
    getClass().getResourceAsStream("marathon_events.json");

Gson gson = new Gson();

JsonReader jsonReader = new JsonReader(
    new InputStreamReader(marathonEvenJsonSource));

JsonParser jsonParser = new JsonParser();

JsonArray jsonArray = jsonParser.parse(jsonReader).getAsJsonArray();

for ( JsonElement element : jsonArray){
  MarathonEvent marathonEvent = 
      gson.fromJson(element, MarathonEvent.class);
  marathonEvent.geoLocation = getGeoCode(marathonEvent.location);

  Gmarker gmarker = new Gmarker(marathonEvent.location,
      marathonEvent.geoLocation.latitude,
      marathonEvent.geoLocation.longitude);
  gmarker.setContent(marathonEvent.toString());
  
  marathonEvents.add(gmarker);
}

if you are not able to follow the JSON parsing code, please read our previous article regarding the same here.

The interesting part here is the getGeoCode(marathonEvent.location) call which is defined as:

public Location getGeoCode(String location) 
    throws MalformedURLException, IOException{
  String url = 
    "http://maps.googleapis.com/maps/api/geocode/json?address="+URLEncoder.encode(location, "UTF-8")+"&sensor=false";
  Location geoLocation = new Location(location);
  Gson gson = new Gson();
  InputStream in = new URL(url).openStream();
  JsonReader reader = new JsonReader(new InputStreamReader(in));
  JsonParser parser = new JsonParser();
  JsonObject jsonObject = parser.parse(reader).getAsJsonObject();
  //Fetch all the possible latitude/longitude results for this place
  JsonArray resultsArray = jsonObject.getAsJsonArray("results");
  
  if ( resultsArray.size() > 0 ){
    //Generally there's only one result, so pick the first. 
    JsonObject geoInformation = 
        resultsArray.get(0).getAsJsonObject();
    String formattedAddress = 
        geoInformation.get("formatted_address").getAsString();
    JsonObject locationJsonObj= 
      geoInformation.get("geometry")
                    .getAsJsonObject()
                    .get("location")
                    .getAsJsonObject();
    String latitude  = locationJsonObj.get("lat").getAsString();
    String longitude = locationJsonObj.get("lng").getAsString();
    geoLocation.latitude = Double.parseDouble(latitude);
    geoLocation.longitude = Double.parseDouble(longitude);
    geoLocation.name = formattedAddress;
  }
  return geoLocation;
}

The above code parses the JSON response obtained from the Google Places API and retrieves the formatted_address field and the latitude(lat) and longitude(lng) values. Here as well the GSON Library is used for parsing. The above two code snippets are part of the MarathonEventsSource class which is our source for model information to the views.

Now lets create a ZK based View and Controller/View Model class.

ZK Based View

<zk>
  <script type="text/javascript" 
  content="zk.googleAPIkey='AIzaSyAgYZVjw15TQWGxAMFv0ayA8OlAtVFkyx0'" />
  <window id="main" width="100%" height="100%" apply="net.javabeat.MarathonHomeComposer">
    <borderlayout>
      <north size="70px">
        <div>
        <html><![CDATA[
        <h2 style="color:#0C7A9A;margin-left:10px">Marathon Events in India</h2>
        ]]></html>
        </div>
      </north>
      <center flex="true">
        <div id="contentDiv" >
          <gmaps id="eventsMap" width="100%" height="100%" showSmallCtrl="true">
          <attribute name="onMapClick"><![CDATA[
          org.zkoss.gmaps.Gmarker gmarker = event.getGmarker();
          if (gmarker != null)
            gmarker.setOpen(true);
          ]]></attribute>
          </gmaps>
        </div>
      </center>
      <south size="20px">
        <hbox pack="center" width="100%">
        <html><![CDATA[
        <span style="color:#0C7A9A">Developed by Mohamed Sanaulla</span>
        ]]></html>
        </hbox>
      </south>
    </borderlayout>
  </window>
</zk>

Interesting pieces from the above code:
1. ZK provides different layouts for organising the contents and BorderLayout is one such layout. In this the content can be organized into 4 regions (exactly similar supported by Swing).
2. Gmaps is the component for embedding the Google Maps.
3. Each view can be backed a View Model class by using the apply attribute of window component apply="net.javabeat.MarathonHomeComposer"

Lets have a look at the MarathonHomeComposer class which is the View Model/Controller class.

public class MarathonHomeComposer extends GenericForwardComposer{

  MapModel mapModel;
  Gmaps eventsMap;
  Div contentDiv;

  public MarathonHomeComposer() 
      throws MalformedURLException, IOException{
    String marathonEventScheduleSource = 
      "http://runinfinity.com/calendar/india-marathon-calendar";
    MarathonEventsSource marathonEventsSource = 
        new MarathonEventsSource();
    List<Gmarker> marathonEvents = 
        marathonEventsSource.getMarathonEvents();	
    mapModel = new MapModelList(marathonEvents);

  }
  public void doAfterCompose(Component comp) throws Exception {
    super.doAfterCompose(comp);		
    eventsMap.setModel(mapModel);
    eventsMap.setZoom(9);
  }
}

Few observations from the View Model class:
1. It extends the GenericForwardComposer class which supports binding of the components between the View and the View Model based on the ids. For example- gmaps component has an id=”eventsMap” and the View Model MarathonHomeComposer class has an instance field by name: eventsMap. This is an easier way of binding the UI element to the Java layer, the other ways can be by using Annotations.
2. The model for the Gmaps is MapModel which is constructed using the MapModelList and the List obtained from the JSON parser (MarathonEventsSource class)
3. doAfterCompose method would have all the components (read Gmaps) initialized and hence we set the model in this method.

If you are interested in the source of this application, you can get it from the git repo here.

Deploying the application to OpenShift

As I said earlier, deploying the application is as simple as running git push command. If you run:

$ git remote -v
origin	ssh://ad221d298243438491c77f9cd9a83206@marathons-mylearning.rhcloud.com/~/git/marathons.git/ (fetch)
origin	ssh://ad221d298243438491c77f9cd9a83206@marathons-mylearning.rhcloud.com/~/git/marathons.git/ (push)

The remote named origin points to the git repo in the cloud. Deploying the application to OpenShift platform:

$ git push origin
# other output
remote: [INFO] BUILD SUCCESS
remote: [INFO] -------------------------------------------------
remote: [INFO] Total time: 30.888s
remote: [INFO] Finished at: Tue May 29 12:24:43 EDT 2012
remote: [INFO] Final Memory: 11M/111M
remote: [INFO] -------------------------------------------------
#other output

Once you have deployed the application, you can access the application by visting: http://-.rhcloud.com/marathonHome.zul

Let me summarize this huge post into:
1. Constructing the Model source for the Map- this involves reading the JSON source, obtaining the latitude and longitude information and then constructing the Gmarker objects.
2. Construct the view- marathonHome.zul which has the gmaps component.
3. Wire the View with the View Model class and also wire up the gmaps component with the model.

This sample application can be accessed here.

Some of the useful resources for this sample:
1. Gmaps Java documentation.
2. ZK Components Java Documentation.
3. ZK Live Demo.
4. Google Geocoding API
5. OpenShift Developer Resources.
6. Git Repository in GitHub.

Lot of developers out there at some point in time would want to know about an API to get the book details and I was in such a situation sometime back and I managed to find out about ISBNDb. But when I looked for the apis sometime later, I landed here where there are 53 APIs are listed. I am not sure how easy are others to use, but I found ISBNDb was just enough for my needs.

The base URL for the API is: https://isbndb.com/api/books.xml. It supports querying on lot of attributes like isbn, title, book_id, publisher_id (which are ISBNdb specific). In this example we are interested in using ISBN to query for the book details. But before proceeding further, you have to sign up to get access to the developer key. Once you have the developer key, to get the book details given the ISBN the URL would be: https://isbndb.com/api/books.xml?access_key=[KEY]&index1=isbn&value1=[ISBN]. The access_key query param would be assigned the key which you have obtained. index1, value1 are the params which are used to pass filter data for obtaining the book details.  We could even filter on book title wherein we add index2=title and value2=any_book_title.

Lets use this API to obtain the book details and this would be implemented in Groovy.

Our Model class for the holding a book details would be:

class Book {
  def isbn
  def title
  def authors
  def publisher
  def String toString(){
    "Title: ${title}\nISBN: ${isbn}\n"+
    "Authors: ${authors}\n"+
    "Publisher: ${publisher}"
  }
}

Building the URL for the API invocation:

def  baseURL = "https://isbndb.com/api/books.xml"
def  ACCESS_KEY = "YOUR_KEY"

def scanner = new Scanner(System.in);
println "Enter the ISBN"
def isbnInput = scanner.nextLine()
def queryParams = []
queryParams << "access_key=${ACCESS_KEY}"
queryParams << "index1=isbn"
queryParams << "value1=${isbnInput}"
def queryString = queryParams.join("&")
def completeApiURl = "${baseURL}?${queryString}"

The above code accepts the ISBN from the User and then prepares the required URL for invoking. One can see that we have made use of Java class in Groovy. The operator “<<” when used with an array appends the values to the array. And the join(“&”) would concatenate all the elements of the array using the “&” character. Once we have the complete URL, we make use of the java.net.URL class to obtain the XML Response and then use XmlSlurper (remember JsonSlurper?) to parse the XML to get the required information:

def apiResponse = new URL(completeApiURl).text
def xmlSlurper = new XmlSlurper()
def parsedXml = xmlSlurper.parseText(apiResponse)

def newBook =
  new Book(title:parsedXml.BookList.BookData.Title,
           isbn: parsedXml.BookList.BookData.@isbn,
           authors: parsedXml.BookList.BookData.AuthorsText,
           publisher: parsedXml.BookList.BookData.PublisherText)

println newBook

The complete code is:

def  baseURL = "https://isbndb.com/api/books.xml"
def  ACCESS_KEY = "MKKGCUMQ"

def scanner = new Scanner(System.in);
println "Enter the ISBN"
def isbnInput = scanner.nextLine()
def queryParams = []
queryParams << "access_key=${ACCESS_KEY}"
queryParams << "index1=isbn"
queryParams << "value1=${isbnInput}"
def queryString = queryParams.join("&")
def completeApiURl = "${baseURL}?${queryString}"
def apiResponse = new URL(completeApiURl).text
def xmlSlurper = new XmlSlurper()
def parsedXml = xmlSlurper.parseText(apiResponse)

def newBook = new Book(title:parsedXml.BookList.BookData.Title,
isbn: parsedXml.BookList.BookData.@isbn,
authors: parsedXml.BookList.BookData.AuthorsText,
publisher: parsedXml.BookList.BookData.PublisherText)
println newBook

class Book {
  def isbn
  def title
  def authors
  def publisher

  def String toString(){
    "Title: ${title}\n"+
    "ISBN: ${isbn}\n"+
    "Authors: ${authors}\n"+
    "Publisher: ${publisher}"
  }
}

The execution and output of the above code:

$ groovy BookManager.groovy
Enter the ISBN
098478280X
Title: Cracking the Coding Interview
ISBN: 098478280X
Authors: Gayle Laakmann McDowell,
Publisher: CareerCup