Hello world Rest Service project

Creating Hello world project with JAX-RS and Jersey


Tools and Technologies used

helloProject_tools_image

Step 1

Create a new maven Project in Eclipse

In Eclipse,Go to File => New => Other
Select Maven project

Name the project as “JerseyHelloWorld”

Select the archetype as maven-archetype-webapp and click on Next

Provide Group Id, Artifact Id and package details as below

jersy_project_create_maven_details_archytype

Click on Finish.

Step 2

Add the Jersey server dependency to pom.xml

Jersey server is one of the widely used implementation of JAX-RS and hence we will use Jersey implementation in this project.

for details on What is JAX-RS and Jersey, please go through JAX-RS article.

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
  4.     http://maven.apache.org/maven-v4_0_0.xsd">
  5.   <modelVersion>4.0.0</modelVersion>
  6.   <groupId>Jersy</groupId>
  7.   <artifactId>JersyHelloWorld</artifactId>
  8.   <packaging>war</packaging>
  9.   <version>0.0.1-SNAPSHOT</version>
  10.   <name>JersyHelloWorld Maven Webapp</name>
  11.   <url>http://maven.apache.org</url>
  12.   <dependencies>
  13.     <dependency>
  14.       <groupId>junit</groupId>
  15.       <artifactId>junit</artifactId>
  16.       <version>3.8.1</version>
  17.       <scope>test</scope>
  18.     </dependency>
  19.  
  20.    <dependency>
  21.     <groupId>org.glassfish.jersey.containers</groupId>
  22.     <artifactId>jersey-container-servlet</artifactId>
  23.     <version>2.24</version>
  24.    </dependency>
  25.  
  26. <!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
  27.    <dependency>
  28.     <groupId>javax.servlet</groupId>
  29.     <artifactId>servlet-api</artifactId>
  30.     <version>2.5</version>
  31.    </dependency>
  32.  
  33.  </dependencies>
  34.  
  35.  <build>
  36.     <finalName>JerseyHelloWorld</finalName>
  37.   </build>
  38. </project>
<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>Jersy</groupId>
  <artifactId>JersyHelloWorld</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>JersyHelloWorld Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

   <dependency>
    <groupId>org.glassfish.jersey.containers</groupId>
    <artifactId>jersey-container-servlet</artifactId>
    <version>2.24</version>
   </dependency>

<!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
   <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
   </dependency>

 </dependencies>
 
 <build>
    <finalName>JerseyHelloWorld</finalName>
  </build>
</project>

We have added dependencies for Jersey servlet ,servelt api and Junit in the above pom file.

Step 3

Update web.xml file with Jersey servlet container

we have defined a special servlet called “jersey-serlvet” in web.xml and mapped it by the URL pattern /rest/*

So just like any other servlet in web application,any request matching with the given pattern i.e /rest/* will be redirected to “Jersey servelt”.

  1. <!DOCTYPE web-app PUBLIC
  2.       "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
  3.       "http://java.sun.com/dtd/web-app_2_3.dtd" >
  4.  
  5. <web-app>
  6.     <display-name>Archetype Created Web Application</display-name>
  7.     <servlet>
  8.         <servlet-name>jersey-serlvet</servlet-name>
  9.          <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
  10.         <init-param>
  11.             <param-name>jersey.config.server.provider.packages</param-name>
  12.             <param-value>com.kb.rest</param-value>
  13.         </init-param>
  14.         <load-on-startup>1</load-on-startup>
  15.     </servlet>
  16.  
  17.     <servlet-mapping>
  18.         <servlet-name>jersey-serlvet</servlet-name>
  19.         <url-pattern>/rest/*</url-pattern>
  20.     </servlet-mapping>
  21.  
  22. </web-app>
<!DOCTYPE web-app PUBLIC
      "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
      "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
	<display-name>Archetype Created Web Application</display-name>
	<servlet>
		<servlet-name>jersey-serlvet</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.kb.rest</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<servlet-mapping>
		<servlet-name>jersey-serlvet</servlet-name>
		<url-pattern>/rest/*</url-pattern>
	</servlet-mapping>

</web-app>

We have also provided the package of java classes(to be qualified as Rest services) under init-param tag.

This package will be considered by Jersey servlet container to identify the actual service when the request comes in.

Step 4

Create the Hello world Rest service

  1. package com.kb.rest;
  2.  
  3. import javax.ws.rs.GET;
  4. import javax.ws.rs.Path;
  5. import javax.ws.rs.Produces;
  6. import javax.ws.rs.core.MediaType;
  7.  
  8. @Path("/hello")
  9. public class HelloWorldRestService {
  10.  
  11.     @GET
  12.     @Produces(MediaType.TEXT_PLAIN)
  13.     public String getMessage(){
  14.         return "Hello World";
  15.        
  16.     }
  17. }
package com.kb.rest;

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

@Path("/hello")
public class HelloWorldRestService {

	@GET
	@Produces(MediaType.TEXT_PLAIN)
	public String getMessage(){
		return "Hello World";
		
	}
}

@Path – to specify the root path of the resource which is “/hello”

@GET – It’s the HTTP method that is supported by the service

@Produces – It’s used to specify the MIME type that service is returning to client which is Plain Text here.

Note: We can see that the package of this class is “com.kb.rest” which is configured in web.xml

Step 5

Build the project

Right click on Project and select Run as Maven install and make sure that build is success.

jersy_project_build

Step 6

Deploy the project in the Tomcat server

Right click on server and select Add and Remove

add_remove_tomcat_server_project

Step 7

Start the server

Step 8

Access the Rest service using below URL

http://localhost:8080/JerseyHelloWorld/rest/hello

jersey_hello_world_output

http://localhost:8080/JerseyHelloWorld -> project context path

/rest -> URL pattern that can be handled by Jersey servlet as configured in web.xml

/hello -> The @Path resource mapping string which is pointing to HelloWorldRestService.java as defined in that class.

Download this project RestWithJerseyHelloWorld.zip

About the Author

Raj
Founder of javainsimpleway.com
I love Java and open source technologies and very much passionate about software development.
I like to share my knowledge with others especially on technology 🙂
I have given all the examples as simple as possible to understand for the beginners.
All the code posted on my blog is developed,compiled and tested in my development environment.
If you find any mistakes or bugs, Please drop an email to kb.knowledge.sharing@gmail.com

Connect with me on Facebook for more updates

Share this article on