Request/response middleware flow in Django - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is middleware in Django?

Middleware is a way to process requests and responses globally before they reach the view or after the view has processed them. It acts like a chain of functions that can modify or handle requests and responses.

intermediate

Describe the order in which Django middleware processes a request and a response.

When a request comes in, Django calls middleware in the order they are listed in settings. For the response, Django calls middleware in reverse order. This means the first middleware to process the request is the last to process the response.

advanced

What methods can a Django middleware class implement?

A middleware class can implement methods like <code>__init__</code>, <code>__call__</code>, <code>process_view</code>, <code>process_exception</code>, and <code>process_template_response</code>. The most common are <code>__call__</code> for request/response and <code>process_exception</code> for error handling.

beginner

How does middleware affect the flow of a Django request?

Middleware can modify the request before it reaches the view, stop the request by returning a response early, or modify the response after the view has processed the request. This lets middleware add features like authentication, logging, or caching.

intermediate

Why is the order of middleware important in Django?

Because middleware processes requests in order and responses in reverse order, the order controls how data flows and what changes happen first. For example, authentication middleware should run before middleware that needs user info.

In Django, when a request comes in, middleware is called in which order?

A In the order they are listed in settings

B In reverse order of listing

C Random order

D Alphabetical order

Django calls middleware in the order they appear in the settings for processing requests.

Which middleware method is commonly used to handle exceptions during request processing?

A __call__

B process_exception

C process_view

D process_template_response

The process_exception method is called when a view raises an exception.

What happens if a middleware returns a response during request processing?

A The request continues to the next middleware

B An error is raised

C The view is skipped and the response is sent back immediately

D The middleware is ignored

Returning a response from middleware stops further processing and sends that response back.

How does Django call middleware when processing a response?

A Middleware is not called for responses

B In the same order as the request

C Only the first middleware is called

D In reverse order of the request

Middleware processes responses in reverse order to the request processing.

Why should authentication middleware run early in the middleware chain?

A To ensure user info is available for later middleware

B It does not matter

C To speed up the server

D To log user actions first

Authentication middleware sets user info needed by other middleware.

Explain the flow of a request and response through Django middleware.

Think about how middleware acts like a chain wrapping the view.

Why is the order of middleware important and how does it affect request and response handling?

Consider middleware dependencies and data flow.

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