Django ਵਿੱਚ middleware ਕੀ ਹੈ?

Question

Accepted Answer

**Middleware** ਇੱਕ hooks ਦਾ framework ਹੈ ਜੋ **ਹਰ request ਅਤੇ response** ਨੂੰ globally ਪ੍ਰਸੰਸਕਰਤ ਕਰਦਾ ਹੈ, ਜੋ web server ਅਤੇ ਤੁਹਾਡੇ views ਦੇ ਵਿਚਕਾਰ ਬੈਠਾ ਹੁੰਦਾ ਹੈ। ਹਰ middleware incoming ਸਮੇਂ requests ਨੂੰ inspect/modify ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ outgoing ਸਮੇਂ responses ਨੂੰ — authentication, security headers, sessions, ਅਤੇ logging ਜਿਵੇਂ cross-cutting concerns ਲਈ ideal ਹੈ।

## 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 ਦੂਜਿਆਂ ਦੇ ਪਹਿਲਾਂ ਚਲਣ ਉੱਤੇ ਨਿਰਭਰ ਹੈ।

## Custom 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 ਉੱਤੇ ਚਲਦਾ ਹੈ, ਬਾਅਦ ਵਾਲਾ code response ਉੱਤੇ ਚਲਦਾ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ view execution ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਦੋਵੇਂ ਕੰਮ ਕਰਨ ਦਿੰਦਾ ਹੈ।

## Common middleware uses

```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 ਦੀ ਪ੍ਰਸੰਸਕਾਰ ਵਿਧੀ ਦੇ ਲਈ ਬੁਨਿਆਦੀ ਹੈ — ਇਸ ਨੂੰ ਸਮਝਣਾ ਦੱਸਦਾ ਹੈ ਕਿ framework ਦੀ ਬਹੁਤ ਸਾਰੀ core functionality ਅਸਲ ਵਿੱਚ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ ਅਤੇ **global, cross-cutting concerns** ਲਈ ਸਹੀ mechanism ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਇਹ ਪਛਾਣਨਾ ਕਿ sessions, authentication (`request.user`), CSRF protection, ਅਤੇ security headers ਸਭ built-in middleware ਤੋਂ ਆਉਂਦੇ ਹਨ, Django ਦੀ request handling ਨੂੰ demystify ਕਰਦਾ ਹੈ ਅਤੇ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਇਹ features "ਬਸ ਕੰਮ ਕਿਓਂ ਕਰਦੇ ਹਨ"। **Onion-layer request/response flow** ਨੂੰ ਸਮਝਣਾ (middleware view ਦੋ ਪਾਸਿਓਂ wrapping ਕਰਦਾ ਹੈ, requests ਨੂੰ top-to-bottom ਅਤੇ responses ਨੂੰ bottom-to-top ਪ੍ਰਸੰਸਕਰਤ ਕਰਦਾ ਹੈ) ਅਤੇ ਇਹ ਕਿ **order ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ** (ਕੁਝ middleware ਦੂਜਿਆਂ ਉੱਤੇ ਨਿਰਭਰ ਹੈ, ਜਿਵੇਂ ਕਿ authentication ਨੂੰ ਪਹਿਲਾਂ sessions ਦੀ ਲੋੜ ਹੈ) Django ਨੂੰ ਠੀਕ ਤਰ੍ਹਾਂ ਸੰਰਚਿਤ ਕਰਨ ਅਤੇ ਸਮੱਸਿਆਵਾਂ ਨੂੰ debug ਕਰਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।

**Custom middleware ਲਿਖਣ ਦੀ ਸਮਰੱਥਾ** app-wide behavior ਨੂੰ cleanly implement ਕਰਨ ਲਈ ਕੀਮਤੀ ਹੈ — logging, timing, custom headers, rate limiting, maintenance mode — ਇੱਕ ਥਾਂ ਵਿੱਚ ਇਸ ਨੂੰ views ਦੇ ਪਾਰ ਵਾਰ ਵਾਰ ਕਰਨ ਦੀ ਬਜਾਏ।

ਇਹ ਜਾਣਨਾ ਕਿ middleware ਦੀ ਵਰਤੋਂ ਕਦੋਂ ਕਰਨੀ ਹੈ (global concerns ਜੋ ਜ਼ਿਆਦਾਤਰ requests ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ) ਬਨਾਮ decorators ਜਾਂ view logic (per-endpoint concerns) ਇੱਕ ਮੁੱਖ architectural ਫੈਸਲਾ ਹੈ।

Middleware ਉਹ ਜਗ੍ਹਾ ਹੈ ਜਿੱਥੇ Django request/response processing ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ ਜੋ ਪੂਰੀ application ਵਿੱਚ ਲਾਗੂ ਹੁੰਦੀ ਹੈ, ਇਸ ਨੂੰ framework ਦੇ internals ਨੂੰ ਸਮਝਣ ਅਤੇ ਸਹੀ separation of cross-cutting concerns ਦੇ ਨਾਲ well-structured applications ਬਣਾਉਣ ਦੋਵੇਂ ਲਈ ਮਹੱਤਵਪੂਰਨ, practically-relevant ਗਿਆਨ ਬਣਾਉਂਦਾ ਹੈ।