Lära RESTful Principles and Design | Foundations of API Design

Before you design a RESTful API, you need to understand the constraints that define the REST architectural style. REST, or Representational State Transfer, is not a protocol but a set of guiding principles for building scalable web services. There are several key constraints:

Statelessness: every request from a client to a server must contain all the information needed to understand and process the request. The server does not store anything about the client session between requests;
Client-server separation: the client and server are independent. The client handles the user interface and user experience, while the server manages and processes resources;
Cacheability: responses must define themselves as cacheable or not, so clients can reuse responses for identical requests, improving efficiency and scalability;
Uniform interface: a standardized way to interact with resources, usually through HTTP methods (GET, POST, PUT, DELETE), resource URIs, and consistent data formats.

Adhering to these constraints ensures that your API is scalable, maintainable, and reliable.


              123456789101112131415161718192021222324252627282930313233343536373839
            
# Simulating a RESTful resource representation and HTTP-like methods

# Define a resource as a dictionary
user_resource = {
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com"
}

# Simulate HTTP-like GET method
def get_user():
    return user_resource

# Simulate HTTP-like POST method (create new user)
def post_user(new_user):
    global user_resource
    user_resource = new_user
    return "201 Created"

# Simulate HTTP-like PUT method (update user)
def put_user(updated_user):
    global user_resource
    user_resource.update(updated_user)
    return "200 OK"

# Simulate HTTP-like DELETE method (delete user)
def delete_user():
    global user_resource
    user_resource = {}
    return "204 No Content"

# Example usage
print("GET:", get_user())
print("POST:", post_user({"id": 2, "name": "Bob", "email": "bob@example.com"}))
print("GET after POST:", get_user())
print("PUT:", put_user({"email": "bob123@example.com"}))
print("GET after PUT:", get_user())
print("DELETE:", delete_user())
print("GET after DELETE:", get_user())

When you design an API, you model resources as entities that can be created, read, updated, or deleted. Each resource typically corresponds to a real-world object or concept, such as a user, product, or order. In RESTful APIs, you use HTTP methods to perform operations on these resources, mapping them to CRUD actions:

Create: use the POST method to add a new resource;
Read: use the GET method to retrieve resource representations;
Update: use the PUT method to modify an existing resource;
Delete: use the DELETE method to remove a resource.

This mapping creates a predictable and consistent interface, making your API intuitive for clients to use. The resource is usually identified by a URI, and the HTTP method determines the operation performed.


              1234567891011121314151617181920212223242526272829303132333435363738394041
            
# Simulating CRUD operations with HTTP methods on a resource

# Resource store (simulating a database)
users = [
    {"id": 1, "name": "Alice", "email": "alice@example.com"}
]

# GET: Read user by id
def get_user_by_id(user_id):
    for user in users:
        if user["id"] == user_id:
            return user
    return "404 Not Found"

# POST: Create new user
def create_user(new_user):
    users.append(new_user)
    return "201 Created"

# PUT: Update user by id
def update_user(user_id, updated_fields):
    for user in users:
        if user["id"] == user_id:
            user.update(updated_fields)
            return "200 OK"
    return "404 Not Found"

# DELETE: Remove user by id
def delete_user_by_id(user_id):
    global users
    users = [user for user in users if user["id"] != user_id]
    return "204 No Content"

# Demonstration
print("GET:", get_user_by_id(1))
print("POST:", create_user({"id": 2, "name": "Bob", "email": "bob@example.com"}))
print("GET all:", users)
print("PUT:", update_user(2, {"email": "bob123@example.com"}))
print("GET updated:", get_user_by_id(2))
print("DELETE:", delete_user_by_id(1))
print("GET all after delete:", users)

1. Which of the following is NOT a constraint of the REST architectural style?

2. Which HTTP method is typically used to update an existing resource in a RESTful API?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 1. Kapitel 2

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Svep för att visa menyn

Statelessness: every request from a client to a server must contain all the information needed to understand and process the request. The server does not store anything about the client session between requests;
Client-server separation: the client and server are independent. The client handles the user interface and user experience, while the server manages and processes resources;
Cacheability: responses must define themselves as cacheable or not, so clients can reuse responses for identical requests, improving efficiency and scalability;
Uniform interface: a standardized way to interact with resources, usually through HTTP methods (GET, POST, PUT, DELETE), resource URIs, and consistent data formats.