Django માં middleware શું છે?

Question

Accepted Answer

**Middleware** એ hooks ની એક framework છે જે **દરેક request અને response** ને globally process કરે છે, વેબ સર્વર અને તમારાં views ની વચ્ચે બેઠું હોય છે. દરેક middleware request ને તપાસી શકે છે/modify કરી શકે છે અને response ને modify કરી શકે છે — authentication, security headers, sessions, અને logging જેવા cross-cutting concerns માટે આદર્શ છે.

## Middleware દ્વારા request/response flow

```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 ની built-in middleware (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
```

Django ની મોટાભાગની core functionality middleware છે: sessions (`request.session`), authentication (`request.user`), CSRF protection, અને security headers બધું જ built-in middleware માંથી આવે છે. **Order મહત્વપૂર્ણ છે** — કેટલીક middleware અન્ય middleware પર પહેલા run થવા માટે આધારિત છે.

## કસ્ટમ 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
```

Ek middleware એક callable છે: `self.get_response(request)` પહેલાનો code request પર run થાય છે, તેના પછીનો code response પર run થાય છે. આ તમને view execution પહેલા અને પછી બંને કામ કરવાની સુવિધા આપે છે.

## Middleware ના સામાન્ય ઉપયોગો

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

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

## શા માટે તે મહત્વપૂર્ણ છે

Middleware Django કે કેવી રીતે requests process કરે છે તેનું મૂળ છે — તેને સમજવાથી ફ્રેમવર્કની મોટી functionality કેવી રીતે કામ કરે છે તે સમજાય છે અને **global, cross-cutting concerns** માટે યોગ્ય mechanism મળે છે.

હોશ્યારી સાથે જાણવું કે sessions, authentication (`request.user`), CSRF protection, અને security headers બધું built-in middleware માંથી આવે છે તે Django ના request handling ને સ્પષ્ટ કરે છે અને બતાવે છે કે શા માટે આ features "બસ કામ કરતા" હોય છે. **Onion-layer request/response flow** (middleware view ને wrap કરે છે, requests top-to-bottom અને responses bottom-to-top process કરે છે) અને કે **order મહત્વપૂર્ણ છે** (કેટલીક middleware અન્ય પર આધારિત છે, જેમ કે authentication ને sessions પહેલે જોઈએ) તે સમજવું Django ને યોગ્ય રીતે configure કરવા અને issues ને debug કરવા માટે મહત્વપૂર્ણ છે.

**કસ્ટમ middleware લખવાની ક્ષમતા** app-wide behavior ને સાફ રીતે implement કરવા માટે મૂલ્યવાન છે — logging, timing, custom headers, rate limiting, maintenance mode — એક જગ્યાએ બદલે views માં તેને બાર-બાર લખવા ના બદલે.

કે middleware ક્યારે use કરવું (global concerns જે મોટાભાગે requests ને અસર કરે છે) બનામ decorators અથવા view logic (per-endpoint concerns) ક્યારે use કરવું તે જાણવું એક મહત્વપૂર્ણ architectural decision છે.

Middleware એ જ્યાં Django request/response processing હેન્ડલ કરે છે જે આખી application માં લાગુ થાય છે, તે તેને મહત્વપૂર્ણ અને practically-relevant knowledge બનાવે છે ફ્રેમવર્ક ની internals ને સમજવા અને proper separation of cross-cutting concerns સાથે well-structured applications બનાવવા બંને માટે.