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` patterns ਨੂੰ path ਨਾਲ ਮੇਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਇੱਕ view ਚੁਣੀ ਜਾਵੇ ਅਤੇ kwargs ਫੜੇ ਜਾਣ।
4. **`process_view`** — ਇੱਕ middleware hook ਜੋ view ਨੂੰ ਕਾਲ ਕਰਨ ਤੋਂ ਠੀਕ ਪਹਿਲਾਂ ਚੱਲਦਾ ਹੈ।
5. **View** — ਤੁਹਾਡੀ function- ਜਾਂ class-based view ਚੱਲਦੀ ਹੈ, ਆਮ ਤੌਰ 'ਤੇ models ਨੂੰ query ਕਰਦੀ ਹੈ ਅਤੇ ਇੱਕ template render ਕਰਦੀ ਹੈ, ਅਤੇ ਇੱਕ `HttpResponse` ਵਾਪਸ ਕਰਦੀ ਹੈ। ਅਪਵਾਦ `process_exception` ਨੂੰ ਟ੍ਰਿਗਰ ਕਰਦੇ ਹਨ।
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)  # ਅਗਲੀ ਪਰਤ / view ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ
        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 ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਰੱਖਣ, debug ਕਰਨ ਕਿ ਤੁਹਾਡੀ view ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ `403`/redirect ਕਿਉਂ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਹਰ view ਨੂੰ ਛੂਹੇ ਬਿਨਾਂ logic ਕਿੱਥੇ hook ਕਰਨੀ ਹੈ ਇਹ ਜਾਣਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਪੜਾਅ

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ