Conas a oibríonn saolré an request in Django?

Question

IT Interview Practice · Accepted Answer

In Django, láimhseáiltear request ag an **WSGI/ASGI handler**, fillte ag cruach de **middleware**, ródaithe ag an **URL resolver** chuig **view**, agus iompaithe ina `HttpResponse` a shreabhann amach arís trí na middleware céanna san ord droim ar ais.

## Na céimeanna

```
Web server ──▶ WSGI/ASGI handler  (cruthaíonn HttpRequest)
   ▼
Middleware — céim request         (barr → bun: __call__ roimh get_response)
   ▼
URL resolver (urls.py)  ── meaitseáil path → view + kwargs
   ▼
Middleware — hook process_view
   ▼
View (function / class-based)  ── do loighic, filleann HttpResponse
   ▼
Middleware — céim response         (bun → barr: tar éis get_response)
   ▼
HttpResponse ──▶ client
```

1. **Handler** — tógann an WSGI (sync) nó ASGI (async) handler `HttpRequest` ón environ/scope.
2. **Middleware, céim request** — ritheann an cód *roimh* `get_response()` i ngach middleware ó bharr go bun (`SecurityMiddleware`, `SessionMiddleware`, `AuthenticationMiddleware`, CSRF, …). Is féidir le haon cheann acu ciorcadghearradh agus response a fhilleadh go luath.
3. **URL resolution** — meaitseáiltear patrúin `ROOT_URLCONF` in aghaidh an path chun view a roghnú agus kwargs a ghabháil.
4. **`process_view`** — hook middleware a ritheann díreach roimh an view a ghlaoch.
5. **View** — ritheann do view fheidhm-bhunaithe nó rang-bhunaithe, de ghnáth ag ceistiú models agus ag rindreáil template, agus filleann sé `HttpResponse`. Spreagann eisceachtaí `process_exception`.
6. **Middleware, céim response** — ritheann an cód *tar éis* `get_response()` ó bhun go barr, ag ligean do middleware an response amach a mhodhnú (headers, comhbhrú).
7. Sruthaítear an `HttpResponse` ar ais chuig an server agus an client.

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

def __call__(self, request):          # 2. céim request (roimh)
        request.started = time.monotonic()
        response = self.get_response(request)  # glaonn ar an gcéad chiseal / view eile
        response["X-Time"] = "..."         # 6. céim response (tar éis)
        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)})
```

## Cén fáth a bhfuil sé tábhachtach

Tá timthriall request/response Django dírithe ar middleware, mar sin cuirtear an chuid is mó den iompar trasghearrthach — auth, sessions, CSRF, security headers, caching — i bhfeidhm mar middleware ordaithe. Tá sé riachtanach a thuiscint go ritheann cód na céime request ó bharr go bun agus go ritheann cód na céime response ó bhun go barr (agus go bhfuil an t-ord in `MIDDLEWARE` tábhachtach) chun do mhiddleware féin a chur i gceart, chun a dhífhabhtú cén fáth a dtarlaíonn `403`/redirect roimh do view, agus chun a fháil amach cén áit ar cheart loighic a hook-áil gan gach view a láimhseáil.

Na céimeanna

Cén fáth a bhfuil sé tábhachtach

Ceisteanna gaolmhara