Django లో middleware అంటే ఏమిటి?

Question

Accepted Answer

**Middleware** అనేది ఒక ఫ్రేమ్‌వర్క్ హుక్‌ల సమితి, ఇది **ప్రతి request మరియు response** ను గ్లోబల్‌గా ప్రక్రియ చేస్తుంది, వెబ్ సర్వర్ మరియు మీ views ల మధ్య కూర్చుంది. ప్రతి middleware request ని తనిఖీ చేయటానికి/సవరించటానికి మరియు response ని సవరించటానికి వీలు ఇస్తుంది — authentication, security headers, sessions, మరియు logging లాంటి cross-cutting concerns కోసం ఆదర్శవంతమైనది.

## Middleware ద్వారా request/response ప్రవాహం

```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 యొక్క కోర్ ఫంక్షనలిటీ చాలా భాగం middleware: sessions (`request.session`), authentication (`request.user`), CSRF protection, మరియు security headers అన్నీ built-in middleware నుండి వస్తాయి. **క్రమం ముఖ్యమైనది** — కొన్ని 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
```

Mmiddleware ఒక callable: `self.get_response(request)` కు ముందుగా ఉన్న కోడ్ request పై నడుస్తుంది, తరువాత ఉన్న కోడ్ response పై నడుస్తుంది. ఇది 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 ను ప్రక్రియ చేసే విధానకు ఆధారమైనది — ఇది ఫ్రేమ్‌వర్క్ యొక్క కోర్ ఫంక్షనలిటీ ఎలా నిజానికి పని చేస్తుందో వివరిస్తుంది మరియు **గ్లోబల్, cross-cutting concerns** కోసం సరైన మెకానిజమ్ ను అందిస్తుంది.

Sessions, authentication (`request.user`), CSRF protection, మరియు security headers అన్నీ built-in middleware నుండి వస్తాయని గుర్తించటం Django యొక్క request handling కోసం రహస్యం పోవటానికి సహాయపడుతుంది మరియు ఈ ఫీచర్‌లు "కేవలం పని చేస్తాయి" కాబట్టి చూపిస్తుంది. **Onion-layer request/response ప్రవాహం** (middleware view ను చుట్టుముటుటూ, requests top-to-bottom మరియు responses bottom-to-top ను ప్రక్రియ చేస్తూ) మరియు **క్రమం ముఖ్యమైనది** (కొన్ని middleware లు ఇతర మిడిల్‌వేర్ పై ఆధారపడతాయి, authentication కు ముందు sessions కు అవసరం) అని అర్థం చేసుకోవటం Django ను సరిగ్గా కాన్ఫిగర్ చేయటానికి మరియు సమస్యలను డీబగ్ చేయటానికి ముఖ్యమైనది.

**Custom middleware రాయటం** సామర్థ్యం అప్లికేషన్-వైడ్ ప్రవర్తనను స్వచ్ఛంగా అమలు చేయటానికి విలువైనది — logging, timing, custom headers, rate limiting, maintenance mode — ఒక స్థానంలో views అంతటా దీన్ని పునరావృత్తి చేయటం కంటే.

Middleware (గ్లోబల్ concerns ఎక్కువ requests ను ప్రభావితం చేస్తుంది) మరియు decorators లేదా view logic (per-endpoint concerns) ను ఉపయోగించటం ఎప్పుడు సరిపోతుందో తెలుసుకోవటం ఒక కీ ఆర్కిటెక్చరల్ నిర్ణయం.

Middleware Django request/response ప్రక్రియ చేసటానికి ఉపయోగపడుతుంది, ఇది మొత్తం అప్లికేషన్ అంతటా వర్తిస్తుంది, ఇది ఫ్రేమ్‌వర్క్ యొక్క internals ను అర్థం చేసుకోవటానికి మరియు cross-cutting concerns యొక్క సరైన విభజన తో బాగా నిర్మిత అప్లికేషన్‌లను నిర్మించటానికి ముఖ్యమైన, ప్రాక్టికల్‌గా-సంబంధితమైన జ్ఞానం చేస్తుంది.