RestEasy: JAX-RS web service using JAXB + JSON example

In the previous article, we learnt and implemented an example on how to use JAX-RS Restful web service to send & receive XML data as request/response. Here, we will re-use and modify the same example to send & receive JSON data as web service request/response

JBoss RestEasy is a JAX-RS implementation for developing Restful web service in java. Once developed, it isn’t restricted to deploy only in JBoss Application Server but you can deploy in any other server like Apache Tomcat, Glassfish, Oracle Weblogic, etc

JAX-RS specification supports the conversion of Java objects to JSON & vice-versa using Jackson library

Still we need Java objects to send/receive data in JSON format so start designing your XML Schema Definition (XSD), as we can use JAXB Maven plugin to generate Java classes. Later this generated POJO used to exchange JSON data on the fly with the help of Jackson library

Annotation Used

@Path (ws.rs.Path)
@GET (ws.rs.GET)
@POST (ws.rs.POST)
@PUT (ws.rs.PUT)
@DELETE (ws.rs.DELETE)
@PathParam (ws.rs.PathParam)
@Consumes (ws.rs.Consumes)
@Produces (ws.rs.Produces)
MediaType (ws.rs.core.MediaType)

Technology Used

Java 1.7
Eclipse Luna IDE
RestEasy-3.0.8.Final
Apache Maven 3.2.1
Apache Tomcat 7.0.54
JBoss Application Server 7.1.1.Final

Mavenize or download required jars

Add RestEasy-3.0.8.Final dependencies to pom.xml

	<properties>
		<resteasy.version>3.0.8.Final</resteasy.version>
		<resteasy.scope>compile</resteasy.scope> <!-- compile(Tomcat) / provided(JBoss) -->
		<compileSource>1.7</compileSource>
		<maven.compiler.target>1.7</maven.compiler.target>
		<maven.compiler.source>1.7</maven.compiler.source>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>
		<!-- RESTEasy JAX RS Implementation -->
		<dependency>
			<groupId>org.jboss.resteasy</groupId>
			<artifactId>resteasy-jaxrs</artifactId>
			<version>${resteasy.version}</version>
			<scope>${resteasy.scope}</scope>
		</dependency>

		<!-- Resteasy Servlet Container Initializer -->
		<dependency>
			<groupId>org.jboss.resteasy</groupId>
			<artifactId>resteasy-servlet-initializer</artifactId>
			<version>${resteasy.version}</version>
			<scope>${resteasy.scope}</scope>
		</dependency>

		<!-- Resteasy Jackson Provider -->
		<dependency>
			<groupId>org.jboss.resteasy</groupId>
			<artifactId>resteasy-jackson-provider</artifactId>
			<version>${resteasy.version}</version>
			<scope>${resteasy.scope}</scope>
		</dependency>

		<!-- RESTEasy JAX RS Client -->
		<dependency>
			<groupId>org.jboss.resteasy</groupId>
			<artifactId>resteasy-client</artifactId>
			<version>${resteasy.version}</version>
			<scope>${resteasy.scope}</scope>
		</dependency>
	</dependencies>

Folks who aren’t familiar with Maven concepts or don’t require maven for their project, can download the below jars individually from the central repository or maven repository and include them in the classpath

JAXB – Generating java source files from XSD

Steps to generate java-sources from XML Schema Definition (XSD)

configure JAXB Maven plugin in pom.xml
write well-defined XSD for your service
use maven command “mvn generate-sources” to generate java source files

Configure JAXB Maven plugin

<!-- JAXB plugin to generate-sources from XSD -->
<plugin>
	<groupId>org.codehaus.mojo</groupId>
	<artifactId>jaxb2-maven-plugin</artifactId>
	<version>1.6</version>
	<executions>
		<execution>
			<goals>
				<goal>xjc</goal><!-- xjc/generate -->
			</goals>
			<configuration>
				<outputDirectory>${basedir}/generated/java/source</outputDirectory>
				<schemaDirectory>${basedir}/src/main/resources/com/resteasy/series/json/service/entities
				</schemaDirectory>
				<schemaFiles>*.xsd</schemaFiles>
				<schemaLanguage>XMLSCHEMA</schemaLanguage>
				<extension>true</extension>
				<args>
					<arg>-XtoString</arg>
				</args>
				<plugins>
					<plugin>
						<groupId>org.jvnet.jaxb2_commons</groupId>
						<artifactId>jaxb2-basics</artifactId>
						<version>0.6.4</version>
					</plugin>
				</plugins>
			</configuration>
		</execution>
	</executions>
</plugin>

Customer.xsd

Below XSD contains two elements with name “CustomerType” and “CustomerListType”

CustomerType contains three attributes namely customerId, name, age
CustomerListType which returns list of CustomerType

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
	targetNamespace="http://benchresources.in/cdm/Customer" xmlns:tns="http://benchresources.in/cdm/Customer"
	elementFormDefault="qualified">

	<!-- player object with three attributes -->
	<xsd:element name="CustomerType">
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element name="customerId" type="xsd:int" />
				<xsd:element name="name" type="xsd:string" />
				<xsd:element name="age" type="xsd:int" />
			</xsd:sequence>
		</xsd:complexType>
	</xsd:element>

	<!-- an object to contain lists of players referencing above player object -->
	<xsd:element name="CustomerListType">
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element ref="tns:CustomerType" minOccurs="0"
					maxOccurs="unbounded" />
			</xsd:sequence>
		</xsd:complexType>
	</xsd:element>

</xsd:schema>

Run mvn generate-sources

Look at the generated java source files in the generated folder

CustomerType.java

package in.benchresources.cdm.customer;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "customerId",
    "name",
    "age"
})
@XmlRootElement(name = "CustomerType")
public class CustomerType {

    protected int customerId;
    @XmlElement(required = true)
    protected String name;
    protected int age;

    public int getCustomerId() {
        return customerId;
    }

    public void setCustomerId(int value) {
        this.customerId = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String value) {
        this.name = value;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int value) {
        this.age = value;
    }
}

CustomerListType.java

package in.benchresources.cdm.customer;

import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "customerType"
})
@XmlRootElement(name = "CustomerListType")
public class CustomerListType {

    @XmlElement(name = "CustomerType")
    protected List<CustomerType> customerType;

    public List<CustomerType> getCustomerType() {
        if (customerType == null) {
            customerType = new ArrayList<CustomerType>();
        }
        return this.customerType;
    }
}

Directory Structure

Before moving on, let us understand the directory/package structure once you create project in Eclipse IDE

Maven has to follow certain directory structure

src/test/java –> test related files, mostly JUnit test cases
src/main/java –> create java source files under this folder
src/main/resources –> all configuration files placed here
src/test/resources –> all test related configuration files placed here
Maven Dependencies or Referenced Libraries –> includes jars in the classpath
WEB-INF under webapp –> stores web.xml & other configuration files related to web application

Project Structure (Package Explorer view in Eclipse)

Jars Libraries Used in the Project (Maven Dependencies)

Web application

For any web application, entry point is web.xml which describes how the incoming http requests are served / processed. Further, it describes about the global-context and local-context param (i.e.; <context-param> & <init-param>) for loading files particular to project requirements & contains respective listener

With this introduction, we will understand how we configured web.xml for RestEasy JAX-RS Restful web service

web.xml (the entry point –> under WEB-INF)

This web.xml file describes,

Like any JEE web framework register org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher with servlet container
http requests with URL pattern “/resteasy/*” will be sent to the registered servlet called “javax.ws.rs.core.Application” i.e.; HttpServletDispatcher (org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher)
set resteasy.servlet.mapping.prefix as <context-param>, if your servlet-mapping has a url-pattern anything other than “/*”. In this example, set “/resteasy”
if not set, then you will end up with 404 not found error
set resteasy.resources as <param-name> with comma delimited list of fully qualified JAX-RS resource class names you want to register as <param-value> using global <context-param>
<welcome-file-list> files under this tag is the start-up page

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

	<display-name>RestEasy-JSON-IO</display-name>

	<!-- RestEasy resource registering -->
	<context-param>
		<param-name>resteasy.resources</param-name>
		<param-value>com.resteasy.series.json.service.CustomerServiceImpl</param-value>
	</context-param>

	<!-- RestEasy Servlet -->
	<servlet>
		<servlet-name>javax.ws.rs.core.Application</servlet-name>
		<servlet-class>org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher</servlet-class>
	</servlet>

	<servlet-mapping>
		<servlet-name>javax.ws.rs.core.Application</servlet-name>
		<url-pattern>/resteasy/*</url-pattern>
	</servlet-mapping>

	<!-- this is mandatory, if url-pattern is other than /* -->
	<context-param>
		<param-name>resteasy.servlet.mapping.prefix</param-name>
		<param-value>/resteasy</param-value>
	</context-param>

	<!-- welcome file -->
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
	</welcome-file-list>

</web-app>

Let’s see coding in action

URL Pattern

Http url for any common web application is http://<server>:<port>/<root-context>/<from_here_application_specific_path>

In our example, we are going to deploy the war into Tomcat 7.0 server so our server and port are localhost and 8080 respectively. Context root is the project name i.e.; RestEasy-JSON-IO. Initial path for this application is http://localhost:8080/RestEasy-JSON-IO

We have configured “/resteasy/*” as url-pattern for the “javax.ws.rs.core.Application” servlet in web.xml and at interface-level (or say class-level) path configured is “/customerservice” using @Path annotation. Next respective path for each method annotated with @Path (method-level)

Customer Service interface

Defines simple CURD operations

@POST – create/inserts a new resource (new customer)
@GET – read/selects internal resource representation based on the customerId
@PUT – update/modifies an internal resource representation (modify customer)
@DELETE – delete/removes a resource (delete customer)
@GET – retrieves all players (get all customers)

Let’s discuss @Produces, @Consumes and MediaType

@Consumes
Defines which MIME type is consumed by this method. For this example, exposed methods are restricted to consume only JSON data and it is annotated with @Consumes(MediaType.APPLICATION_JSON)

@Produces
Defines which MIME type it will produce. For this example, exposed methods are restricted to produce only JSON data and it is annotated with @Produces(MediaType.APPLICATION_JSON)

Most widely used Media Types are

MediaType.APPLICATION_XML,
MediaType.APPLICATION_JSON,
MediaType.TEXT_PLAIN,
MediaType.TEXT_XML,
MediaType.APPLICATION_FORM_URLENCODED,
etc

NOTE: It’s always a good programming practice to do code-to-interface and have its implementation separately

ICustomerService.java

package com.resteasy.series.json.service;

import in.benchresources.cdm.customer.CustomerListType;
import in.benchresources.cdm.customer.CustomerType;

import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/customerservice")
public interface ICustomerService {

	// Basic CRUD operations for Customer Service

	// http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/addcustomer  - Tomcat 7.0.x
	// http://localhost:9090/RestEasy-JSON-IO/resteasy/customerservice/addcustomer  - JBoss AS7
	@POST
	@Path("addcustomer")
	@Consumes({MediaType.APPLICATION_JSON})
	@Produces({MediaType.APPLICATION_FORM_URLENCODED})
	public String createOrSaveNewCustomerInfo(CustomerType customerType);

	// http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/getcustomer/10001  - Tomcat 7.0.x
	// http://localhost:9090/RestEasy-JSON-IO/resteasy/customerservice/getcustomer/10001  - JBoss AS7
	@GET
	@Path("getcustomer/{id}")
	@Consumes({MediaType.APPLICATION_FORM_URLENCODED})
	@Produces({MediaType.APPLICATION_JSON})
	public CustomerType getCustomerInfo(@PathParam("id") int customerId);

	// http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/updatecustomer  - Tomcat 7.0.x
	// http://localhost:9090/RestEasy-JSON-IO/resteasy/customerservice/updatecustomer  - JBoss AS7
	@PUT
	@Path("updatecustomer")
	@Consumes({MediaType.APPLICATION_JSON})
	@Produces({MediaType.APPLICATION_FORM_URLENCODED})
	public String updateCustomerInfo(CustomerType Customer);

	// http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/deletecustomer  - Tomcat 7.0.x
	// http://localhost:9090/RestEasy-JSON-IO/resteasy/customerservice/deletecustomer  - JBoss AS7
	@DELETE
	@Path("deletecustomer")
	@Consumes({MediaType.APPLICATION_JSON})
	@Produces({MediaType.APPLICATION_FORM_URLENCODED})
	public String deleteCustomerInfo(CustomerType Customer);

	// http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/getallcustomer  - Tomcat 7.0.x
	// http://localhost:9090/RestEasy-JSON-IO/resteasy/customerservice/getallcustomer  - JBoss AS7
	@GET
	@Path("getallcustomer")
	@Consumes({MediaType.APPLICATION_FORM_URLENCODED})
	@Produces({MediaType.APPLICATION_JSON})
	public CustomerListType getAllCustomerInfo();
}

Customer Service implementation

Implements above interface

CustomerServiceImpl.java

package com.resteasy.series.json.service;

import in.benchresources.cdm.customer.CustomerListType;
import in.benchresources.cdm.customer.CustomerType;

public class CustomerServiceImpl implements ICustomerService {

	/**
	 * returns a String value with SUCCESS message after adding/saving a New Customer information
	 */
	@Override
	public String createOrSaveNewCustomerInfo(CustomerType customerType) {

		// get the player information from formal arguments and inserts into database & return playerId (primary_key)
		return "Customer information saved successfully with Customer_ID " + customerType.getCustomerId();
	}

	/**
	 * retrieves a customer information object based on the ID supplied in the formal argument using @PathParam
	 */
	@Override
	public CustomerType getCustomerInfo(int customerId) {

		// retrieve player based on the id supplied in the formal argument
		CustomerType customerType = new CustomerType();
		customerType.setCustomerId(customerId);
		customerType.setName("Napaa");
		customerType.setAge(42);
		return customerType;
	}

	/**
	 * returns a String value with SUCCESS message after updating customer information
	 */
	@Override
	public String updateCustomerInfo(CustomerType customerType) {

		// update customer info & return SUCCESS message
		return "Customer information updated successfully";
	}

	/**
	 * returns a String value with SUCCESS message after deleting customer information
	 */
	@Override
	public String deleteCustomerInfo(CustomerType customerType) {

		// delete customer info & return SUCCESS message
		return "Customer information deleted successfully";
	}

	/**
	 * retrieves all customer stored
	 */
	@Override
	public CustomerListType getAllCustomerInfo() {

		// create a object of type CustomerListType which takes customer objects in its list
		CustomerListType customerListType = new CustomerListType();

		CustomerType customerOne = new CustomerType();
		customerOne.setCustomerId(10025);
		customerOne.setName("Master Hoshi");
		customerOne.setAge(85);
		customerListType.getCustomerType().add(customerOne); // add to customerListType

		CustomerType customerTwo = new CustomerType();
		customerTwo.setCustomerId(10026);
		customerTwo.setName("Shin");
		customerTwo.setAge(50);
		customerListType.getCustomerType().add(customerTwo); // add to customerListType

		return customerListType;
	}
}

Deployment

Run maven command to build the war: mvn clean install (use command prompt or integrated maven in eclipse IDE
Copy the war file from the target folder
Paste it into apache tomcat (webapps folder)
Start the tomcat server

Test the service !!

Testing

There are many ways to do testing

Copy the URL of GET service into web browser
Advanced REST client from Google Chrome
Rest client in Mozilla Firefox Add On
Write your own client for example, Java client using improved CloseableHttpClient from Apache
JDK’s in-built classes like HttpURLConnection
Using Client, WebTarget from core JAX-RS classes javax.ws.rs.client
Using ResteasyClient, ResteasyWebTarget and Response classes from JBoss package org.jboss.resteasy.client
Using ClientRequest and ClientResponse classes from JBoss package org.jboss.resteasy.client

1. Using RestClient from Mozilla Firefox Add-On

First service: @POST (createOrSaveNewCustomerInfo())
URL: http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/addcustomer
Request:

{
  "customerId": 10001,
  "name": "Napaa",
  "age": 42
}

Content-Type: application/json
Accept: application/x-www-form-urlencoded
Response: Customer information saved successfully with Customer_ID 10001

Second service: @GET (getCustomerInfo())
URL: http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/getcustomer/10001
Request: None
Content-Type: application/x-www-form-urlencoded
Accept: application/json
Response:

{
  "customerId": 10001,
  "name": "Napaa",
  "age": 42
}

Third service: @PUT (updateCustomerInfo())
URL: http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/updatecustomer
Request:

{
  "customerId": 10001,
  "name": "Napaa",
  "age": 42
}

Content-Type: application/json
Accept: application/x-www-form-urlencoded
Response: Customer information updated successfully

Fourth service: @DELETE (deleteCustomerInfo())
URL: http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/deletecustomer
Request:

{
  "customerId": 10001,
  "name": "Napaa",
  "age": 42
}

Content-Type: application/json
Accept: application/x-www-form-urlencoded
Response: Customer information deleted successfully

Fifth service: @GET (getAllCustomerInfo())
URL: http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/getallcustomer
Request: None
Content-Type: application/x-www-form-urlencoded
Accept: application/json
Response:

{
  "CustomerType": [
    {
      "customerId": 10025,
      "name": "Master Hoshi",
      "age": 85
    },
    {
      "customerId": 10026,
      "name": "Shin",
      "age": 50
    }
  ]
}

2. Java client (RestEasy)

There are two test clients which comes from JBoss RestEasy package org.jboss.resteasy.client and org.jboss.resteasy.client.jaxrs

ClientRequest and ClientResponse for invoking getCustomerInfo service
ResteasyClient, ResteasyClientBuilder and ResteasyWebTarget for invoking addCustomerInfo service

Self-explanatory !!

Note: above clients can be interchanged. No restriction, only needs to set correct http request parameters

TestCustomerService.java

package test.resteasy.series.json.service;

import javax.ws.rs.HttpMethod;
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

import org.jboss.resteasy.client.ClientRequest;
import org.jboss.resteasy.client.ClientResponse;
import org.jboss.resteasy.client.jaxrs.ResteasyClient;
import org.jboss.resteasy.client.jaxrs.ResteasyClientBuilder;
import org.jboss.resteasy.client.jaxrs.ResteasyWebTarget;

public class TestCustomerService {

	public static void main(String[] args) throws Exception {

		// setting & invoking first service getCustomer/10024
		System.out.println("Invoking and executing getCustomer service for customer id 24001");
		String httpGetURL = "http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/getcustomer/24001";
		String responseStringGet = testCustomerServiceForGetRequest(httpGetURL);
		System.out.println("GET >> Response String : " + responseStringGet);

		// setting & invoking second service addCustomer with XML request
		System.out.println("\n\nInvoking and executing addCustomer service with request JSON");
		String httpPostURL = "http://localhost:8080/RestEasy-JSON-IO/resteasy/customerservice/addcustomer";
		String requestString = "{"
				+ 					" \"customerId\": 10030, "
				+ 					" \"name\": \"Yam Cha\","
				+ 					"\"age\": 30 "
				+				"}";
		String responseStringPost = testCustomerServiceForPostRequest(httpPostURL, requestString);
		System.out.println("POST >> Response String : " + responseStringPost);
	}

	/**
	 * using ClientRequest and ClientResponse classes from org.jboss.resteasy.client
	 * @param httpURL
	 * @return responseString
	 * @throws Exception
	 */
	@SuppressWarnings("deprecation")
	public static String testCustomerServiceForGetRequest(String httpURL) throws Exception {

		// local variables
		ClientRequest clientRequest = null;
		ClientResponse<String> clientResponse = null;
		int responseCode;
		String responseString = null;

		try{
			clientRequest = new ClientRequest(httpURL);
			clientRequest.setHttpMethod(HttpMethod.GET);
			clientRequest.header("Content-Type", MediaType.APPLICATION_FORM_URLENCODED);
			clientRequest.accept(MediaType.APPLICATION_JSON);
			clientResponse = clientRequest.get(String.class);

			responseCode = clientResponse.getResponseStatus().getStatusCode();
			System.out.println("Response code: " + responseCode);

			if(clientResponse.getResponseStatus().getStatusCode() != 200) {
				throw new RuntimeException("Failed with HTTP error code : " + responseCode);
			}

			System.out.println("ResponseMessageFromServer: " + clientResponse.getResponseStatus().getReasonPhrase());
			responseString = clientResponse.getEntity();
		}
		catch(Exception ex) {
			ex.printStackTrace();
		}
		finally{
			// release resources, if any
			clientResponse.close();
			clientRequest.clear();
		}
		return responseString;
	}

	/**
	 * using ResteasyClient, ResteasyWebTarget and Response classes from org.jboss.resteasy.client
	 * @param httpURL
	 * @param requestString
	 * @return
	 */
	public static String testCustomerServiceForPostRequest(String httpURL, String requestString) {

		// local variables
		ResteasyClient resteasyClient = null;
		ResteasyWebTarget resteasyWebTarget = null;
		Response response = null;
		int responseCode;
		String responseString = null;

		try{
			resteasyClient = new ResteasyClientBuilder().build();
			resteasyWebTarget = resteasyClient.target(httpURL);
			resteasyWebTarget.property("Content-Type", MediaType.APPLICATION_FORM_URLENCODED);
			resteasyWebTarget.property("accept", MediaType.APPLICATION_JSON);
			response = resteasyWebTarget.request(MediaType.APPLICATION_FORM_URLENCODED).post(Entity.entity(requestString, MediaType.APPLICATION_JSON));

			responseCode = response.getStatus();
			System.out.println("Response code: " + responseCode);

			if (response.getStatus() != 200) {
				throw new RuntimeException("Failed with HTTP error code : " + responseCode);
			}

			System.out.println("ResponseMessageFromServer: " + response.getStatusInfo().getReasonPhrase());
			responseString = response.readEntity(String.class);
		}
		catch(Exception ex){
			ex.printStackTrace();
		}
		finally{
			// release resources, if any
			response.close();
		}
		return responseString;
	}
}

Output in console

Invoking and executing getCustomer service for customer id 24001
Response code: 200
ResponseMessageFromServer: OK
GET >> Response String : {"customerId":24001,"name":"Napaa","age":42}


Invoking and executing addCustomer service with request JSON
Response code: 200
ResponseMessageFromServer: OK
POST >> Response String : Customer information saved successfully with Customer_ID 10030

Download project (Tomcat Server 7.0.x)

RestEasy-JSON-IO (Tomcat server) (13kB)

JBoss Deployment

Update pom.xml with resteasy scope “provided” for dependencies as JBoss AS7 modules already contains these dependent jars
```
<resteasy.scope>provided</resteasy.scope> 
```

Update web.xml
web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

	<display-name>RestEasy-JSON-IO</display-name>

	<!-- RestEasy Servlet -->
	<servlet-mapping>
		<servlet-name>javax.ws.rs.core.Application</servlet-name>
		<url-pattern>/resteasy/*</url-pattern>
	</servlet-mapping>

	<!-- welcome file -->
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
	</welcome-file-list>

</web-app>

Rest remain the same
Read through this article which explains development & deployment of RestEasy web service with JBoss Application Server in detail

Note: JBoss Application Server 7.1.1.Final comes with default RestEasy distribution with version 2.3.2.Final. So update JBoss AS7 with latest RestEasy version. Look at this article, which explains how to update default version with latest version available in the JBoss community

Download project (JBoss Application Server 7.1.1.Final)

RestEasy-JSON-IO (JBoss server) (13kB)

Conclusion: Thus, JSON format can be used to send/receive data where performance is a big consideration as it is light-weight. Especially, in mobile development client prefer to use JSON data for web service interaction

Happy Coding !!
Happy Learning !!

BenchResources.Net

Java tutorial for beginners

RestEasy: JAX-RS web service using JAXB + JSON example

Annotation Used

Technology Used

Mavenize or download required jars

JAXB – Generating java source files from XSD

Configure JAXB Maven plugin

Customer.xsd

Run mvn generate-sources

CustomerType.java

Directory Structure

Project Structure (Package Explorer view in Eclipse)

Jars Libraries Used in the Project (Maven Dependencies)

Web application

web.xml (the entry point –> under WEB-INF)

web.xml

Let’s see coding in action

URL Pattern

Customer Service interface

ICustomerService.java

Customer Service implementation

CustomerServiceImpl.java

Deployment

Testing

1. Using RestClient from Mozilla Firefox Add-On

2. Java client (RestEasy)

TestCustomerService.java

Output in console

Download project (Tomcat Server 7.0.x)

JBoss Deployment

Download project (JBoss Application Server 7.1.1.Final)

Related

Annotation Used

Technology Used

Mavenize or download required jars

JAXB – Generating java source files from XSD

Configure JAXB Maven plugin

Customer.xsd

Run mvn generate-sources

CustomerType.java

Directory Structure

Project Structure (Package Explorer view in Eclipse)

Jars Libraries Used in the Project (Maven Dependencies)

Web application

web.xml (the entry point –> under WEB-INF)

web.xml

Let’s see coding in action

URL Pattern

Customer Service interface

ICustomerService.java

Customer Service implementation

CustomerServiceImpl.java

Deployment

Testing

1. Using RestClient from Mozilla Firefox Add-On

2. Java client (RestEasy)

TestCustomerService.java

Output in console

Download project (Tomcat Server 7.0.x)

JBoss Deployment

Download project (JBoss Application Server 7.1.1.Final)

Related

Related posts: