We’ll leave the RESTful implementation for a later article. Our sample application is a micro-blogging web service (similar to Twitter), where users create accounts and then post entries.
Finally, while designing our application, we’ll define a set of steps that can be applied to designing any software system that needs to be deployed as a RESTful web service.
Designing a RESTful web service
Designing RESTful web services is not different from designing traditional web applications. We still have business requirements, we still have users who want to do things with data, and we still have hardware constraints and software architectures to deal with. The main difference, however, is that we look at the requirements to tease out resources and forget about specific actions to be taken on these resources.
We can think of RESTful web service design as being similar to Object Oriented Design (OOD). In OOD, we try to identify objects from the data we want to represent together with the actions that an object can have. But the similarities end at the data structure definition, because with RESTful web services we already have specific calls that are part of the protocol itself.
The underlying RESTful web service design principles can be summarized in the following four steps:
- Requirements gathering—this step is similar to traditional software requirement gathering practices.
- Resource identification—this step is similar to OOD where we identify objects, but we don’t worry about messaging between objects.
- Resource representation definition—because we exchange representation between clients and servers, we should define what kind of representation we need to use. Typically, we use XML, but JSON has gained popularity. That’s not to say that we can’t use any other form of resource representation—on the contrary, we could use XHTML or any other form of binary representation, though we let the requirements guide our choices.
- URI definition—with resources in place, we need to define the API, which consists of URIs for clients and servers to exchange resources’ representations.
This design process is not static. These are iterative steps that gravitate around resources. Let’s say that during the URI definition step we discover that one of the URI’s responses is not covered in one of the resources we have identified. Then we go back to define a suitable resource. In most cases, however, we find that the resources that we already have cover most of our needs, and we just have to combine existing resources into a meta-resource to take care of the new requirement.
Requirements of sample web service
The RESTful web service we design in this article is a social networking web application similar to Twitter.
We follow an OOD process mixed with an agile philosophy for designing and coding our applications. This means that we create just enough documentation to be useful, but not so much that we spend an inordinate amount of time deciphering it during our implementation phase.
As with any application, we begin by listing the main business requirements, for which we have the following use cases (these are the main functions of our application):
- A web user creates an account with a username and a password (creating an account means that the user is now registered).
- Registered users post blog entries to their accounts. We limit messages to 140 characters.
- Registered and non-registered users view all blog entries.
- Registered and non-registered users view user profiles.
- Registered users update their user profiles, for example, users update their password.
- Registered and non-registered users search for terms in all blog entries.
However simple this example may be, social networking sites work on these same principles: users sign up for accounts to post personal updates or information. Our intention here, though, is not to fully replicate Twitter or to fully create a social networking application. What we are trying to outline is a set of requirements that will test our understanding of RESTful web services design and implementation.
The core value of social networking sites lies in the ability to connect to multiple users who connect with us, and the value is derived from what the connections mean within the community, because of the tendency of users following people with similar interests. For example, the connections between users create targeted distribution networks.
The connections between users create random graphs in the graph theory sense, where nodes are users and edges are connections between users. This is what is referred to as the social graph.
Out of the use cases listed above, we now need to define the service’s resources. From reading the requirements we see that we need users and messages. Users appear in two ways: a single user and a list of users. Additionally, users have the ability to post blog entries in the form of messages of no more than 140 characters. This means that we need resources for a single message and a list of messages. In sum, we identify the following resources:
- List of users
- List of messages