Как создать middleware в Django

Создание middleware в Django: полное руководство

Middleware в Django - это мощный механизм для обработки запросов и ответов на уровне всего приложения. Он позволяет выполнять код до и после обработки каждого запроса, что идеально подходит для логирования, аутентификации, CORS и других задач.

Что такое Django middleware?

Middleware - это класс, который обрабатывает запросы и ответы в процессе их прохождения через Django. Каждый middleware может:

Обрабатывать запрос до того, как он дойдет до view
Обрабатывать ответ после того, как view его сгенерирует
Модифицировать запрос или ответ
Прерывать обработку запроса

Структура middleware

Каждый middleware должен реализовывать метод __call__:

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

  def __call__(self, request):
      # Код, выполняемый до view
      print(f"Обрабатывается запрос: {request.path}")

      # Передаем управление следующему middleware или view
      response = self.get_response(request)

      # Код, выполняемый после view
      print(f"Получен ответ: {response.status_code}")

      return response

Практические примеры middleware

1. Middleware для логирования запросов

import time
import logging
from django.utils.deprecation import MiddlewareMixin

logger = logging.getLogger(__name__)

class RequestLoggingMiddleware(MiddlewareMixin):
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Засекаем время начала обработки
        start_time = time.time()

        # Логируем информацию о запросе
        logger.info(f"Начало обработки запроса: {request.method} {request.path}")

        # Обрабатываем запрос
        response = self.get_response(request)

        # Вычисляем время обработки
        duration = time.time() - start_time

        # Логируем результат
        logger.info(
            f"Запрос {request.method} {request.path} обработан за {duration:.2f}с, "
            f"статус: {response.status_code}"
        )

        return response

2. Middleware для аутентификации по API ключу

from django.contrib.auth.models import User
  from django.http import JsonResponse
  from django.utils.deprecation import MiddlewareMixin

  class APIKeyAuthMiddleware(MiddlewareMixin):
      def __init__(self, get_response):
          self.get_response = get_response

      def __call__(self, request):
          # Проверяем API ключ только для API запросов
          if request.path.startswith('/api/'):
              api_key = request.headers.get('X-API-Key')

              if not api_key:
                  return JsonResponse(
                      {'error': 'API ключ не предоставлен'},
                      status=401
                  )

              try:
                  # Ищем пользователя по API ключу
                  user = User.objects.get(profile__api_key=api_key)
                  request.user = user
              except User.DoesNotExist:
                  return JsonResponse(
                      {'error': 'Неверный API ключ'},
                      status=401
                  )

          return self.get_response(request)

3. Middleware для CORS

from django.utils.deprecation import MiddlewareMixin

  class CORSMiddleware(MiddlewareMixin):
      def __init__(self, get_response):
          self.get_response = get_response

      def __call__(self, request):
          response = self.get_response(request)

          # Добавляем CORS заголовки
          response["Access-Control-Allow-Origin"] = "*"
          response["Access-Control-Allow-Methods"] = "GET, POST, PUT, DELETE, OPTIONS"
          response["Access-Control-Allow-Headers"] = "Content-Type, Authorization"

          return response

      def process_view(self, request, view_func, view_args, view_kwargs):
          # Обрабатываем preflight запросы
          if request.method == "OPTIONS":
              response = HttpResponse()
              response["Access-Control-Allow-Origin"] = "*"
              response["Access-Control-Allow-Methods"] = "GET, POST, PUT, DELETE, OPTIONS"
              response["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
              return response

          return None

4. Middleware для кэширования

from django.core.cache import cache
  from django.utils.deprecation import MiddlewareMixin
  import hashlib

class CacheMiddleware(MiddlewareMixin):
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Генерируем ключ кэша на основе URL и параметров
        cache_key = self._generate_cache_key(request)

        # Проверяем кэш для GET запросов
        if request.method == 'GET':
            cached_response = cache.get(cache_key)
            if cached_response:
                return cached_response

        # Обрабатываем запрос
        response = self.get_response(request)

        # Кэшируем успешные GET ответы
        if request.method == 'GET' and response.status_code == 200:
            cache.set(cache_key, response, timeout=300)  # 5 минут

        return response

    def _generate_cache_key(self, request):
        """Генерирует уникальный ключ для кэша"""
        url = request.get_full_path()
        user_id = getattr(request.user, 'id', 'anonymous')
        return hashlib.md5(f"{url}:{user_id}".encode()).hexdigest()

5. Middleware для rate limiting

from django.core.cache import cache
from django.http import HttpResponseTooManyRequests
from django.utils.deprecation import MiddlewareMixin
import time

class RateLimitMiddleware(MiddlewareMixin):
    def __init__(self, get_response):
        self.get_response = get_response
        self.rate_limit = 100  # запросов в минуту
        self.window = 60  # секунд

    def __call__(self, request):
        # Получаем IP адрес
        ip = self._get_client_ip(request)

        # Проверяем лимит запросов
        if not self._check_rate_limit(ip):
            return HttpResponseTooManyRequests(
                "Превышен лимит запросов. Попробуйте позже."
            )

        return self.get_response(request)

    def _get_client_ip(self, request):
        """Получает реальный IP адрес клиента"""
        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

    def _check_rate_limit(self, ip):
        """Проверяет лимит запросов для IP"""
        current_time = int(time.time())
        window_start = current_time - self.window

        # Получаем количество запросов в текущем окне
        key = f"rate_limit:{ip}:{current_time // self.window}"
        requests_count = cache.get(key, 0)

        if requests_count >= self.rate_limit:
            return False

        # Увеличиваем счетчик
        cache.set(key, requests_count + 1, timeout=self.window)
        return True

Специальные методы middleware

Django middleware может реализовывать дополнительные методы:

process_request

class CustomMiddleware(MiddlewareMixin):
    def process_request(self, request):
        """Выполняется до view, может вернуть response для прерывания"""
        if request.path.startswith('/admin/') and not request.user.is_staff:
            return HttpResponseForbidden("Доступ запрещен")
        return None  # Продолжаем обработку

process_response

class CustomMiddleware(MiddlewareMixin):
    def process_response(self, request, response):
        """Выполняется после view, всегда должен вернуть response"""
        # Добавляем заголовок
        response['X-Custom-Header'] = 'Custom Value'
        return response

process_exception

class ExceptionLoggingMiddleware(MiddlewareMixin):
    def process_exception(self, request, exception):
        """Выполняется при возникновении исключения в view"""
        logger.error(
            f"Исключение в {request.path}: {str(exception)}",
            exc_info=True
        )
        return None  # Django обработает исключение стандартно

Регистрация middleware

Добавь middleware в настройки проекта:

# settings.py
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',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'your_app.middleware.CustomMiddleware',  # Твой middleware
]

Порядок выполнения middleware

Middleware выполняется в следующем порядке:

process_request - от первого к последнему
View - обработка запроса
process_response - от последнего к первому
process_exception - при ошибках

Тестирование middleware

Вот пример теста для middleware:

from django.test import TestCase, RequestFactory
from django.http import HttpResponse
from .middleware import CustomMiddleware

class MiddlewareTestCase(TestCase):
    def setUp(self):
        self.factory = RequestFactory()
        self.middleware = CustomMiddleware(lambda req: HttpResponse("OK"))

    def test_middleware_processes_request(self):
        """Тестирует обработку запроса middleware"""
        request = self.factory.get('/test/')
        response = self.middleware(request)

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.content.decode(), "OK")

Лучшие практики

Используй MiddlewareMixin для совместимости с разными версиями Django
Обрабатывай исключения в middleware
Не делай middleware слишком тяжелым - это влияет на производительность
Тестируй middleware отдельно
Документируй назначение и поведение middleware

Отладка middleware

Для отладки middleware используй логирование:

import logging
from django.utils.deprecation import MiddlewareMixin

logger = logging.getLogger(__name__)

class DebugMiddleware(MiddlewareMixin):
    def __call__(self, request):
        logger.debug(f"Middleware: начало обработки {request.path}")

        response = self.get_response(request)

        logger.debug(f"Middleware: завершение обработки {request.path}")
        return response

FAQ

Q: Когда использовать middleware?
A: Для обработки запросов/ответов на уровне всего приложения: логирование, аутентификация, CORS, кэширование, rate limiting.

Q: Можно ли использовать middleware для бизнес-логики?
A: Лучше избегать сложной бизнес-логики в middleware. Используй их для технических задач.

Q: Какой порядок выполнения middleware?
A: process_request выполняется от первого к последнему, process_response - наоборот.

Q: Можно ли прервать выполнение запроса в middleware?
A: Да, если process_request возвращает HttpResponse, запрос не дойдет до view.

Q: Как тестировать middleware?
A: Используй RequestFactory для создания тестовых запросов и проверяй результат.

Заключение

Django middleware - это мощный инструмент для обработки запросов и ответов на уровне приложения. Они позволяют создавать гибкие и расширяемые приложения, но требуют осторожного использования. Следуй лучшим практикам, тестируй свою логику и документируй все middleware.