Django中间件详解 - 请求响应钩子系统完整指南

class MyMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # 请求处理（视图之前）
        response = self.get_response(request)
        # 响应处理（视图之后）
        return response

    def process_exception(self, request, exception):
        # 异常处理
        pass

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'myproject.middleware.MyMiddleware',  # 自定义中间件
]

# 请求处理流程
请求 -> Middleware1(前) -> Middleware2(前) -> Middleware3(前) -> View -> 响应处理
                                                                        |
# 响应处理流程（逆序）                                                  |
响应 <- Middleware1(后) <- Middleware2(后) <- Middleware3(后) <----------+

import time
import logging

logger = logging.getLogger(__name__)

class TimingMiddleware:
    """请求计时中间件"""

    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        start_time = time.time()

        response = self.get_response(request)

        duration = time.time() - start_time
        logger.info(
            f'{request.method} {request.path} - '
            f'{response.status_code} - {duration:.3f}s'
        )

        # 在响应头中添加处理时间
        response['X-Process-Time'] = f'{duration:.3f}s'
        return response

import time
from django.http import HttpResponseForbidden

class RateLimitMiddleware:
    """IP限流中间件"""

    def __init__(self, get_response):
        self.get_response = get_response
        self.requests = {}  # {ip: [timestamp1, timestamp2, ...]}
        self.max_requests = 100  # 最大请求数
        self.window = 60  # 时间窗口（秒）

    def __call__(self, request):
        ip = self.get_client_ip(request)
        now = time.time()

        # 清理过期记录
        if ip in self.requests:
            self.requests[ip] = [t for t in self.requests[ip] if now - t < self.window]
        else:
            self.requests[ip] = []

        # 检查限流
        if len(self.requests[ip]) >= self.max_requests:
            return HttpResponseForbidden('请求过于频繁，请稍后再试')

        self.requests[ip].append(now)
        return self.get_response(request)

    def get_client_ip(self, request):
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        if x_forwarded_for:
            return x_forwarded_for.split(',')[0].strip()
        return request.META.get('REMOTE_ADDR')

import logging
from django.conf import settings
from django.http import JsonResponse

logger = logging.getLogger(__name__)

class ExceptionHandlerMiddleware:
    """异常处理中间件"""

    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        return self.get_response(request)

    def process_exception(self, request, exception):
        """处理未捕获的异常"""
        logger.error(
            f'未处理异常: {exception.__class__.__name__}: {exception}',
            exc_info=True
        )

        # API请求返回JSON错误
        if request.path.startswith('/api/'):
            return JsonResponse({
                'error': '服务器内部错误',
                'detail': str(exception) if settings.DEBUG else None,
            }, status=500)

        # 普通请求返回None，由Django默认处理
        return None