Request/response middleware flow in Django - Step-by-Step Execution

Concept Flow - Request/response middleware flow

Incoming HTTP Request

↓

Middleware 1: process_request

↓

Middleware 2: process_request

↓

View Function Called

↓

Middleware N: process_response

↓

Middleware N-1: process_response

↓

Middleware 1: process_response

↓

HTTP Response Sent Back

The request passes through middleware in order before reaching the view, then the response passes back through middleware in reverse order before sending to client.

Execution Sample

Django

def middleware_1(get_response):
    def middleware(request):
        print('Middleware 1: before view')
        response = get_response(request)
        print('Middleware 1: after view')
        return response
    return middleware

This middleware prints messages before and after the view is called, showing request and response flow.

Execution Table

Step	Action	Middleware Layer	Message Printed	Flow Direction
1	Request enters	Middleware 1	Middleware 1: before view	Down (request)
2	Request passes	Middleware 2	Middleware 2: before view	Down (request)
3	Request reaches	View	View processes request	Down (request)
4	Response returns	Middleware 2	Middleware 2: after view	Up (response)
5	Response returns	Middleware 1	Middleware 1: after view	Up (response)
6	Response sent	Client	No message	End

💡 Response sent back to client after passing all middleware in reverse order

Variable Tracker

Variable	Start	After Middleware 1 Request	After Middleware 2 Request	After View	After Middleware 2 Response	After Middleware 1 Response	Final
request	Incoming HTTP request object	Passed to Middleware 1	Passed to Middleware 2	Received by View	Passed back Middleware 2	Passed back Middleware 1	Sent to client
response	None	None	None	View returns response	Middleware 2 modifies/forwards	Middleware 1 modifies/forwards	Final HTTP response

Key Moments - 2 Insights

Why does the response go through middleware in reverse order?

Because middleware wraps the view call like layers of an onion, the request goes in order, but the response comes back out in reverse order, as shown in execution_table steps 4 and 5.

What happens if a middleware returns a response before calling get_response?

The middleware short-circuits the flow and the view and later middleware are skipped. This is not shown in the table but is important to know.

Visual Quiz - 3 Questions

Look at the execution table, what message is printed at step 2?

A Middleware 1: after view

B Middleware 2: before view

C View processes request

D Middleware 2: after view

💡 Hint

Check the 'Message Printed' column for step 2 in the execution_table

At which step does the response start going back up through middleware?

A Step 4

B Step 3

C Step 1

D Step 6

💡 Hint

Look for 'Flow Direction' changing to 'Up (response)' in execution_table

If Middleware 1 returned a response immediately without calling get_response, what would change in the execution_table?

A Step 5 would be skipped

B Step 1 would be skipped

C Steps 2 and 3 would be skipped

D No steps would change

💡 Hint

Think about which middleware and view are bypassed if response is returned early

Concept Snapshot

Django middleware wraps request and response.
Request flows through middleware in order before view.
Response flows back through middleware in reverse order.
Middleware can modify request or response.
Middleware can short-circuit by returning response early.

Full Transcript

In Django, when a web request comes in, it passes through each middleware's request processing in order. Each middleware can inspect or change the request. After all middleware have processed the request, the view function runs to generate a response. Then the response goes back through the middleware in reverse order, allowing each middleware to modify the response before it is sent to the client. This flow is like layers wrapping around the view. Middleware can also stop the flow early by returning a response without calling the next layer. This trace shows the messages printed at each middleware step and how the request and response move through the layers.