Hva er middleware i Django?

Question

Accepted Answer

**Middleware** er et rammeverk av hooks som behandler **hver request og response** globalt, og sitter mellom webserveren og dine views. Hvert middleware kan inspisere/modifisere requests på vei inn og responses på vei ut — ideelt for cross-cutting concerns som autentisering, sikkerhetshoder, økter og logging.

## Request/response-flyten gjennom middleware

```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)
```

## Djangos innebygde middleware (i settings.py)

```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
```

Mye av Djangos kjernefunksjonalitet er middleware: økter (`request.session`), autentisering (`request.user`), CSRF-beskyttelse og sikkerhetshoder kommer alle fra innebygd middleware. **Rekkefølgen er viktig** — noe middleware avhenger av at andre kjøres først.

## Skrive egendefinert middleware

```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
```

Et middleware er et callable: kode før `self.get_response(request)` kjøres på request-en, kode etter kjøres på response-en. Dette lar deg handle både før og etter viewkjøring.

## Vanlige middleware-brukstilfeller

```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 vs views/dekoratører

```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.
```

## Hvorfor det er viktig

Middleware er grunnleggende for hvordan Django behandler requests — å forstå det forklarer hvordan mye av rammeverkets kjernefunksjonalitet faktisk fungerer og gir deg riktig mekanisme for **globale, cross-cutting concerns**.

Å gjenkjenne at økter, autentisering (`request.user`), CSRF-beskyttelse og sikkerhetshoder alle kommer fra innebygd middleware demystifiserer Djangos request-håndtering og viser hvorfor disse funksjonene "bare fungerer". Å forstå **løk-lag request/response-flyten** (middleware som omslutter viewet, behandler requests topp-til-bunn og responses bunn-til-topp) og at **rekkefølgen er viktig** (noe middleware avhenger av andre, som autentisering som trenger økter først) er viktig for å konfigurere Django korrekt og for å feilsøke problemer.

Evnen til å **skrive egendefinert middleware** er verdifull for å implementere appomfattende oppførsel rent — logging, tidsbestemmelse, egendefinerte headers, rate limiting, vedlikeholdsmodus — på ett sted i stedet for å gjenta det på tvers av views.

Å vite når man skal bruke middleware (globale concerns som påvirker de fleste requests) kontra dekoratører eller view-logikk (per-endepunkt concerns) er en viktig arkitekturellbeslutning.

Middleware er der Django håndterer request/response-behandling som gjelder hele applikasjonen, noe som gjør det viktig, praktisk relevant kunnskap for både å forstå rammeverkets indre arbeider og for å bygge velstrukturerte applikasjoner med riktig separasjon av cross-cutting concerns.