Yaya rayuwar request (request lifecycle) ke aiki a Django?

Question

IT Interview Practice · Accepted Answer

A Django, **WSGI/ASGI handler** ne ke sarrafa request, wanda gungun **middleware** ke naɗewa, sannan **URL resolver** ke tura shi zuwa **view**, sannan a mai da shi `HttpResponse` da ke komawa waje ta cikin wannan middleware ɗin da kanta a juye.

## Matakan

```
Web server ──▶ WSGI/ASGI handler  (na ƙirƙira HttpRequest)
   ▼
Middleware — matakin request        (sama → ƙasa: __call__ kafin get_response)
   ▼
URL resolver (urls.py)  ── daidaita path → view + kwargs
   ▼
Middleware — hook ɗin process_view
   ▼
View (function / class-based)  ── logic ɗinka, na mayar da HttpResponse
   ▼
Middleware — matakin response        (ƙasa → sama: bayan get_response)
   ▼
HttpResponse ──▶ client
```

1. **Handler** — WSGI (sync) ko ASGI (async) handler na gina `HttpRequest` daga environ/scope.
2. **Middleware, matakin request** — code ɗin kowace middleware wanda ke *kafin* `get_response()` na gudana daga sama-zuwa-ƙasa (`SecurityMiddleware`, `SessionMiddleware`, `AuthenticationMiddleware`, CSRF, …). Kowanne cikinsu na iya toshewa da wuri ya mayar da response da wuri.
3. **URL resolution** — ana daidaita patterns ɗin `ROOT_URLCONF` da path domin zaɓar view da kama kwargs.
4. **`process_view`** — hook ɗin middleware da ke gudana kaɗan kafin a kira view.
5. **View** — view ɗinka na function ko na class na gudana, yawanci na tambayar models sannan render template, sannan ya mayar da `HttpResponse`. Exceptions na kunna `process_exception`.
6. **Middleware, matakin response** — code wanda ke *bayan* `get_response()` na gudana daga ƙasa-zuwa-sama, na barin middleware ta canja response mai fita (headers, compression).
7. Ana stream `HttpResponse` komawa zuwa server da client.

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

def __call__(self, request):          # 2. matakin request (kafin)
        request.started = time.monotonic()
        response = self.get_response(request)  # na kiran layer na gaba / view
        response["X-Time"] = "..."         # 6. matakin response (bayan)
        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)})
```

## Me ya sa yake da muhimmanci

Zagayen request/response na Django na sanya middleware a tsakiya, don haka mafi yawan cross-cutting behavior — auth, sessions, CSRF, security headers, caching — ana aiwatar da su a matsayin middleware mai tsari. Fahimtar cewa code ɗin matakin request na gudana daga sama-zuwa-ƙasa sannan code ɗin matakin response na gudana daga ƙasa-zuwa-sama (kuma cewa tsari a cikin `MIDDLEWARE` na da muhimmanci) yana da muhimmanci wajen sanya middleware ɗinka daidai, da gyara dalilin da ya sa `403`/redirect ke faruwa kafin view ɗinka, da sanin inda za a haɗa logic ba tare da taɓa kowace view ba.

Matakan

Me ya sa yake da muhimmanci

Tambayoyi masu alaƙa