Skip to main content

REST Architecture and REST Constraints

What is REST?

This term “REST” was first defined by Roy Fielding in 2000. It stands for Representational State Transfer(REST). Actually REST is architectural model and design for serve network applications.The most common application of REST is the World Wide Web itself, which used REST as a basis for HTTP 1.1 development.

What is the REST API?

A RESTful API is an application program interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. Representational state transfer (REST), which is used by browsers, can be thought of as the language of the Internet.

REST architectural Model

  • REST-REpresentational State Transfer
  • Resource-based
  • Representation
  • Six Constraints
    • Client-Server
    • Stateless
    • Cacheable
    • Uniform Interface
    • Layered System
    • Code-On-Demand
The REST architectural style describes six constraints. These constraints, applied to the architecture, were originally communicated by Roy Fielding in his doctoral dissertation and defines the basis of RESTful-style.

Resource-based

REST is resource based API because RESTful API is as below points
  • Things vs Actions
  • Nouns vs Verbs
  • Identified by URIs
  • Multiple URIs may refers to same resource as like CRUD operation on student resource using HTTP verbs.
  • Separate from their representations-resource may represent as per as request content type either JSON or XML etc.

Representation

  • How resources get manipulated
  • Part of the resource state-transferred between client and server
  • Typically JSON or XML
For Example-
Resource– Author (Dinesh)
Service– Contact information about dinesh (GET)
Representation-name,mobile, address as JSON or XML format

REST Constraints

REST architecture style describe six constraints for REST APIs.

1. Uniform Interface

The uniform interface constraint defines the interface between clients and servers. It simplifies and decouples the architecture, which enables each part to evolve independently.
For us this means
  • HTTP Verbs (GET,POST,PUT,DELETE)
  • URIs (resource name)
  • HTTP response (status and body)
The four guiding principles of the uniform interface are:
1.1) Identifying the resource – Each resource must have a specific and cohesive URI to be made available, for example, to bring a particular user registered on the site:
HTTP/1.1 GET http://dineshonjava.com/user/dinesh
1.2) Resource representation – Is how the resource will return to the client. This representation can be in HTML, XML, JSON, TXT, and more. Example of how it would be a simple return of the above call:
{
"name": "Dinesh Rajput",
"job": "REST API Developer",
"hobbies": ["blogging", "coding", "music"]
}
1.3) Self-descriptive Messages – Each message includes enough information to describe how to process the message. Beyond what we have seen so far, the passage of meta information is needed (metadata) in the request and response. Some of this information are: HTTP response code, Host, Content-Type etc. Taking as an example the same URI as we have just seen:
GET /#!/user/dinesh HTTP/1.1
User-Agent: Chrome/37.0.2062.94
Accept: application/json
Host: dineshonjava.com
1.4) Hypermedia as the Engine of Application State (HATEOAS)– Clients deliver state via body contents, query-string parameters, request headers and the requested URI (the resource name). Services deliver state to clients via body content, response codes, and response headers. This part is often overlooked when talking about REST. It returns all the necessary information in response so client knows how to navigate and have access to all application resources.
Just one example:
Request:
HTTP/1.1 POST http://dineshonjava.com/dinesh/posts
Response:

{
"post": {
"id": 42,
"title": "concepts REST",
"decription": "a little about the concept of architecture of REST",
"_links": [
{
"href": "/dinesh/post/42",
"method": "GET",
"rel": "self"
},
{
"href": "/dinesh/post/42",
"method": "DELETE",
"rel": "remove"
},
{
"href": "/dinesh/post/42/comments",
"method": "GET",
"rel": "comments"
},
{
"href": "/dinesh/posts/42/comments",
"method": "POST",
"rel": "new_comment"
},
{...}
]
},
"_links": {
"href": "/post",
"method": "GET",
"rel": "list"
}
}

2. Stateless

One client can send multiple requests to the server; however, each of them must be independent, that is, every request must contain all the necessary information so that the server can understand it and process it accordingly. In this case, the server must not hold any information about the client state. Any information status must stay on client – such as sessions.

3. Cacheable

Because many clients access the same server, and often requesting the same resources, it is necessary that these responses might be cached, avoiding unnecessary processing and significantly increasing performance.

4. Client-Server

The uniform interface separates clients from servers. This separation of concerns means that, for example, clients are not concerned with data storage, which remains internal to each server, so that the portability of client code is improved. Servers are not concerned with the user interface or user state, so that servers can be simpler and more scalable. Servers and clients may also be replaced and developed independently, as long as the interface is not altered.

5. Layered System

A client cannot ordinarily tell whether it is connected directly to the end server, or to an intermediary along the way. Intermediary servers may improve system scalability by enabling load-balancing and by providing shared caches. Layers may also enforce security policies.

6. Code-On-Demand (Optional)

This condition allows the customer to run some code on demand, that is, extend part of server logic to the client, either through an applet or scripts. Thus, different customers may behave in specific ways even using exactly the same services provided by the server. As this item is not part of the architecture itself, it is considered optional. It can be used when performing some of the client-side service which is more efficient or faster.

Summary

We have looked into REST Architecture design and its six constraints about REST API. Here we notice if only optional constraint of REST architecture is code on demand. If a service violates any other constraint, it cannot strictly be referred to as RESTful.

Labels:

Comments

Post a Comment

Popular posts from this blog

Android Architecture Patterns Part 1: Model-View-Controller

A year ago, when the majority of the current Android team started working at upday, the application was far from being the robust, stable app that we wanted it to be. We tried to understand why our code was in such bad shape and we found two main culprits: continuous changing of the UI and the lack of an architecture that supported the flexibility that we needed. The app was already at its fourth redesign in six months. The design pattern chosen seemed to be Model-View-Controller but was then already a “mutant”, far from how it should be. Let’s discover together what the Model-View-Controller pattern is; how it has been applied in Android over the years; how it should be applied so it can maximize testability; and some of its advantages and disadvantages. The Model-View-Controller Pattern In a world where the user interface logic tends to change more often than the business logic, the desktop and Web developers needed a way of separating user interface functionality. The MV
Post a Comment
Read more

Need To Know About SQL's GROUP BY

A Brief Tutorial  Group by  is one of the most frequently used SQL clauses. It allows you to collapse a field into its distinct values. This clause is most often used with aggregations to show one value per grouped field or combination of fields. Consider the following table We can use a group by and aggregates to collect multiple types of information. For example, a group by can quickly tell us the number of countries on each continent.   How many countries are in each continent? select    continent   ,  count (*) from     countries group by     continent ‍ Keep in mind when using GROUP BY: Group by X means put all those with the same value for X in the same row. Group by X, Y put all those with the same values for both X and Y in the same row. ‍ ‍ More Interesting Things About GROUP BY 1. Aggregations Can Be Filtered Using The HAVING Clause ‍ You will quickly discover that the where clause cannot be used on an aggregation. For instance select    continent
Post a Comment
Read more