Restful web services with java

REST
● REST stands for Representational State Transfer
-Design pattern for developing web services.
● Resource based
● Rest Style:
● Client-server
● Uniform interface
● Stateless
● Cached
● Layered system
● HATEOAS - (Hypermedia As The Engine Of Application State)

REST - not a Standard
● But it uses several standards:
o HTTP
o URL
o XML/HTML/GIF/JPEG/etc (Resource Representations)
o text/xml, text/html, image/gif, image/jpeg, etc (Resource Types, MIME Types)
Browser Web ServerGET /index.html HTTP/1.1
Host: www.pitt.edu
HTTP/1.1 200 OK
Content-Type:
text/html

HTTP Request
• The HTTP request is sent from the client.
– Identifies the location of a resource.
– Uses nouns rather than verbs to denote simple resources.
– Specifies the verb, or HTTP method to use when accessing the resource.
– Supplies optional request headers (name-value pairs) that provide additional
information the server may need when processing the request.
– Supplies an optional request body that identifies additional data to be
uploaded to the server (e.g. form parameters, attachments, etc.)

Sample Client Requests:
GET /view?id=1 HTTP/1.1 Request Headers
User-Agent: Chrome
Accept: application/json Requested Resource (path and query
string)
(no request body)
POST /save HTTP/1.1 Requested Resource (typically no query string)
User-Agent: IE
Content-Type: application/x-www-form-urlencoded Request Headers
name=x&id=2 Request Body (e.g. form parameters)

HTTP Response
• The HTTP response is sent from the server.
– Gives the status of the processed request.
– Supplies response headers (name-value pairs) that provide additional
information about the response.
– Supplies an optional response body that identifies additional data to be
downloaded to the client (html, xml, binary data, etc.)
– -HTTP Status codes(1xx, 2xx, 3xx, 4xx, 5xx)

Sample Server Responses:
HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 1337
[CRLF]
<html>

</html>
HTTP/1.1 500 Internal Server Error
HTTP/1.1 201 Created
Location: /view/7
[CRLF]
Some message goes here.
Response Status
Response Headers
Response Body (content)
Response Status
Response Header
Response Body
Response Status

Standard Set of Methods
● GET - read data and not change it.
● PUT - update capabilities
● POST - create subordinate resources
● DELETE - delete a resource
● OPTIONS - ‘What methods are allowed’
● HEAD - HTTP header

A typical HTTP REST URL:
http://my.store.com/fruits/list?category=fruit&limit=20
• The protocol identifies the transport scheme that will be used to
process and respond to the request.
• The host name identifies the server address of the resource.
• The path and query string can be used to identify and customize
the accessed resource.
protocol host name path to a resource query string

RESTful Application Cycle
Resources are identified by URIs
Clients communicate with resources via
requests using a standard set of methods
Requests and responses contain resource
representations in formats identified by
media types.
Responses contain URIs that link to further
resources

Examples of Rest URIs
Insert new customer in a system POST
http://www.example.com/customers/1234
5
Read a customer with customer
ID
GET
5
Read all orders with customer ID GET
5/orders

JAX-RS is a Java standard API for REST services:
• Services are annotation driven
• Provides support for data binding.(JAX-B)
• Provides advanced APIs for content negotiation.(@Produces/@Consumes)

SOAP vs. REST: Overview
Both SOAP and REST are front-end technologies.
SOAP – Simple Object Access Protocol
 Supports a variety of transports (HTTP, JMS, etc.) and integrates with a variety of web service standards.
 Typically used to pass contractually structured data between applications.
 Bound to xml.
 Uses SOAP envelope and then HTTP (or FTP/SMTP) to transfer the data.
 Slower performance and scalability is a bit complex. Caching not possible.

REST - Representational State Transfer
 Architectural style
 Simple point-to-point communication using well-established HTTP verbs, protocols, and standards.
 Supports many different data formats like JSON, XML etc.
 Performance and scalability, caching.
 Lightweight, easy to consume.
 Widely and frequently used.
SOAP vs. REST: Overview

 - XML-based protocol
 - How to access the service and what operations are performed
 Broadly consists of:
 - Types
 - Operation
 - Binding
WSDL- Webservices Description Language

Connection point
Client-server response
Client-server request
WSDL Example

Name of the service
Parameter of the ws
Request-response operation
targetNamespace, default and
other namespaces

WSDL Example- contd.
 Define binding
transport
Endpoint URI
Connect port
and binding

Restful Webservices
● A RESTful Web service follows four basic design principles:
o Uses HTTP methods
o Be stateless as far as possible
o Expose directory/folder structure-like URI
o Transfer XML, JSON, or both

Java API for RESTful Web Services (JAX-RS)
vs Spring MVC
Some Guidelines for choosing your solution:
• Both JAX-RS and Spring MVC can produce REST services.
• Spring MVC is a web application framework that can be used as service framework.
– Provides better validation
– Supports internationalization
• JAX-RS is a primarily a services framework.
– Provides support for WADL generation
– Can use CXF interceptors, filters, etc.
• Match the framework to the needs and purpose of the project.
• Don’t mix both in same web application unless you need unique features from each.
– If your project needs both, consider separate web applications.

Spring mvc architecture
● Spring web MVC framework

RESTful support in Spring
● Controllers can handle requests for all HTTP methods, including the four primary REST methods: GET,
PUT, DELETE, and POST.
● The @PathVariable annotation enables controllers to handle requests for parameterized URLs (URLs
that have variable input as part of their path).
● Resources can be represented in a variety of ways using Spring views and view resolvers, including
View implementations for rendering model data as XML, JSON, Atom, and RSS.
The representation best suited for the client can be chosen using ContentNegotiatingViewResolver.
● View-based rendering can be bypassed altogether using the @ResponseBody annotation and various
HttpMethodConverter implementations.
● Similarly, the @RequestBody annotation, along with HttpMethodConverter implementations, can
convert inbound HTTP data into Java objects passed in to a controller’s handler methods.
● Spring applications can consume REST resources using RestTemplate

Web.xml configuration
<servlet>
<servlet-name>AccountService</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>app</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>

Content Negotiation using views

Next topics
- Securing Restful Services
- Open source frameworks JERSEY, RESTEASY

References
- Restful Webservice: Leonrard Richardson and Sam
Ruby//O’Reilly
- RESTful Web Services Cookbook: Subbu Allamraju//O’Reilly
- Roy Fieldings dissertation -
http://www.ics.uci.edu/~fielding/pubs/dissertation/top.htm
- Spring in Action, 4th Edition, Craig Walls//Manning

Restful web services with java

More Related Content

What's hot (20)

Similar to Restful web services with java (20)

Recently uploaded (20)

Restful web services with java

Editor's Notes