Spring Boot: Rest

Spring Boot Rest

Spring Boot Rest

📘 Rest

REST stands for Representational State Transfer. It is an architectural style for building web services that are designed to be lightweight, stateless, and easy to scale.

Spring Boot Request-Response Cycle

1 Overview

An API is a set of definitions and protocols for building and integrating application software.

It’s sometimes referred to as a contract between an information provider and an information user—establishing the content required from the consumer (the call) and the content required by the producer (the response).

For example, the API design for a weather service could specify that the user supply a zip code and that the producer reply with a 2-part answer, the first being the high temperature, and the second being the low temperature.

Rest

REST is a set of architectural constraints, not a protocol or a standard. API developers can implement REST in a variety of ways.

When a client request is made via a RESTful API, it transfers a representation of the state of the resource to the requester or endpoint.

This information, or representation, is delivered in one of several formats via HTTP: JSON (Javascript Object Notation), HTML, XLT, Python, PHP, or plain text.

JSON

JSON is the most generally popular file format to use because, despite its name, it’s language-agnostic, as well as readable by both humans and machines.

2 stateless

In REST (Representational State Transfer), a stateless system is one in which the server does not maintain any state or session information about the client between requests.

This means that each request from the client to the server is treated as an independent and complete operation, and the server responds with the appropriate data based solely on the information provided in the request.

In other words, the server does not keep track of any information about the previous requests made by the client. This is in contrast to stateful systems, where the server maintains information about the client’s session or context, and uses that information to provide a personalized response to each request.

stateless architecture

The stateless architecture of REST provides several benefits, such as improved scalability, simplicity, and reliability, as well as allowing requests to be processed in parallel by different servers or nodes.

However, it also means that the client needs to include all the necessary information in each request, and the server cannot assume any context or information beyond what is provided in the request.

3 HTTP messages

HTTP messages are how data is exchanged between a server and a client.

There are two types of messages:

• requests sent by the client to trigger an action on the server,
• and responses, the answer from the server.

HTTP messages are composed of textual information encoded in ASCII, and span over multiple lines.

In HTTP/1.1, and earlier versions of the protocol, these messages were openly sent across the connection. In HTTP/2, the once human-readable message is now divided up into HTTP frames, providing optimization and performance improvements.

HTTP message

HTTP requests, and responses, share similar structure and are composed of:

1. A start-line describing the requests to be implemented, or its status of whether successful or a failure. This start-line is always a single line.
2. An optional set of HTTP headers specifying the request, or describing the body included in the message.
3. A blank line indicating all meta-information for the request has been sent.
4. An optional body containing data associated with the request (like content of an HTML form), or the document associated with a response. The presence of the body and its size is specified by the start-line and HTTP headers.

4 HTTP status messages

• HTTP status messages

HTTP status messages poster

Source-status-code-poster by Steve Schoger

5 Spring Boot

In Spring Boot, the Spring MVC framework is used to build RESTful web services.

The @RestController annotation is used to define a class as a RESTful web service controller. This annotation is a combination of the @Controller and @ResponseBody annotations, which means that the class is a controller and the methods return the data directly rather than returning the name of a view.

The @RequestMapping annotation is used to map HTTP requests to specific methods in a controller class. This annotation can be used at the class level or the method level to define the path that the method should handle.

In addition to these annotations, Spring Boot also provides a number of other features that make it easy to build RESTful web services, such as support for JSON and XML serialization and deserialization, automatic content negotiation, and built-in exception handling.

Rest and Spring Boot

In summary, REST stands for Representational State Transfer.

In Spring Boot, the Spring MVC framework is used to build RESTful web services, the @RestController and @RequestMapping annotations are used to define a class as a RESTful web service controller and map HTTP requests to specific methods, respectively.

Spring Boot provides many features to make building RESTful web services easy, such as support for JSON and XML serialization and deserialization, automatic content negotiation, and built-in exception handling.

6 Using Annotations

In this table, we will explore some of the most commonly used annotations in Spring Boot. These annotations can be used to map HTTP requests to controller methods, extract data from the request, bind data to model attributes, and handle exceptions. Understanding these annotations is essential for building Spring Boot applications that are reliable, scalable, and maintainable.

Spring Boot Annotations

Annotation	Description
@Controller	Indicates that a class serves as a Spring Boot controller.
@RequestMapping	Maps HTTP requests to controller methods.
@GetMapping	Maps HTTP GET requests to controller methods.
@PostMapping	Maps HTTP POST requests to controller methods.
@PutMapping	Maps HTTP PUT requests to controller methods.
@DeleteMapping	Maps HTTP DELETE requests to controller methods.
@PathVariable	Extracts a variable from the URL path.
@RequestParam	Extracts a variable from the query string or request body.
@ModelAttribute	Binds a method parameter to a model attribute.
@SessionAttribute	Binds a method parameter to a session attribute.
@InitBinder	Initializes a web data binder for a specific controller method.
@ExceptionHandler	Handles exceptions thrown by a controller method.
@ResponseStatus	Sets the HTTP status code for a controller method.
@ResponseBody	Indicates that a controller method returns a response body instead of a view.
@ControllerAdvice	Provides global exception handling for controllers.

GET, POST, PUT, PATCH, and DELETE are HTTP methods that are used to perform CRUD (Create, Read, Update, and Delete) operations on resources in a RESTful API.

• GET: retrieves a representation of a resource from the server.
• POST: creates a new resource on the server.
• PUT: updates an existing resource on the server.
• PATCH: partially updates an existing resource on the server.
• DELETE: deletes a resource from the server.

7 API Rest clean style

When designing an API in a RESTful style, it’s important to follow some best practices to ensure that your API is easy to understand, maintain, and use.

Here are some guidelines for creating a clean RESTful API:

1. Use HTTP methods: GET, POST, PUT, PATCH, DELETE.
2. Use resource-oriented URLs with clear hierarchy, plurals, and nouns: domains
3. Use query parameters for filtering and pagination.
4. Use HTTP status codes to indicate request results.
5. Use consistent response formats, such as JSON: @ResponseEntity
6. Use versioning to handle API changes.
7. Provide clear documentation with examples and practices.

API Rest clean style

8 API Rest mindmap

API Rest roadmap-mindset

9 Example

@RestController
@RequestMapping("/api")
public class MyController {
    
    @GetMapping("/hello")
    public String hello() {
        return "Hello, world!";
    }
    
    @PostMapping("/data")
    public ResponseEntity<Void> postData(@RequestBody MyData data) {
        // Process the data...
        return ResponseEntity.ok().build();
    }
}

By defining controllers like this, you can create RESTful APIs and web applications that can handle a wide range of HTTP requests and responses.

The method then returns a ResponseEntity object with an HTTP status code of 200 (OK) and an empty response body.

In this example, the @RestController annotation indicates that this class is a controller, and the @RequestMapping("/api") annotation specifies that all routes in this controller should be prefixed with “/api”.

The hello() method is annotated with @GetMapping("/hello"), which means it will handle GET requests to the "/api/hello" endpoint and return the string “Hello, world!”.

The postData() method is annotated with @PostMapping("/data"), which means it will handle POST requests to the "/api/data" endpoint and accept a JSON payload in the request body, which will be automatically converted to a MyData object using Spring’s request body parsing functionality.