TECHIE KERNEL: RESTEASY

Showing posts with label RESTEASY. Show all posts

Thursday, December 13, 2012

Spring and RESTEasy

9:09:00 PM Posted by Satish J2EE, JAVA, JAX-RS, JBOSS, MAVEN, REST, RESTEASY, SPRING, TUTORIALS, WEB SERVICE No comments

This tutorial I am going to demonstrate how to integrate Jboss RESTEasy and Spring 3 to create a RESTFul web service. Using this I am going to show how use spring context to get the service bean in web service class.

I am going to use the following tools and technologies.

Jersey 2.2.1.GA
Spring 3.0.5.RELEASE
JDK 1.7
Tomcat 7.0
Maven
Eclipse

I am going to take you to the following areas in this tutorial.

Service Layer Interface
Service Layer Class
Web Service Class
Spring Bean Configuration
Configuration for Spring and RESTEasy
Application Deployment
Testing

Before start coding let's create a dynamic web project using the following maven command.

1	mvn archetype:generate -DgroupId=com.techiekernel.rest -DartifactId=Spring-RESTEasy -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

After executing, the project will be get created with pom.xml file. As I am using JDK 7 and annotations, I have to specify the updated maven plugin. After giving the RESTEasy and Spring dependency, the pom.xml looks as following.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.techiekernel.rest</groupId>
  <artifactId>Spring-RESTEasy</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>JAXRS-Jersey Maven Webapp</name>
  <url>http://maven.apache.org</url>

  <repositories>
    <repository>
      <id>JBoss repository</id>
      <url>https://repository.jboss.org/nexus/content/groups/public-jboss/</url>
    </repository>
  </repositories>
 
  <dependencies>
 
    <!-- JBoss RESTEasy -->
    <dependency>
      <groupId>org.jboss.resteasy</groupId>
      <artifactId>resteasy-jaxrs</artifactId>
      <version>2.2.1.GA</version>
    </dependency>
 
    <!-- Spring 3 dependencies -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>3.0.5.RELEASE</version>
    </dependency>
 
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>3.0.5.RELEASE</version>
    </dependency>
 
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>3.0.5.RELEASE</version>
    </dependency>
 
    <!-- need for solution 1, if your container don't have this -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.4</version>
    </dependency>
    </dependencies>
    <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <version>2.1.1</version>
      </plugin>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.5</source>
          <target>1.5</target>
        </configuration>
      </plugin>
    </plugins>
    <finalName>Spring-RESTEasy</finalName>
  </build>
</project>

Service Layer Interface:

package com.techiekernel.service;

public interface FooBarService {
  public String getMessage(String msg);
}

Service Layer Class:

package com.techiekernel.service;

public class FooBarServiceImpl implements FooBarService{
  public String getMessage(String msg) {
    String output = "FooBar say : " + msg;
    return output;
  }
}

Web Service Class:

package com.techiekernel.rest;

import javax.servlet.ServletContext;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.Response;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.web.context.support.WebApplicationContextUtils;

import com.techiekernel.service.FooBarService;

@Component
@Path("/foobar")
public class FooBarWS {
  FooBarService fooBarService;
 
  @GET
  @Path("/{param}")
  public Response getMessage(@PathParam("param") String msg, @Context ServletContext servletContext) {
    //get Spring application context
        ApplicationContext ctx = 
                         WebApplicationContextUtils.getWebApplicationContext(servletContext);
        fooBarService= ctx.getBean("FooBar",FooBarService.class);
    return Response.status(200).entity(fooBarService.getMessage(msg)).build();
  }
}

Using the spring context to get the bean in stead of IOC does not look good to me. I suggest you to check this post for better integration. I followed the example, but that did not work for me.. So I end up doing this mess. But I strongly suggest to give a try to this post.

Spring Bean Configuration:

Now it is time to create the configuration for spring beans in applicationContext.xml. It is very much required to place the following configuration in classpath, so that container will read from the deployment descriptor.

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context-3.0.xsd">

  <context:component-scan base-package="com.techiekernel.rest" />

  <bean id="FooBar" class="com.techiekernel.service.FooBarServiceImpl" />

</beans>

Configuration for Spring and RESTEasy:

The integration is going to be in web.xml. Register Spring “ContextLoaderListener” listener class and specify the RESTEasy servlet “org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher“ as front controller for web services.

<web-app id="WebApp_ID" version="2.4"
  xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
  http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <display-name>Spring RESTEasy</display-name>

  <context-param>
    <param-name>resteasy.resources</param-name>
    <param-value>com.techiekernel.rest.FooBarWS</param-value>
  </context-param>
 
  <listener>
    <listener-class>
      org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap
                </listener-class>
  </listener>
 
  <listener>
    <listener-class>
                        org.springframework.web.context.ContextLoaderListener
                </listener-class>
  </listener>
 
 <!-- this need same with resteasy servlet url-pattern -->
  <context-param>
    <param-name>resteasy.servlet.mapping.prefix</param-name>
    <param-value>/ws</param-value>
  </context-param>
  <servlet>
    <servlet-name>resteasy-servlet</servlet-name>
    <servlet-class>
      org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher
                </servlet-class>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>resteasy-servlet</servlet-name>
    <url-pattern>/ws/*</url-pattern>
  </servlet-mapping>
</web-app>

Application Deployment:

Now every thing is ready and time to build for creating a war file.

1	mvn clean install;

n successful completion of the above command a war file will be get created in target folder. Copy the war file to webapp folder of your tomcat and start the tomcat.

Testing:

Once tomcat is started use the following url to access the web service.

1	http://localhost:8080/Spring-RESTEasy/ws/foobar/techiekernel

Once you hit the url in the browser, you are going to get the following output.

1	FooBar say : techiekernel

Source Code:

You can pull the code from GitHub.

JAX-RS With Jboss RESTEasy

5:10:00 PM Posted by Satish J2EE, JAVA, JAX-RS, JBOSS, MAVEN, RESTEASY, TUTORIALS, WEB SERVICE No comments

RESTEasy, JBoss project, implementation of the JAX-RS specification. In this tutorial, I will show you how to develop a simple RESTful web service with RESTEasy framework.

I am going to use the following tools and technologies.

RESTEasy 2.2.1.GA
JDK 1.7
Tomcat 7.0
Maven
Eclipse

I am going to take you to the following areas in this tutorial.

Service Class and Mapping Configuration
Front Controller And Listener Configuration
Application Deployment
Testing

Before start coding let's create a dynamic web project using the following maven command.

1	mvn archetype:generate -DgroupId=com.techiekernel.rest -DartifactId=JAXRS-RESTEasy -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.techiekernel.rest</groupId>
  <artifactId>JAXRS-RESTEasy</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>JAXRS-Jersey Maven Webapp</name>
  <url>http://maven.apache.org</url>

  <repositories>
    <repository>
      <id>JBoss repository</id>
      <url>https://repository.jboss.org/nexus/content/groups/public-jboss/</url>
    </repository>
  </repositories>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.jboss.resteasy</groupId>
      <artifactId>resteasy-jaxrs</artifactId>
      <version>2.2.1.GA</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <version>2.1.1</version>
      </plugin>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.5</source>
          <target>1.5</target>
        </configuration>
      </plugin>
    </plugins>
    <finalName>JAXRS-RESTEasy</finalName>
  </build>
</project>

Service Class and Mapping Configuration:

package com.techiekernel.rest;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.core.Response;

@Path("/foobar")
public class FooBarService {
  @GET
  @Path("/{param}")
  public Response getMsg(@PathParam("param") String msg) {
 
    String output = "Jersey say : " + msg;
 
    return Response.status(200).entity(output).build();
 
  }
}

Front Controller and Listener Configuration:

<web-app id="WebApp_ID" version="2.4"
  xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
  http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <display-name>JAXRS-RESTEasy</display-name>
  <!-- Auto scan REST service -->
  <context-param>
    <param-name>resteasy.scan</param-name>
    <param-value>true</param-value>
  </context-param>

  <!-- this need same with resteasy servlet url-pattern -->
  <context-param>
    <param-name>resteasy.servlet.mapping.prefix</param-name>
    <param-value>/ws</param-value>
  </context-param>

  <listener>
    <listener-class>
      org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap</listener-class>
  </listener>

  <servlet>
    <servlet-name>resteasy-servlet</servlet-name>
    <servlet-class>
      org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>resteasy-servlet</servlet-name>
    <url-pattern>/ws/*</url-pattern>
  </servlet-mapping>
</web-app>

You need to set the “resteasy.servlet.mapping.prefix” if your servlet-mapping for the resteasy servlet has a url-pattern other than “/*“.

In above example, the resteasy servlet url-pattern is “/ws/*“, so you have to set the “resteasy.servlet.mapping.prefix” to “/ws” as well, otherwise, you will hit resource not found error message.

Remember to set “resteasy.scan” to true, so that RESTEasy will find and register your REST service automatically.

Application Deployment:

Now every thing is ready and time to build for creating a war file.

1	mvn clean install;

On successful completion of the above command a war file will be get created in target folder. Copy the war file to webapp folder of your tomcat and start the tomcat.

Testing:

Once tomcat is started use the following url to access the web service.

1	http://localhost:8080/JAXRS-RESTEasy/ws/foobar/foobar

Output:

Once you hit the url in the browser, you are going to get the following output.

1	FooBar say : foobar

Source Code:

You can pull the code from GitHub.

RESTful Web Services

8:48:00 PM Posted by Satish CXF, GLASSFISH, J2EE, JAVA, JAX-RS, JERSEY, MAVEN, RESTEASY, SPRING, TOMCAT, TUTORIALS, WEB SERVICE No comments

REST (Representational State Transfer) is an architectural style which is based on web-standards and the HTTP protocol.

In a REST based architecture everything is a resource. A resource is accessed via a common interface based on the HTTP standard methods. In a REST based architecture you typically have a REST server which provides access to the resources and a REST client which accesses and modify the REST resources. Every resource should support the HTTP common operations. Resources are identified by global IDs. REST allows that resources have different representations, e.g. text, xml, json etc. The rest client can ask for specific representation via the HTTP protocol (content negotiation).

The PUT, GET, POST and DELETE methods are typical used in REST based architectures.

GET defines a reading access of the resource without side-effects. The resource is never changed via a GET request, e.g. the request has no side effects (idempotent).
PUT creates a new resource, must also be idempotent.
DELETE removes the resources. The operations are idempotent, they can get repeated without leading to different results.
POST updates an existing resource or creates a new resource.

RESTFul webservices are based on the HTTP methods and the concept of REST. A RESTFul webservice typically defines the base URI for the services, the supported MIME-types (XML, Text, JSON, user-defined) and the set of operations (POST, GET, PUT, DELETE) which are supported.

Java defines REST support via the Java Specification Request 311 (JSR). This specificiation is called JAX-RS (The Java API for RESTful Web Services). JAX-RS uses annotations to define the REST relevance of Java classes.

I suggest to read the following two article before start learing the REST (JAX-RS) web service. I wrote these articles keeping in mind atleast you get a over all idea of web service.

Before Learning Java Web Service

XML Parsing using Java

1. JAX-RS With GlassFish Jersey

2. JAX-RS With Jboss RESTEasy

3. JAX-RS With Apache CXF

4. Spring And Jersey

5. Spring and RESTEasy

6. Spring And CXF

7. RESTful Web Service with Spring 3.1

8. @Path - JAX-RS

9. @PathParam - JAX-RS

10. @RequestParam - JAX-RS

In this article I have not completed all the topics.. There are lot more techniques and tricks in RESTful web services. I was going through Spring 3.1.0 developer docs and it is pretty good from understanding point of view. So I would suggest you to refer Spring 3.1.0 or some other implementations of JAX-RS for a much better knowledge. I am short of time and next I will be working towards some modern technologies, so that I can get you some implementation for what I posted last week in my article Architecture of a Modern Web Application.

TECHIE KERNEL

A Technology Blog About Code Development, Architecture, Operating System, Hardware, Tips and Tutorials for Developers.

Thursday, December 13, 2012

Spring and RESTEasy

Sunday, December 9, 2012

JAX-RS With Jboss RESTEasy

Thursday, December 6, 2012

RESTful Web Services