Developing RESTful Web Services with Jersey 2.0

JAX-RS 2.0 is a framework that helps you in writing the RESTful web services on the client side as well as on the server side. Jersey 2.0 is the reference implementation of the JAX-RS 2.0 (JSR 339 specification). Along with the enhancements in Java EE 7, JAX-RS 2.0 has also been revised dramatically.

The following is a list of the RESTful principles that must be followed:

Before moving ahead, let's look at the existing features of JAX-RS 1.0:

As a part of Java EE 7, it is easy to create RESTful web services using JAX-RS 2.0. Using JAX-RS annotations, we can map the POJO resource class to the URIs and the URI templates. Using annotations, it becomes easier to develop web services. Different @*Param annotations are available to access the values of the user request:

JAX-RS also supports all the Java data types to be supplied in the @*Param annotations. There are other APIs available to create the RESTful web services, but mostly they require more coding. However, in the Jersey implementation of JAX-RS, it is simpler and easier to create the RESTful web services. JAX-RS manages to encode and decode the request/response content according to the media type it mentioned.

To provide backward compatibility, all Jersey applications are compiled with Java SE 6. Thus, we can run our Jersey application on Java SE 6 easily though JAX-RS 2.0 is part of Java EE 7.

To create Jersey-based applications, we require several dependencies and for other modules, we require third-party dependencies. Jersey dependencies are loosely-coupled and separated according to the module dependencies. Jersey dependencies are lightweight, so our application has much complexity for dependencies and creation of the RESTful web services.

The following are the core Jersey modules:

Apart from these dependencies, there are Jersey Containers, Connectors, Media, Extensions, Test Framework, and Glassfish Bundles. These dependencies can be easily plugged. You can find Jersey 2.0 binaries on the Jersey 2.0 Maven repository,

http://repo1.maven.org/maven2/org/glassfish/jersey/,

and on

https://maven.java.net/content/repositories/releases/org/glassfish/jersey/.

The first step for creating a new project is to accumulate the required tools:

Firstly, we will create a web project using Eclipse IDE. Go to File | New | Others | Dynamic Web Project. Follow the steps, and after the project is created, add the following libraries into the classpath:

Now, we need to configure web.xml to the bound Jersey Container with the resources packages:

...........
<servlet>
  <servlet-name>simpleJerseyExample</servlet-name>
  <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
  <init-param>
    <param-name>jersey.config.server.provider.packages</param-name>
    <param-value>com.demo</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
  <servlet-name>simpleJerseyExample</servlet-name>
  <url-pattern>/services/*</url-pattern>
</servlet-mapping>
...........

A servlet container is treated as a controller to redirect the specified resource that is being called. jersey.config.server.provider.packages maps the resources that are available in the com.demo package. So, whenever any resource is being requested, ServletContainer checks into the com.demo package for the resource URI and serves the request accordingly.

The next step is to create the Resource class that contains the business logic:

package com.demo;

import javax.ws.rs.Path;
import javax.ws.rs.Get;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.Produces;

/**
*    helloWorld Root Resource
*/
@Path("helloWorld")
public class HelloWorldResource{

  @GET
  @PRODUCES(MediaType.TEXT_PLAIN)
  public String greet(){
    return "Hello World!!!";
  }
}

A JAX-RS resource is an annotated POJO, which provides the so-called resource methods that are able to handle the HTTP requests for the URI paths bound to the resource. In the previous code, "helloWorld" is the resource URI:

@Path("helloWorld")

To run the application, create a WAR file and deploy it on the Apache Tomcat Server. Once the project is deployed on the Tomcat server, we are ready to consume the "helloWorld" web service. We can type the resource URL in the browser or we can use curl:

$curl http://localhost:8080/projectName/services/helloWorld
Hello World!!!

We have covered a brief introduction about the JAX-RS 2.0 and Jersey 2.0 features that have enriched the JAX-RS web services. We've analyzed a simple RESTful web service example that shows the basic implementation of the JAX-RS 2.0. In the next chapter, we will see how to use the Server API with different examples of complete sets of code to implement the Server-side web services.