Mi az a middleware a Django-ban?

Question

Accepted Answer

**Middleware** egy horog-keretrendszer, amely globálisan feldolgozza **minden kérést és választ**, a webszerver és a nézeteid között helyezkedve el. Minden middleware képes megvizsgálni/módosítani a kéréseket az érkezéskor és a válaszokat az induláskor — ideális keresztfeladatok kezelésére, mint a hitelesítés, biztonsági fejlécek, munkamenetek és naplózás.

## A kérés/válasz folyamata a middleware-en keresztül

```text
Request  → MW1 → MW2 → MW3 → VIEW
Response ← MW1 ← MW2 ← MW3 ← VIEW

Middleware wraps the view like layers of an onion:
  - on the way IN (request): top-to-bottom
  - on the way OUT (response): bottom-to-top (reverse order)
```

## Django beépített middleware-e (a settings.py-ben)

```python
MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",          # security headers (HSTS, etc.)
    "django.contrib.sessions.middleware.SessionMiddleware",   # enables request.session
    "django.middleware.common.CommonMiddleware",
    "django.middleware.csrf.CsrfViewMiddleware",              # CSRF protection
    "django.contrib.auth.middleware.AuthenticationMiddleware",# enables request.user
    "django.middleware.clickjacking.XFrameOptionsMiddleware", # clickjacking protection
]
# ORDER MATTERS — e.g. SessionMiddleware must come before AuthenticationMiddleware
```

A Django sok alapvető funkciója middleware: munkamenetek (`request.session`), hitelesítés (`request.user`), CSRF-védelem és biztonsági fejlécek mind a beépített middleware-ből származnak. **A sorrend számít** — néhány middleware függ attól, hogy mások előbb futhassanak le.

## Egyéni middleware írása

```python
class TimingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response          # the next middleware/view

def __call__(self, request):
        # --- code here runs on the way IN (before the view) ---
        import time; start = time.time()

response = self.get_response(request)     # call the next layer (eventually the view)

# --- code here runs on the way OUT (after the view) ---
        response["X-Response-Time"] = f"{time.time() - start:.3f}s"
        return response
```

A middleware egy callable: a `self.get_response(request)` előtti kód a kérésre fut, utána pedig a válaszra. Ez lehetővé teszi, hogy a nézet végrehajtása előtt és után is cselekedhess.

## Middleware gyakori felhasználási esetei

```text
✓ Authentication / setting request.user
✓ Security headers (CSP, HSTS, X-Frame-Options)
✓ Request/response logging, timing, metrics
✓ Sessions, locale/i18n detection, CORS
✓ Rate limiting, maintenance mode, custom request preprocessing
```

## Middleware versus nézetek/dekorátorok

```text
Middleware → GLOBAL, cross-cutting concerns affecting EVERY (or most) request
Decorators/view logic → per-view concerns specific to certain endpoints
→ Use middleware for app-wide behavior; decorators for selective behavior.
```

## Miért fontos

A middleware alapvető a Django kérésfelhasználásában — a megértése elmagyarázza, hogy a keretrendszer sok alapfunkciója valójában hogyan működik, és biztosítja a megfelelő mechanizmust a **globális, keresztfeladat-problémák** megoldásához.

Annak felismerése, hogy a munkamenetek, hitelesítés (`request.user`), CSRF-védelem és biztonsági fejlécek mind a beépített middleware-ből származnak, demisztifikálja a Django kéréskezelését és megmutatja, miért "működnek csak úgy ezek a funkciók". A **hagymaréteg-típusú kérés/válasz folyamat** megértése (middleware körülveszi a nézetet, a kéréseket fentről lefelé, a válaszokat pedig lentről felfelé feldolgozva) és az, hogy **a sorrend számít** (néhány middleware függ másoktól, például a hitelesítés a munkamenetekre szorul először), fontos a Django helyes konfigurálásához és a hibák elhárításához.

Az **egyéni middleware írásának** képessége értékes az alkalmazások széles körére kiterjedő viselkedés tiszta megvalósításához — naplózás, időmérés, egyéni fejlécek, forgalomsebességi korlátozás, karbantartási mód — egy helyen, ahelyett, hogy a nézetek között ismétlődne.

Annak ismerete, hogy mikor kell middleware-t használni (globális problémák, amelyek a legtöbb kérésre hatnak) szemben a dekorátorokkal vagy nézeti logiával (konkrét végpontok problémái), kulcsfontosságú építészeti döntés.

A middleware az a hely, ahol a Django a teljes alkalmazáson átívelő kérés/válasz-feldolgozást kezeli, így fontos, gyakorlati vonatkozású ismeretté válik mind a keretrendszer internálisainak megértéséhez, mind a jól strukturált alkalmazások létrehozásához, megfelelő szétválasztásával a keresztfeladat-problémák kezeléséhez.