Django मा request lifecycle कसरी काम गर्छ?

Question

IT Interview Practice · Accepted Answer

Django मा, request लाई **WSGI/ASGI handler** ले सम्हाल्छ, **middleware** को एउटा stack ले बेर्छ, **URL resolver** ले एउटा **view** मा route गर्छ, र यो एउटा `HttpResponse` मा परिणत हुन्छ जुन त्यही middleware बाट उल्टो क्रममा फर्केर बाहिर बग्छ।

## चरणहरू

```
Web server ──▶ WSGI/ASGI handler  (HttpRequest बनाउँछ)
   ▼
Middleware — request phase        (माथि → तल: get_response अघि __call__)
   ▼
URL resolver (urls.py)  ── path मिलाउँछ → view + kwargs
   ▼
Middleware — process_view hook
   ▼
View (function / class-based)  ── तपाईंको logic, HttpResponse फर्काउँछ
   ▼
Middleware — response phase        (तल → माथि: get_response पछि)
   ▼
HttpResponse ──▶ client
```

1. **Handler** — WSGI (sync) वा ASGI (async) handler ले environ/scope बाट एउटा `HttpRequest` बनाउँछ।
2. **Middleware, request phase** — प्रत्येक middleware को `get_response()` *अघि* को code माथिबाट तलसम्म चल्छ (`SecurityMiddleware`, `SessionMiddleware`, `AuthenticationMiddleware`, CSRF, …)। तीमध्ये कुनैले पनि short-circuit गरेर छिट्टै response फर्काउन सक्छ।
3. **URL resolution** — `ROOT_URLCONF` का pattern हरू path सँग मिलाइन्छ र view छान्न तथा kwargs capture गर्न प्रयोग हुन्छ।
4. **`process_view`** — view call हुनुभन्दा ठीक अघि चल्ने middleware hook।
5. **View** — तपाईंको function- वा class-based view चल्छ, सामान्यतया models query गर्छ र template render गर्छ, र एउटा `HttpResponse` फर्काउँछ। Exception ले `process_exception` trigger गर्छ।
6. **Middleware, response phase** — `get_response()` *पछि* को code तलबाट माथिसम्म चल्छ, जसले middleware लाई बाहिर जाने response (headers, compression) परिमार्जन गर्न दिन्छ।
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 phase (अघि)
        request.started = time.monotonic()
        response = self.get_response(request)  # अर्को layer / view call गर्छ
        response["X-Time"] = "..."         # 6. response phase (पछि)
        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 cycle middleware-केन्द्रित छ, त्यसैले धेरैजसो cross-cutting behavior — auth, sessions, CSRF, security headers, caching — क्रमबद्ध middleware को रूपमा लागू गरिन्छ। request-phase code माथिबाट तल चल्छ र response-phase code तलबाट माथि चल्छ (र `MIDDLEWARE` मा क्रमले फरक पार्छ) भनेर बुझ्नु तपाईंको आफ्नै middleware सही ठाउँमा राख्न, तपाईंको view अघि नै किन `403`/redirect हुन्छ भनेर debug गर्न, र प्रत्येक view नछोई कहाँ logic hook गर्ने भन्ने थाहा पाउन आवश्यक छ।

चरणहरू

यो किन महत्त्वपूर्ण छ

सम्बन्धित प्रश्नहरू