Django मध्ये request lifecycle कसे काम करते?

Question

IT Interview Practice · Accepted Answer

Django मध्ये, request **WSGI/ASGI handler** द्वारे हाताळली जाते, **middleware** च्या एका stack ने गुंडाळली जाते, **URL resolver** द्वारे एका **view** कडे routed केली जाते, आणि एका `HttpResponse` मध्ये रूपांतरित होते जी त्याच middleware मधून उलट्या क्रमाने परत बाहेर वाहते.

## टप्पे

```
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 चा `get_response()` *आधीचा* code वरून-खाली चालतो (`SecurityMiddleware`, `SessionMiddleware`, `AuthenticationMiddleware`, CSRF, …). यापैकी कोणतेही short-circuit करून लवकर response परत करू शकते.
3. **URL resolution** — `ROOT_URLCONF` patterns path शी जुळवले जातात जेणेकरून एक view निवडता येईल आणि kwargs capture करता येतील.
4. **`process_view`** — एक middleware hook जो view कॉल होण्याच्या अगदी आधी चालतो.
5. **View** — तुमचे function- किंवा class-based view चालते, सहसा models query करत आणि एक template render करत, आणि एक `HttpResponse` परत करते. Exceptions `process_exception` ट्रिगर करतात.
6. **Middleware, response टप्पा** — `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 टप्पा (आधी)
        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 cycle middleware-केंद्रित आहे, त्यामुळे बहुतांश cross-cutting वर्तन — auth, sessions, CSRF, security headers, caching — क्रमबद्ध middleware म्हणून अंमलात आणले जाते. request-टप्प्यातील code वरून-खाली चालतो आणि response-टप्प्यातील code खालून-वर चालतो (आणि `MIDDLEWARE` मधील क्रम महत्त्वाचा आहे) हे समजून घेणे तुमचे स्वतःचे middleware योग्यरित्या ठेवण्यासाठी, तुमच्या view आधी `403`/redirect का होते हे debug करण्यासाठी, आणि प्रत्येक view ला स्पर्श न करता logic कुठे hook करायचे हे जाणून घेण्यासाठी आवश्यक आहे.

टप्पे

हे का महत्त्वाचे आहे

संबंधित प्रश्न