REST API

API (Application Programming Interface) is a set of rules, protocols, and tools that allow different software applications or components to communicate with each other. APIs serve as an intermediary that allows different software systems to interact and leverage each other's functionalities. Imagine going to a restaurant for dinner. When you want to order food, you can't just walk into the kitchen and tell the chefs what you want. Instead, you talk to the waiter. The waiter checks if the food you want is available, takes your order to the kitchen, and brings your food to you. In this scenario, the waiter acts as an intermediary, just like an API.

Similarly, think about Zomato, an app that lets you track your food delivery on a map. Zomato doesn't directly access Google Maps data due to security reasons. Instead, it uses an API. When you want to see the map, Zomato asks the API to get the map data. The API talks to the system, gets the map, and then sends it back to Zomato. If everything goes well, the API sends back the map with a success message. If there's a problem, it sends an error message. So, APIs act as messengers between different systems, making things work smoothly.

Now, let's talk about what Rest API is.

A REST API, which stands for Representational State Transfer Application Programming Interface, sets a standard for building websites. It's essentially a set of best practices to maintain consistency. It lays out rules that, when followed, indicate that a server is built using REST API principles.

Rules of the REST API:

One of the primary rules of REST is the independence of the client and server. This means that the server and client should operate as separate entities without relying on each other too much. Typically, in a client-server architecture, the client sends requests, the server processes them, and then sends back responses. Clients can vary from web browsers to mobile devices or smart gadgets like Alexa. Responses can come in various forms, including images, text, HTML files, or JSON data.

However, there's an issue when a client, such as a mobile device or smart gadget, can't handle certain response types. For instance, sending an HTML file to a device that can't render it creates a dependency on the server. In line with REST API principles, the solution is for the server to send raw data like XML or JSON. The client can then interpret and display this data on its own, eliminating dependencies.

To simplify, if you're certain that your client will only be a web browser, sending an HTML file makes sense. In that case, there's no need to send raw data since browsers can handle HTML. However, for broader compatibility, following the REST API practice of sending raw data is advisable to ensure independence between the client and server.

The second rule of the REST API is to respect the HTTP methods. HTTP methods like GET, POST, PUT, PATCH, and DELETE have specific meanings and functions. It's important to adhere to these definitions and not modify or misuse them. For example, if you want to update data, it's best to use the PATCH method rather than trying to achieve the same result using POST. This practice ensures clarity and avoids confusion in how the API is used.

Key Points:

Statelessness: Statelessness is a fundamental principle in REST APIs. It means that each HTTP request from a client to the server must contain all the information needed to understand and process that request, and the server should not store any client-specific state between requests.

HTTP Status Codes: The API sends the response along with the status codes to represent the status of the response.

Some common status codes include:

• 200 OK: The request was successful.
• 201 Created: A new resource was successfully created.
• 204 No Content: The request was successful, but there is no response body.
• 400 Bad Request: The client sent an invalid request.
• 401 Unauthorized: Authentication is required to access the resource.
• 404 Not Found: The requested resource does not exist.
• 500 Internal Server Error: An error occurred on the server.

Headers: HTTP headers play a crucial role in REST API communication.

• Content-Type: Specifies the format of the data in the request or response (e.g., JSON, XML).
• Authorization: Used for authentication and authorization purposes, ensuring that only authorized users access certain resources.
• Accept: Informs the server about the preferred representation format for the response.
• Cache-Control: controls caching behavior, enabling efficient data retrieval and reducing server load.
• Versioning: Versioning is essential for evolving REST APIs while maintaining backward compatibility.
• URI Versioning: Including the version number in the URI (e.g., "/v1/resource") is a common versioning strategy. It allows clients to specify the version they want to use.
• Header Versioning: Versions can also be indicated using custom headers in the request, providing flexibility without modifying the URI.
• Compatibility: Versioning ensures that existing clients continue to function as the API evolves, preventing disruptions in service.Representation: In REST APIs, resources can have multiple representations (e.g., JSON, XML, HTML), and clients specify their preferred representation using the "Accept" header in the HTTP request.

If you come across any errors, please let me know. We all are in this together, so your feedback is like a compass guiding me. 🌟

Hope you'll like it.