Jump to content

REST

From Wikipedia, the free encyclopedia

This is an old revision of this page, as edited by 207.219.45.62 (talk) at 20:01, 5 September 2006 (→‎The World-Wide Web: removed bogus reference to "cut and paste"). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

"REST" redirects here; for other meanings of the word "rest", see rest.

Representational State Transfer (REST) is a software architectural style for distributed hypermedia systems like the world wide web. The term originated in a 2000 doctoral dissertation about the web written by Roy Fielding, one of the principal authors of the HTTP protocol specification, and has quickly passed into widespread use in the networking community.

REST strictly refers to a collection of architectural principles (described below). The term is also often used in a looser sense to describe any simple interface that uses XML (or YAML, JSON, plain text) over HTTP without an additional messaging layer such as SOAP. These two meanings can conflict as well as overlap. It is possible to design any large software system in accordance with Fielding's REST architectural style without using the HTTP protocol and without interacting with the world wide web. It is also possible to design simple XML+HTTP interfaces that do not conform to REST principles, and instead follow a RPC model. The two different uses of the term REST cause some confusion in technical discussions.

Systems that follow Fielding's REST principles are often referred to as RESTful; REST's most zealous advocates call themselves RESTafarians.

Principles

REST's proponents argue that the web has enjoyed the scalability and growth that it has as a result of a few key design principles:

  • Application state and functionality is divided into resources
  • Every resource is uniquely addressable using a universal syntax for use in hypermedia links
  • All resources share a uniform interface for the transfer of state between client and resource, consisting of
    • A constrained set of well-defined operations
    • A constrained set of content types, optionally supporting code-on-demand
  • A protocol that is:
    • Client/Server
    • Stateless
    • Cacheable
    • Layered

Claimed Benefits

REST advocates claim that REST:

  • Provides improved response times and server loading characteristics due to support for caching
  • Improves server scalability by reducing the need to maintain communication state. This means that different servers can handle initial and subsequent requests
  • Requires less client-side software to be written than other approaches, because a single browser can access any application and any resource
  • Depends on less vendor software than mechanisms that layer additional messaging frameworks on top of HTTP
  • Provides equivalent functionality when compared to alternative approaches to communication
  • Does not require a separate resource discovery mechanism, due to the use of hyperlinks in content
  • Provides better long-term compatibility and evolvability characteristics than RPC. This is due to:
    • The capability of document types such as HTML to evolve without breaking backwards- or forwards- compatibility, and
    • The ability of resources to add support for new content types as they are defined without dropping or reducing support for older content types.

REST detractors note the lack of tool support and the scarcity of truly RESTful applications deployed on the web of today. Some claim that REST is applicable to GET, but unproven for other state transfer operations such as PUT. POST is often considered the only necessary client-to-server state transfer operation, and is treated as a mechanism to tunnel arbitrary method invocations across HTTP.

The World-Wide Web

The Web is the key example of existing RESTful design. Much of it conforms or can be made to conform to REST principles. The Web consists of the HyperText Transfer Protocol (HTTP), content types including the HyperText Markup Language (HTML), and other Internet technologies such as the Domain Name Servce (DNS).

HTML can include javascript and applets to support code-on-demand, and has implicit support for hyperlinks.


HTTP's uniform interface to access to resources consists of URIs, methods, status codes, headers, and content distingished by mime type.

The most important HTTP methods are POST, GET, PUT and DELETE. These are often compared with the CRUD operations associated with data persistence.

HTTP separates the notions of a web server and a web browser. This allows the implementation of each to vary from the other based on the client/server principle. When used RESTfully, HTTP is Stateless. Each message contains all the information necessary to understand the request when combined with state at the resource. As a result, neither the client nor the server needs to remember any communication-state between messages. Any state retained by the server must be modelled as a resource. The statelessness constraint can be violated in HTTP using cookies to maintain sessions.

HTTP provides mechanisms to control caching, and permits a conversation between web browser and web cache to occur using the same mechanisms as between web browser and web server. No layer can "see" beyond the conversation it is immediately involved with.

Resources

An important concept in REST is the existence of resources (sources of specific information), each of which can be referred to using a global identifier (an URI). In order to manipulate these resources, components of the network (clients and servers) communicate via a standardized interface (e.g. HTTP) and exchange representations of these resources (the actual documents conveying the information). For example, a resource that is a circle may accept and return a representation that specifies a centre point and radius, formatted in SVG, but may also accept and return a representation that specifies any three distinct points along the curve as a comma-separated list.

Any number of connectors (e.g., clients, servers, caches, tunnels, etc.) can mediate the request, but each does so without "seeing past" its own request (referred to as "layering", another constraint of REST and a common principle in many other parts of information and networking architecture). Thus an application can interact with a resource by knowing two things: the identifier of the resource, and the action required – it does not need to know whether there are caches, proxies, gateways, firewalls, tunnels, or anything else between it and the server actually holding the information. The application does, however, need to understand the format of the information (representation) returned, which is typically an HTML or XML document of some kind, although it may be an image or any other content.

REST versus RPC

The REST Triangle
The REST Triangle

A REST web application requires a different design approach than an RPC (Remote procedure call) application. An RPC application is exposed as one or more network objects, each with an often unique set of functions that can be invoked. Before a client communicates with the application it must have knowledge of the object identity in order to locate it and must also have knowledge of the object type in order to communicate with it.

REST design constrains the aspects of a resource that define its interface (the verbs and content types). This leads to the definition of fewer types on the network than an RPC-based application but more resource identifiers (nouns). REST design seeks to define a set of resources that clients can interact with uniformly, and to provide hyperlinks between resources that clients can navigate without requiring knowledge of the whole resource set. Server-provided forms can also be used in a RESTful environment to describe how clients should construct a URL in order to navigate to a particular resource.

Example

An RPC application might define operations such as the following: 

getUser()
addUser()
removeUser()
updateUser()
getLocation()
addLocation()
removeLocation()
updateLocation()
listUsers()
listLocations()
findLocation()
findUser()

Client code to access this application may look something like this: 

exampleAppObject = new ExampleApp("example.com:1234")
exampleAppObject.getUser()

With REST, on the other hand, the emphasis is on the diversity of resources, or nouns; for example, a REST application might define the following resources 

http://example.com/users/
http://example.com/users/{user} (one for each user)
http://example.com/findUserForm
http://example.com/locations/
http://example.com/locations/{location} (one for each location)
http://example.com/findLocationForm

Client code to access this application may look something like this: 

userResource = new Resource("http://example.com/users/001")
userResource.get()

Each resource has its own identifier noun. Clients start at a single resource such as the user resource that represents themselves, and navigate to location resources and other user resources. Clients work with each resource through standard operations, such as GET to download a copy of the resource's representation, PUT to paste a changed copy over the top of the original, or DELETE to remove the data or state associated with the resource. POST is sometimes used interchangeably with PUT, but can also be seen as a "paste after" rather than a "paste over" request. POST is generally used for actions with side-effects, such as requesting the creation of a purchase order, or adding some data to a collection. Note how each object has its own URL and can easily be cached, copied, and bookmarked.

Uniform Interfaces in REST and RPC

The uniform interface allows clients to access data from a range of resources without special code to deal with each one, so long as it is actually uniform. The content returned from a user resource could be the globally standard and RESTful HTML, a less RESTful industry standard representation such as UserML, or an unRESTful application-specific data format. Which content is returned can be negotiated at request time. The content could even be a combination of these representations: HTML can be marked up with Microformats that have general or industry-specific appeal, and these microformats can be extended with application-specific information.

Uniform interfaces reduce the cost of client software by ensuring it is only written once, rather than once per application it has to deal with. Both REST and RPC designs may try to maximise the uniformity of the interface they expose by conforming to industry or global standards. In the RPC model these standards are primarily in the form of standard type definitions and standard choreography. In REST it is primarily the choice of standard content types and verbs that controls uniformity.

Public implementations

Since REST is defined very broadly, it is possible to claim an enormous number of RESTful applications on the Web (just about everything accessible through an HTTP GET request or updateable through HTTP POST). Taken more narrowly, in its sense as an alternative to both Web Services generally and the RPC style specifically, REST can be found in many places on the public Web:

There are also examples of interfaces that label themselves 'REST', but are, in fact, using HTTP to tunnel function calls - also known as 'POX/HTTP', or Plain Old XML over HTTP:

These interfaces, and the many others like them, do not intentionally respect REST's architectural constraints. Some have been called Accidentally RESTful, by a REST expert. This requires a very narrow view of RESTfulness. The accident of RESTfulness applies in the few cases where: single GETs are appropriate - when it's not appropriate to navigate through many GETs in hypermedia style; those GETs retrieve data - not change data; cacheing isn't needed; and user-specific ids don't appear in the URL - or 'RESTful' is to be considered in the context of a single user. Finally, as an 'accident', it's a very fragile form of 'RESTful'.

Outside of the Web

Just as much of the web can be seen as RESTful or nearly-RESTful, a number of existing protocols and architectures have RESTful characteristics. Wherever you see a piece of software that interacts with a number of different kinds of objects or devices you are seeing a uniform interface at work. Many of these uniform interfaces follow document-oriented REST patterns rather than object-oriented patterns:

  • Modbus is a protocol that allows memory ranges within PLCs to be addressed. Ranges can be written and read effectively as PUT and GET operations.
  • Java Beans and other systems that perform property-based editing follow the PUT and GET model of the REST architectural style. Rather than write object-specific editor code, the code is written once and can interact with various object types. Resources in this model are a combination of object identifier and property name.
  • Document-oriented SOA has several RESTful characteristics

See also

External links

Retrieved from "https://en.wikipedia.org/w/index.php?title=REST&oldid=74006574"