What is Django Middleware and how do you create custom middleware? Django Middleware क्या है और custom middleware कैसे create करते हैं?

Middleware is a set of hooks/filters that process requests and responses globally. Built-in middleware handles security, sessions, and authentication. Create custom middleware for logging, timing, authentication checks, or modifying requests/responses.

// Middleware Execution Order
// Request: Top to Bottom
// Response: Bottom to Top

// settings.py - Middleware configuration
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'myapp.middleware.CustomLoggingMiddleware',  # Custom
    'myapp.middleware.TimingMiddleware',  # Custom
]

// middleware.py - Custom Middleware
import time
import logging
from django.utils.deprecation import MiddlewareMixin

logger = logging.getLogger(__name__)

// Method 1: Class-based middleware
class CustomLoggingMiddleware(MiddlewareMixin):
    # Called for every request
    def process_request(self, request):
        logger.info(f'Request: {request.method} {request.path}')
        logger.info(f'User: {request.user}')
        # Return None to continue, or Response to short-circuit
        return None
    
    # Called after view processes request (if view returns response)
    def process_view(self, request, view_func, view_args, view_kwargs):
        logger.info(f'View: {view_func.__name__}')
        return None
    
    # Called after response is generated
    def process_response(self, request, response):
        logger.info(f'Response Status: {response.status_code}')
        return response
    
    # Called if view raises exception
    def process_exception(self, request, exception):
        logger.error(f'Exception: {exception}')
        return None

// Timing Middleware
class TimingMiddleware(MiddlewareMixin):
    def process_request(self, request):
        request._start_time = time.time()
        return None
    
    def process_response(self, request, response):
        if hasattr(request, '_start_time'):
            duration = time.time() - request._start_time
            logger.info(f'{request.path} took {duration:.2f} seconds')
            response['X-Process-Time'] = str(duration)
        return response

// Authentication Middleware
class AuthenticationCheckMiddleware(MiddlewareMixin):
    def process_request(self, request):
        # Skip for public pages
        public_urls = ['/login/', '/register/', '/about/']
        if request.path not in public_urls:
            if not request.user.is_authenticated:
                # Redirect to login or return 403
                from django.shortcuts import redirect
                return redirect('login')
        return None

// IP Blocking Middleware
class IPBlockMiddleware(MiddlewareMixin):
    BLOCKED_IPS = ['192.168.1.100', '10.0.0.1']
    
    def process_request(self, request):
        client_ip = self.get_client_ip(request)
        if client_ip in self.BLOCKED_IPS:
            from django.http import HttpResponse
            return HttpResponse('Access Denied', status=403)
        return None
    
    def get_client_ip(self, request):
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        if x_forwarded_for:
            ip = x_forwarded_for.split(',')[0]
        else:
            ip = request.META.get('REMOTE_ADDR')
        return ip

// Middleware Execution Flow
/*
Request Flow:
1. process_request (top to bottom)
2. process_view
3. View processes request
4. process_response (bottom to top)

Exception Flow:
1. process_exception called
2. Custom error handling
3. Return error response

Example Order:
SecurityMiddleware.process_request
SessionMiddleware.process_request
CsrfMiddleware.process_request
CustomMiddleware.process_request
[View Processing]
CustomMiddleware.process_response
CsrfMiddleware.process_response
SessionMiddleware.process_response
SecurityMiddleware.process_response
*/

// Common Use Cases
// 1. Request/response logging
// 2. Performance monitoring
// 3. Authentication checking
// 4. IP blocking
// 5. Header modification
// 6. Request timing
// 7. Error tracking
// 8. Rate limiting