[go: up one dir, main page]
Scribd
Upload
10 views10 pages

RestFul Web

This document provides a comprehensive guide on developing RESTful web services in Java using JAX-RS and Jersey. It covers key annotations, HTTP methods, and the configuration of Jersey within a web application, including code examples for creating a simple REST service. Additionally, it outlines the installation process and basic setup required to run the service on a servlet container like Tomcat.

Uploaded by

Paoli Bose
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
10 views10 pages

RestFul Web

This document provides a comprehensive guide on developing RESTful web services in Java using JAX-RS and Jersey. It covers key annotations, HTTP methods, and the configuration of Jersey within a web application, including code examples for creating a simple REST service. Additionally, it outlines the installation process and basic setup required to run the service on a servlet container like Tomcat.

Uploaded by

Paoli Bose
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 10

Rest ful Web Services

==========================
Annotation Description
@PATH(your_path) Sets the path to base URL + /your_path. The base URL is based on
your application name, the servlet and the URL pattern from
the web.xml configuration file.

@POST Indicates that the following method will answer to an HTTP POST request.
@GET Indicates that the following method will answer to an HTTP GET request.
@PUT Indicates that the following method will answer to an HTTP PUT request.
@DELETE Indicates that the following method will answer to an HTTP DELETE
request.
@Produces(MediaType.TEXT_PLAIN[, more-types])
@Produces defines which MIME type is delivered by a method annotated with @GET. In
the example text ("text/plain") is produced. Other examples would be
"application/xml" or "application/json".
@Consumes(type[, more-types])
@Consumes defines which MIME type is consumed by this method.
@PathParam Used to inject values from the URL into a method parameter. This way
you inject, for example, the ID of a resource into the method to get the correct
object.

1.3. RESTFul web services

A RESTFul web services are based on HTTP methods and the concept of REST. A RESTFul
web service 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.

JAX-RS supports the creation of XML and JSON via the Java Architecture for XML
Binding (JAXB

2. JAX-RS with Jersey

2.2. Jersey

Jersey is the reference implementation for the JSR 311 specification.

The Jersey implementation provides a library to implement Restful webservices in a


Java servlet container.

On the server side Jersey provides a servlet implementation which scans predefined
classes to identify RESTful resources. In your web.xml configuration file your
register this servlet for your web application.

The Jersey implementation also provides a client library to communicate with a


RESTful webservice.

The base URL of this servlet is:

http://your_domain:port/display-name/url-pattern/path_from_rest_class

SetUp:=

Download the Jersey distribution as zip file from the Jersey download site.
The zip contains the Jersey implementation JAR and its core dependencies. It does
not provide dependencies for third party JARs beyond those for JSON support and
JavaDoc.

Copy all JARs from your Jersey download into the WEB-INF/lib folder.

package com.vogella.jersey.first;

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

// Plain old Java Object it does not extend as class or implements


// an interface

// The class registers its methods for the HTTP GET request using the @GET
annotation.
// Using the @Produces annotation, it defines that it can deliver several MIME
types,
// text, XML and HTML.

// The browser requests per default the HTML MIME type.

//Sets the path to base URL + /hello


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

// This method is called if TEXT_PLAIN is request


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

// This method is called if XML is request


@GET
@Produces(MediaType.TEXT_XML)
public String sayXMLHello() {
return "<?xml version=\"1.0\"?>" + "<hello> Hello Jersey" + "</hello>";
}

// This method is called if HTML is request


@GET
@Produces(MediaType.TEXT_HTML)
public String sayHtmlHello() {
return "<html> " + "<title>" + "Hello Jersey" + "</title>"
+ "<body><h1>" + "Hello Jersey" + "</body></h1>" + "</html> ";
}

Web.xml
========
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>com.vogella.jersey.first</display-name>
<servlet>
<servlet-name>Jersey REST Service</servlet-name>
<servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
<!-- Register resources and providers under com.vogella.jersey.first package.
-->
<init-param>
<param-name>jersey.config.server.provider.packages</param-name>
<param-value>com.vogella.jersey.first</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Jersey REST Service</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>
</web-app>

====
You should be able to access your resources under the following URL:
http://localhost:8080/com.vogella.jersey.first/rest/hello

7. Create a REST client

TutorialsTrainingConsultingProductsBooksCompanyDonateContact us

Search
Search

NOW Hiring

QUICK LINKS

10 Oct - RCP Training


vogella Training
vogella Books
Follow me on twitter Follow me on Google+
REST with Java (JAX-RS) using Jersey - Tutorial

Lars Vogel

Version 2.5

Copyright � 2009-2015 vogella GmbH

15.12.2015

RESTful web services with Java (Jersey / JAX-RS)


This tutorial explains how to develop RESTful web services in Java with the JAX-RS
reference implementation Jersey.

In this tutorial Eclipse 4.5 (Mars), Java 1.8, Tomcat 6.0 and JAX-RS 2.0 (with
Jersey 2.11) is used.

Table of Contents

1. REST - Representational State Transfer


1.1. What is REST?
1.2. HTTP methods
1.3. RESTFul web services
2. JAX-RS with Jersey
2.1. JAX-RS
2.2. Jersey
2.3. JAX-RS annotations
3. Installation of Jersey
3.1. Manual setup of Jersey libraries in an Eclipse project
3.2. Required setup for Gradle with Eclipse web projects
4. Web container
5. Prerequisites
6. Create your first RESTful Webservice
6.1. Create a new web project
6.2. Configure jersey usage
6.3. Java Class
6.4. Define Jersey Servlet dispatcher
6.5. Run your rest service
7. Create a REST client
8. RESTful web services and JAXB
8.1. Create necessary classes
8.2. Configure jersey usage
8.3. Create project
8.4. Create a client
9. CRUD RESTful webservice
9.1. Project
9.2. Create a simple HTML form
9.3. Rest Service
9.4. Run
9.5. Create a client
9.6. Using the REST service via HTML page
10. About this website
11. Links and Literature
11.1. Rest Resources
11.2. vogella GmbH training and consulting support

1. REST - Representational State Transfer

1.1. What is REST?

REST is an architectural style which is based on web-standards and the HTTP


protocol. REST was first described by Roy Fielding in 2000. 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 modifies the REST resources.
Every resource should support the HTTP common operations. Resources are identified
by global IDs (which are typically URIs). REST allows that resources have different
representations, e.g., text, XML, JSON etc. The REST client can ask for a specific
representation via the HTTP protocol (content negotiation).

1.2. HTTP methods

The PUT, GET, POST and DELETE methods are typical used in REST based architectures.
The following table gives an explanation of these operations.

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. It 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.

1.3. RESTFul web services

A RESTFul web services are based on HTTP methods and the concept of REST. A RESTFul
web service 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.

2. JAX-RS with Jersey

2.1. JAX-RS

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

2.2. Jersey

Jersey is the reference implementation for the JSR 311 specification.

The Jersey implementation provides a library to implement Restful webservices in a


Java servlet container.

On the server side Jersey provides a servlet implementation which scans predefined
classes to identify RESTful resources. In your web.xml configuration file your
register this servlet for your web application.

The Jersey implementation also provides a client library to communicate with a


RESTful webservice.

The base URL of this servlet is:

http://your_domain:port/display-name/url-pattern/path_from_rest_class
This servlet analyzes the incoming HTTP request and selects the correct class and
method to respond to this request. This selection is based on annotations in the
class and methods.

A REST web application consists, therefore, out of data classes (resources) and
services. These two types are typically maintained in different packages as the
Jersey servlet will be instructed via the web.xml to scan certain packages for data
classes.

JAX-RS supports the creation of XML and JSON via the Java Architecture for XML
Binding (JAXB).

2.3. JAX-RS annotations

The most important annotations in JAX-RS are listed in the following table.

Table 1. JAX-RS annotations

Annotation Description
@PATH(your_path) Sets the path to base URL + /your_path. The base URL is based on
your application name, the servlet and the URL pattern from the web.xml
configuration file.
@POST Indicates that the following method will answer to an HTTP POST request.
@GET Indicates that the following method will answer to an HTTP GET request.
@PUT Indicates that the following method will answer to an HTTP PUT request.
@DELETE Indicates that the following method will answer to an HTTP DELETE
request.
@Produces(MediaType.TEXT_PLAIN[, more-types]) @Produces defines which MIME type
is delivered by a method annotated with @GET. In the example text ("text/plain") is
produced. Other examples would be "application/xml" or "application/json".
@Consumes(type[, more-types]) @Consumes defines which MIME type is consumed by this
method.
@PathParam Used to inject values from the URL into a method parameter. This way
you inject, for example, the ID of a resource into the method to get the correct
object.

The complete path to a resource is based on the base URL and the @PATh annotation
in your class.

http://your_domain:port/display-name/url-pattern/path_from_rest_class

3. Installation of Jersey

3.1. Manual setup of Jersey libraries in an Eclipse project

Download the Jersey distribution as zip file from the Jersey download site.

The zip contains the Jersey implementation JAR and its core dependencies. It does
not provide dependencies for third party JARs beyond those for JSON support and
JavaDoc.

Copy all JARs from your Jersey download into the WEB-INF/lib folder.

3.2. Required setup for Gradle with Eclipse web projects

TODO...

4. Web container

For this tutorial you can use any web container, for example Tomcat or the Google
App Engine.

If you want to use Tomcat as servlet container please see Eclipse WTP and Apache
Tomcat for instructions on how to install and use Eclipse WTP and Apache Tomcat.
Alternative you could also use the Google App Engine for running the server part of
the following REST examples. If you use the Google App Engine, you do not have to
install and configure Tomcat.

Tip If you are using GAE/J, you have to create App Engine projects instead of
Dynamic Web Project. The following description is based on Apache Tomcat.
5. Prerequisites

The following description assumes that you are familiar with creating web
applications in Eclipse. See Eclipse WTP development for an introduction into
creating web applications with Eclipse.

6. Create your first RESTful Webservice

6.1. Create a new web project

Create a new Dynamic Web Project called com.vogella.jersey.first.

Ensure that you create the web.xml deployment descriptor.

6.2. Configure jersey usage

See Section 3, �Installation of Jersey� for the setup.

6.3. Java Class

Create the following class.

package com.vogella.jersey.first;

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

// Plain old Java Object it does not extend as class or implements


// an interface

// The class registers its methods for the HTTP GET request using the @GET
annotation.
// Using the @Produces annotation, it defines that it can deliver several MIME
types,
// text, XML and HTML.

// The browser requests per default the HTML MIME type.

//Sets the path to base URL + /hello


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

// This method is called if TEXT_PLAIN is request


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

// This method is called if XML is request


@GET
@Produces(MediaType.TEXT_XML)
public String sayXMLHello() {
return "<?xml version=\"1.0\"?>" + "<hello> Hello Jersey" + "</hello>";
}

// This method is called if HTML is request


@GET
@Produces(MediaType.TEXT_HTML)
public String sayHtmlHello() {
return "<html> " + "<title>" + "Hello Jersey" + "</title>"
+ "<body><h1>" + "Hello Jersey" + "</body></h1>" + "</html> ";
}

}
This class register itself as a get resource via the @GET annotation. Via the
@Produces annotation it defines that it delivers the text and the HTML MIME types.
It also defines via the @Path annotation that its service is available under the
hello URL.

The browser will always request the HTML MIME type. To see the text version, you
can use tool like curl.

6.4. Define Jersey Servlet dispatcher

You need to register Jersey as the servlet dispatcher for REST requests. Open the
file web.xml and modify it to the following.

<?xml version="1.0" encoding="UTF-8"?>


<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>com.vogella.jersey.first</display-name>
<servlet>
<servlet-name>Jersey REST Service</servlet-name>
<servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
<!-- Register resources and providers under com.vogella.jersey.first package.
-->
<init-param>
<param-name>jersey.config.server.provider.packages</param-name>
<param-value>com.vogella.jersey.first</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Jersey REST Service</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>
</web-app>
The parameter jersey.config.server.provider.packages defines in which package
Jersey will look for the web service classes. This property must point to your
resources classes. The URL pattern defines the part of the base URL your
application will be placed.
6.5. Run your rest service

Run you web application in Eclipse. See Eclipse WTP for details on how to run
dynamic web applications.

You should be able to access your resources under the following URL:
http://localhost:8080/com.vogella.jersey.first/rest/hello

Result of the Jersey service


This name is derived from the "display-name" defined in the web.xml file, augmented
with the servlet-mapping URL-pattern and the hello @Path annotation from your class
file. You should get the message "Hello Jersey".

The browser requests the HTML representation of your resource. In the next chapter
we are going to write a client which will read the XML representation.

7. Create a REST client

Jersey contains a REST client library which can be used for testing or to build a
real client in Java. The usage of this library is demonstrated in the following
tutorial.

Create a new Java project com.vogella.jersey.first.client and add the Jersey JARs
to the project and the project build path. Create the following test class.

package com.vogella.jersey.first;

import java.net.URI;

import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriBuilder;

import org.glassfish.jersey.client.ClientConfig;

public class Test {

public static void main(String[] args) {


ClientConfig config = new ClientConfig();

Client client = ClientBuilder.newClient(config);

WebTarget target = client.target(getBaseURI());

String response = target.path("rest").


path("hello").
request().
accept(MediaType.TEXT_PLAIN).
get(Response.class)
.toString();

String plainAnswer =

target.path("rest").path("hello").request().accept(MediaType.TEXT_PLAIN).get(String
.class);
String xmlAnswer =

target.path("rest").path("hello").request().accept(MediaType.TEXT_XML).get(String.c
lass);
String htmlAnswer=

target.path("rest").path("hello").request().accept(MediaType.TEXT_HTML).get(String.
class);

System.out.println(response);
System.out.println(plainAnswer);
System.out.println(xmlAnswer);
System.out.println(htmlAnswer);
}

private static URI getBaseURI() {


return
UriBuilder.fromUri("http://localhost:8080/com.vogella.jersey.first").build();
}
}

No. SOAP REST


1) SOAP is a protocol. REST is an architectural style.
2) SOAP stands for Simple Object Access Protocol. REST stands for
REpresentational State Transfer.
3) SOAP can't use REST because it is a protocol. REST can use SOAP web
services because it is a concept and can use any protocol like HTTP, SOAP.
4) SOAP uses services interfaces to expose the business logic.REST uses URI to
expose business logic.
5) JAX-WS is the java API for SOAP web services. JAX-RS is the java API for
RESTful web services.
6) SOAP defines standards to be strictly followed. REST does not define too much
standards like SOAP.
7) SOAP requires more bandwidth and resource than REST. REST requires less
bandwidth and resource than SOAP.
8) SOAP defines its own security. RESTful web services inherits security
measures from the underlying transport.
9) SOAP permits XML data format only. REST permits different data format such
as Plain text, HTML, XML, JSON etc.
10) SOAP is less preferred than REST. REST more preferred than SOAP.

You might also like