Resource in Restful web services
In RESTful web services, a resource is an essential concept that represents any information or entity that can be manipulated by the client using standard HTTP methods (GET, POST, PUT, DELETE). Resources are identified by their URIs (Uniform Resource Identifiers), which clients use to interact with them. These URIs uniquely identify each resource and allow clients to perform operations on them.

Table of Contents
Key Characteristics of Resources:
- 1. Identification : Resources are identified by unique URIs, which serve as their address on the web.
- 2. Representation : Resources can have different representations, such as JSON, XML, or plain text, depending on the client’s requirements.
- 3. Statelessness : Each interaction with a resource is stateless, meaning that each request contains all the necessary information for the server to process it. There is no session state stored on the server between requests.
- 4. Manipulation : Clients interact with resources using standard HTTP methods:
- GET : Retrieve a representation of the resource.
- POST : Create a new resource.
- PUT : Update an existing resource.
- DELETE : Remove a resource.
Explanation in Java Example
To illustrate the concept of a resource in RESTful web services using Java, we’ll create a simple example of a Book resource that can be manipulated using HTTP methods.
xml
<dependencies>
<dependency>
<groupId>javax.ws.rs</groupId>
<artifactId>javax.ws.rs-api</artifactId>
<version>2.1.1</version>
</dependency>
<dependency>
<groupId>org.glassfish.jersey.containers</groupId>
<artifactId>jersey-container-servlet</artifactId>
<version>2.33</version>
</dependency>
<dependency>
<groupId>org.glassfish.jersey.inject</groupId>
<artifactId>jersey-hk2</artifactId>
<version>2.33</version>
</dependency>
</dependencies>
java
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.List;
@Path("/books")
public class BookResource {
private static List<Book> books = new ArrayList<>();
// GET all books
@GET
@Produces(MediaType.APPLICATION_JSON)
public List<Book> getAllBooks() {
return books;
}
// GET book by ID
@GET
@Path("/{id}")
@Produces(MediaType.APPLICATION_JSON)
public Response getBookById(@PathParam("id") int id) {
if (id >= 0 && id < books.size()) {
return Response.ok(books.get(id)).build();
} else {
return Response.status(Response.Status.NOT_FOUND).entity("Book not found").build();
}
}
// POST create a new book
@POST
@Consumes(MediaType.APPLICATION_JSON)
public Response createBook(Book book) {
books.add(book);
return Response.status(Response.Status.CREATED).build();
}
// PUT update an existing book
@PUT
@Path("/{id}")
@Consumes(MediaType.APPLICATION_JSON)
public Response updateBook(@PathParam("id") int id, Book book) {
if (id >= 0 && id < books.size()) {
books.set(id, book);
return Response.ok().build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
}
// DELETE delete a book by ID
@DELETE
@Path("/{id}")
public Response deleteBook(@PathParam("id") int id) {
if (id >= 0 && id < books.size()) {
books.remove(id);
return Response.ok().build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
}
}
java
public class Book {
private int id;
private String title;
private String author;
// Constructors, getters, and setters
}
java
import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;
@ApplicationPath("/api")
public class RestApplication extends Application {
// No need to implement any methods
}
xml
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
version="3.1">
<display-name>RestApp</display-name>
<servlet>
<servlet-name>Jersey Web Application</servlet-name>
<servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
<init-param>
<param-name>javax.ws.rs.Application</param-name>
<param-value>com.example.RestApplication</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Jersey Web Application</servlet-name>
<url-pattern>/api/*</url-pattern>
</servlet-mapping>
</web-app>
src
└── main
├── java
│ └── com
│ └── example
│ ├── Book.java
│ ├── BookResource.java
│ └── RestApplication.java
└── webapp
└── WEB-INF
└── web.xml
6. Run the Application
Deploy the project in a servlet container like Apache Tomcat. Once deployed, you can access the RESTful web service for books at http://localhost:8080/your-context-root/api/books.
You can test the service using tools like Postman or cURL:
- GET all books : Retrieve all books
GET http://localhost:8080/your-context-root/api/books
- GET book by ID : Retrieve a specific book by ID
GET http://localhost:8080/your-context-root/api/books/{id}
- POST create a new book : Create a new book
POST http://localhost:8080/your-context-root/api/books
Body: { “id”: 1, “title”: “Java Programming”, “author”: “John Doe” }
- PUT update an existing book : Update an existing book by ID
PUT http://localhost:8080/your-context-root/api/books/{id}
Body: { “id”: 1, “title”: “Updated Java Programming”, “author”: “Jane Doe” }
- DELETE delete a book by ID : Delete a book by ID
DELETE http://localhost:8080/your-context-root/api/books/{id}
Explanation
- Resource Class (BookResource.java) :
- Defines REST endpoints (/books) to handle CRUD operations on Book resources.
- Uses annotations (@Path, @GET, @POST, @PUT, @DELETE, @PathParam, @Consumes, @Produces) to specify URI paths, HTTP methods, and data formats (JSON in this case).
- Book Class (Book.java) :
- Represents the structure (fields) of the resource (Book).
- Application Config Class (RestApplication.java) :
- Sets up the application path (/api) for all RESTful resources.
- web.xml Configuration :
- Configures the Jersey servlet container to handle REST requests.