Request/response middleware flow in Django - Mini Project: Build & Apply

Understanding Request/Response Middleware Flow in Django

📖 Scenario: You are building a simple Django web application that logs messages during the request and response process using middleware. This helps understand how Django processes requests and responses step-by-step.

🎯 Goal: Create a custom middleware class that logs messages when a request is received and when a response is returned. This will demonstrate the flow of request and response through middleware in Django.

📋 What You'll Learn

Create a middleware class named SimpleLoggingMiddleware

Add an __init__ method that accepts get_response and stores it

Add a __call__ method that logs 'Request received' before calling get_response

Log 'Response returned' after getting the response

Return the response from the __call__ method

💡 Why This Matters

🌍 Real World

Middleware is used in Django projects to add functionality like logging, authentication, or modifying requests and responses globally.

💼 Career

Understanding middleware flow is essential for backend developers working with Django to customize request handling and implement cross-cutting concerns.

1

Create the middleware class with __init__

Create a class called SimpleLoggingMiddleware with an __init__ method that takes self and get_response as parameters. Inside __init__, assign get_response to self.get_response.

Django

class SimpleLoggingMiddleware:
    def __init__(self, get_response):
        # Your code here

Hint

The __init__ method stores the next callable in the middleware chain.

2

Add the __call__ method to log request reception

Add a __call__ method to SimpleLoggingMiddleware that takes self and request as parameters. Inside it, print the string 'Request received' before calling self.get_response(request).

Django

class SimpleLoggingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Your code here

Hint

The __call__ method handles the request and must return the response.

3

Log response return after calling next middleware

In the __call__ method, after calling self.get_response(request) and storing it in response, print the string 'Response returned' before returning response.

Django

class SimpleLoggingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        print('Request received')
        response = self.get_response(request)
        # Your code here
        return response

Hint

Print the message after getting the response but before returning it.

4

Complete middleware and add to Django settings

Ensure the SimpleLoggingMiddleware class is complete as shown. Then, add the string 'yourapp.middleware.SimpleLoggingMiddleware' to the MIDDLEWARE list in your Django settings.py file to activate it.

Django

class SimpleLoggingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        print('Request received')
        response = self.get_response(request)
        print('Response returned')
        return response

# Add 'yourapp.middleware.SimpleLoggingMiddleware' to MIDDLEWARE in settings.py

Hint

Adding the middleware string to MIDDLEWARE activates it in your Django project.

Practice

1. What is the main purpose of middleware in Django's request/response flow?

easy

A. To directly render HTML templates

B. To run code before and after the view processes a request

C. To manage database migrations

D. To handle user authentication only

Solution

1. Step 1: Understand middleware role

   Middleware runs code before and after views to modify requests or responses.

2. Step 2: Compare options

   Only To run code before and after the view processes a request describes this behavior; others describe unrelated tasks.

3. Final Answer:

   To run code before and after the view processes a request -> Option B

4. Quick Check:

   Middleware = pre/post view code [OK]

Hint: Middleware wraps views to add pre/post processing [OK]

Common Mistakes:

• Confusing middleware with template rendering
• Thinking middleware manages database directly
• Assuming middleware only handles authentication

2. Which of the following is the correct minimal structure of a Django middleware class?

easy

A. def my_middleware(get_response):
def middleware(request):
return get_response(request)
return middleware

B. class MyMiddleware:
def process_request(self, request):
pass

C. class MyMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
response = self.get_response(request)
return response

D. class MyMiddleware:
def handle(self, request):
return request

Solution

1. Step 1: Recall Django middleware class pattern

   Middleware must have __init__ with get_response and __call__ with request.

2. Step 2: Match options to pattern

   Only class MyMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): response = self.get_response(request) return response matches this exact structure; others miss __call__ or use wrong methods.

3. Final Answer:

   Class with __init__ and __call__ methods -> Option C

4. Quick Check:

   Middleware class = __init__ + __call__ [OK]

Hint: Middleware class needs __init__ and __call__ methods [OK]

Common Mistakes:

• Using process_request instead of __call__
• Defining middleware as a simple function without class
• Missing get_response parameter in __init__

3. Given this middleware code, what will be printed when a request is processed?

class LogMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
        print('Init called')
    def __call__(self, request):
        print('Before view')
        response = self.get_response(request)
        print('After view')
        return response

# Assume this middleware is active and a request comes in

medium

A. Init called\nBefore view\nAfter view

B. Before view\nAfter view\nInit called

C. After view\nBefore view\nInit called

D. Init called only

Solution

1. Step 1: Understand middleware instantiation

   __init__ runs once when server starts, printing 'Init called'.

2. Step 2: Trace __call__ during request

   On request, prints 'Before view', calls view, then prints 'After view'.

3. Final Answer:

   Init called\nBefore view\nAfter view -> Option A

4. Quick Check:

   Init once, then before/after view prints [OK]

Hint: Init prints once; __call__ prints before and after view [OK]

Common Mistakes:

• Thinking __init__ runs on every request
• Mixing order of prints
• Ignoring that __call__ wraps the view call

4. Identify the error in this middleware code snippet:

class ExampleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    def __call__(self, request):
        response = self.get_response
        return response

medium

A. Missing parentheses when calling get_response in __call__

B. Missing __init__ method

C. Using wrong method name instead of __call__

D. Returning request instead of response

Solution

1. Step 1: Check __call__ method

   It assigns response = self.get_response without calling it (missing parentheses).

2. Step 2: Understand consequence

   Without parentheses, response is a function, not a response object, causing errors.

3. Final Answer:

   Missing parentheses when calling get_response in __call__ -> Option A

4. Quick Check:

   Call get_response() with () [OK]

Hint: Always call get_response with parentheses in __call__ [OK]

Common Mistakes:

• Forgetting parentheses on function calls
• Confusing method names
• Returning request instead of response

5. You want to add a custom header 'X-Hello: World' to every response using middleware. Which code correctly implements this?

hard

A. class HeaderMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
response = self.get_response(request)
response.header['X-Hello'] = 'World'
return response

B. class HeaderMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
request['X-Hello'] = 'World'
response = self.get_response(request)
return response

C. class HeaderMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
response = self.get_response(request)
response.add_header('X-Hello', 'World')
return response

D. class HeaderMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
response = self.get_response(request)
response['X-Hello'] = 'World'
return response

Solution

1. Step 1: Recall how to add headers in Django response

   Response objects support dict-like access to headers: response['Header-Name'] = value.

2. Step 2: Check options for correct header addition

   class HeaderMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): response = self.get_response(request) response['X-Hello'] = 'World' return response uses response['X-Hello'] = 'World' correctly after calling get_response.

3. Final Answer:

   response['X-Hello'] = 'World' after getting the response -> Option D

4. Quick Check:

   Use response['Header'] = value to add headers [OK]

Hint: Add headers by setting response['Header'] = value after get_response [OK]

Common Mistakes:

• Trying to add headers to request object
• Using non-existent add_header method
• Accessing headers attribute which doesn't exist on response