Django లో request lifecycle ఎలా పనిచేస్తుంది?

Question

IT Interview Practice · Accepted Answer

Django లో, ఒక request **WSGI/ASGI handler** ద్వారా నిర్వహించబడుతుంది, **middleware** స్టాక్‌తో చుట్టబడుతుంది, **URL resolver** ద్వారా ఒక **view** కు రూట్ చేయబడుతుంది, మరియు అదే middleware గుండా రివర్స్ క్రమంలో తిరిగి బయటికి ప్రవహించే `HttpResponse` గా మార్చబడుతుంది.

## దశలు

```
Web server ──▶ WSGI/ASGI handler  (HttpRequest సృష్టిస్తుంది)
   ▼
Middleware — request దశ        (పైన → కింద: get_response కు ముందు __call__)
   ▼
URL resolver (urls.py)  ── path సరిపోల్చు → view + kwargs
   ▼
Middleware — process_view hook
   ▼
View (function / class-based)  ── మీ logic, HttpResponse ను తిరిగి ఇస్తుంది
   ▼
Middleware — response దశ        (కింద → పైన: get_response తర్వాత)
   ▼
HttpResponse ──▶ client
```

1. **Handler** — WSGI (sync) లేదా ASGI (async) handler environ/scope నుండి ఒక `HttpRequest` ను నిర్మిస్తుంది.
2. **Middleware, request దశ** — ప్రతి middleware యొక్క code *`get_response()` కు ముందు* పై నుండి కింద వరకు నడుస్తుంది (`SecurityMiddleware`, `SessionMiddleware`, `AuthenticationMiddleware`, CSRF, …). వాటిలో ఏదైనా ముందుగానే ఆపి ఒక response ను తిరిగి ఇవ్వవచ్చు.
3. **URL resolution** — `ROOT_URLCONF` pattern లు ఒక view ను ఎంచుకోవడానికి మరియు kwargs ను పట్టుకోవడానికి path తో సరిపోల్చబడతాయి.
4. **`process_view`** — view పిలవబడటానికి కొంచెం ముందు నడిచే ఒక middleware hook.
5. **View** — మీ function- లేదా class-based view నడుస్తుంది, సాధారణంగా model లను query చేసి ఒక template ను render చేస్తుంది, మరియు ఒక `HttpResponse` ను తిరిగి ఇస్తుంది. మినహాయింపులు `process_exception` ను ట్రిగ్గర్ చేస్తాయి.
6. **Middleware, response దశ** — code *`get_response()` తర్వాత* కింద నుండి పైకి నడుస్తుంది, బయటికి వెళ్లే response ను (headers, compression) మార్చడానికి middleware ను అనుమతిస్తుంది.
7. `HttpResponse` server మరియు client కు తిరిగి stream చేయబడుతుంది.

```python
# middleware.py
class TimingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

def __call__(self, request):          # 2. request దశ (ముందు)
        request.started = time.monotonic()
        response = self.get_response(request)  # తదుపరి layer / view ను పిలుస్తుంది
        response["X-Time"] = "..."         # 6. response దశ (తర్వాత)
        return response

# urls.py  → 3. routing
urlpatterns = [path("items/<int:pk>/", views.item_detail)]

# views.py → 5. view
def item_detail(request, pk):
    return render(request, "item.html", {"item": Item.objects.get(pk=pk)})
```

## ఇది ఎందుకు ముఖ్యం

Django యొక్క request/response చక్రం middleware-కేంద్రితమైనది, కాబట్టి చాలా cross-cutting ప్రవర్తన — auth, sessions, CSRF, security headers, caching — క్రమబద్ధమైన middleware గా అమలు చేయబడుతుంది. request-దశ code పై నుండి కిందకు, response-దశ code కింద నుండి పైకి నడుస్తుందని (మరియు `MIDDLEWARE` లో క్రమం ముఖ్యమని) అర్థం చేసుకోవడం మీ స్వంత middleware ను సరిగ్గా ఉంచడానికి, మీ view కు ముందు ఒక `403`/redirect ఎందుకు జరుగుతుందో debug చేయడానికి, మరియు ప్రతి view ను తాకకుండా logic ను ఎక్కడ hook చేయాలో తెలుసుకోవడానికి అవసరం.

దశలు

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు