Creating custom middleware in Django - Visual Walkthrough

Concept Flow - Creating custom middleware

Request comes in

↓

Middleware __call__ or process_request

↓

View function executes

↓

Middleware process_response

↓

Response sent back to client

Middleware intercepts requests before views and responses after views, allowing custom processing.

Execution Sample

Django

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

This middleware prints messages before and after the view runs for each request.

Execution Table

Step	Action	Evaluation	Result
1	Request received by middleware __call__	Print 'Before view'	Message logged: Before view
2	Call get_response(request) to run view	View processes request	View returns HttpResponse
3	After view returns	Print 'After view'	Message logged: After view
4	Return response to client	Response sent	Client receives HttpResponse
5	End of middleware processing	No further action	Request cycle complete

💡 Response returned to client after middleware and view processing

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
request	HttpRequest object	Same HttpRequest	Same HttpRequest	Same HttpRequest	Same HttpRequest
response	None	None	HttpResponse from view	HttpResponse from view	HttpResponse from view

Key Moments - 2 Insights

Why do we call self.get_response(request) inside __call__?

Calling self.get_response(request) runs the next middleware or the view. Without it, the request would stop and no response would be generated. See execution_table step 2.

What happens if we modify the response after calling get_response?

You can change the response before returning it to the client. This happens after the view runs, as shown in execution_table step 3.

Visual Quiz - 3 Questions

Look at the execution table, what is printed before the view runs?

A 'Request received'

B 'After view'

C 'Before view'

D 'Response sent'

💡 Hint

Check step 1 in the execution_table where the first print happens.

At which step does the view function execute?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the action in step 2 where get_response(request) is called.

If we remove the call to self.get_response(request), what happens?

A The middleware prints both messages

B No response is returned to the client

C The view still runs normally

D The response is sent twice

💡 Hint

Refer to key_moments about why get_response(request) is necessary.

Concept Snapshot

Creating custom middleware in Django:
- Define a class with __init__(get_response) and __call__(request)
- __call__ runs code before and after calling get_response(request)
- get_response(request) calls the next middleware or view
- Modify request before or response after view
- Return the final response to complete the cycle

Full Transcript

In Django, custom middleware is a class that intercepts requests and responses. When a request comes in, the middleware's __call__ method runs. It can do something before the view by running code before calling get_response(request). Then it calls get_response(request) to run the view or next middleware. After the view returns a response, the middleware can modify or log after the view. Finally, it returns the response to the client. This lets you add custom behavior around every request and response cycle.