Async middleware in Django - Step-by-Step Execution

Concept Flow - Async middleware

Request received

↓

Async middleware called

↓

Await next middleware or view

↓

Response returned

↓

Async middleware post-processing

↓

Response sent to client

Async middleware in Django intercepts requests and responses asynchronously, awaiting the next step before continuing.

Execution Sample

Django

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

    async def __call__(self, request):
        print('Before view')
        response = await self.get_response(request)
        print('After view')
        return response

This async middleware prints messages before and after the view is awaited.

Execution Table

Step	Action	Awaited?	Output/State
1	Request received by middleware	No	Middleware starts processing
2	Print 'Before view'	No	Console: Before view
3	Await next middleware or view	Yes	Waiting for response
4	Response received from view	No	Response object ready
5	Print 'After view'	No	Console: After view
6	Return response to client	No	Response sent
7	End of middleware call	No	Middleware finished

💡 Middleware finishes after returning the awaited response.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
request	HttpRequest object	HttpRequest object	HttpRequest object	HttpRequest object
response	None	HttpResponse object	HttpResponse object	HttpResponse object

Key Moments - 2 Insights

Why do we use 'await' before calling the next middleware or view?

Because the next middleware or view is asynchronous, we must wait for its response before continuing, as shown in step 3 of the execution_table.

What happens if we forget to 'await' the next middleware or view?

The middleware would not wait for the response, causing errors or unexpected behavior since the response would be a coroutine, not the actual HttpResponse, as implied between steps 3 and 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is printed before awaiting the next middleware or view?

A 'Response sent'

B 'Before view'

C 'After view'

D Nothing is printed

💡 Hint

Check step 2 in the execution_table where the print happens before awaiting.

At which step does the middleware receive the actual response object?

A Step 2

B Step 3

C Step 4

D Step 6

💡 Hint

Look at step 4 in the execution_table where the response is received.

If the middleware did not await the next call, what would the 'response' variable hold after step 3?

A Coroutine object

B HttpRequest object

C HttpResponse object

D None

💡 Hint

Refer to variable_tracker and the explanation in key_moments about awaiting.

Concept Snapshot

Async middleware in Django:
- Defined as a class with async __call__ method
- Uses 'await' to call next middleware or view
- Can run code before and after awaiting
- Ensures non-blocking request handling
- Returns HttpResponse after async processing

Full Transcript

Async middleware in Django works by intercepting HTTP requests and responses asynchronously. When a request comes in, the middleware's async __call__ method runs. It can execute code before calling the next middleware or view. Using 'await', it waits for the next step to finish and get the response. After receiving the response, it can run more code before returning the response to the client. This allows Django to handle requests without blocking, improving performance. The key is to always await the next middleware or view to get the actual response object.