> В чем разница использования middleware в FastAPI и в Django или Flask? (Python)

Короткий ответ

Основное различие - в архитектуре и жизненном цикле middleware. В FastAPI middleware работает на уровне ASGI: это корутина, оборачивающая весь запрос/ответ, с доступом к scope, receive и send. В Django middleware - это классы с хуками process_request, process_response, process_exception, работающие синхронно в рамках WSGI/ASGI. В Flask middleware - это либо декоратор before_request/after_request, либо WSGI-обёртка. FastAPI даёт больше контроля над потоком данных, но требует понимания ASGI.

Подробное объяснение

В FastAPI middleware - это ASGI-компонент. Вы пишете функцию, которая принимает request (объект Request от Starlette) и call_next, и возвращает Response. Внутри вы можете выполнить код до и после вызова call_next. Это работает на уровне протокола ASGI, поэтому вы можете модифицировать scope, перехватывать receive/send, менять тело ответа, добавлять заголовки, логировать время и т.д. Всё это асинхронно.

В Django middleware - это классы, которые регистрируются в MIDDLEWARE (список строк). Каждый класс реализует один или несколько хуков: __call__ (для ASGI), process_request, process_response, process_exception, process_view. Порядок выполнения строго определён: для process_request - сверху вниз, для process_response - снизу вверх. Django middleware работает синхронно (если не использовать async-версии), и доступ к request/response ограничен API Django ORM, сессий, auth и т.д.

В Flask middleware - это либо декораторы before_request, after_request, teardown_request, либо WSGI-обёртка. Декораторы работают на уровне приложения, а не протокола: вы не можете напрямую менять environ или перехватывать поток данных на уровне WSGI. Для этого нужно писать отдельный WSGI middleware класс, который оборачивает app.wsgi_app. Это синхронно и менее гибко, чем ASGI.

Ключевое различие - модель исполнения: FastAPI - асинхронная, Django - синхронная (с опциями async), Flask - синхронная. Также различается область применения: в FastAPI middleware часто используется для CORS, логирования, обработки ошибок, rate limiting; в Django - для CSRF, auth, session, GZip; в Flask - для обработки запросов, установки глобальных переменных, закрытия ресурсов.

На практике

На практике выбор middleware зависит от фреймворка и задачи. В FastAPI вы пишете middleware как @app.middleware("http") или как класс, наследующий BaseHTTPMiddleware. Это удобно для асинхронных операций (например, вызов внешнего API, работа с БД через async драйвер). Но будьте осторожны: BaseHTTPMiddleware имеет известные проблемы с производительностью и совместимостью с WebSocket, поэтому для критичных путей лучше использовать чистый ASGI middleware.

В Django middleware - это стандартный способ добавить сквозную логику. Вы должны помнить про порядок: если middleware зависит от другого (например, auth), он должен быть ниже в списке. Также важно, что process_response вызывается даже при исключении, поэтому нужно аккуратно обрабатывать response как None.

В Flask - для простых задач используйте before_request/after_request. Для сложных (например, изменение тела ответа) - пишите WSGI middleware. Но помните, что Flask не поддерживает асинхронность, поэтому любые блокирующие операции в middleware будут блокировать весь сервер.

Пример кода

FastAPI (ASGI middleware):

PYTHON
from fastapi import FastAPI, Request
from starlette.middleware.base import BaseHTTPMiddleware

app = FastAPI()

class CustomMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        start = time.time()
        response = await call_next(request)
        response.headers["X-Process-Time"] = str(time.time() - start)
        return response

app.add_middleware(CustomMiddleware)

Django (классический middleware):

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

    def __call__(self, request):
        # до view
        response = self.get_response(request)
        # после view
        response["X-Process-Time"] = str(time.time() - start)
        return response

Flask (декораторы):

PYTHON
from flask import Flask, request, g

app = Flask(__name__)

@app.before_request
def before():
    g.start = time.time()

@app.after_request
def after(response):
    response.headers["X-Process-Time"] = str(time.time() - g.start)
    return response

Как отвечать на собеседовании

Начните с ключевого различия: уровень абстракции (ASGI vs WSGI vs приложение). Затем поясните, что FastAPI middleware - это асинхронная корутина, Django - класс с хуками, Flask - декораторы или WSGI-обёртка. Приведите примеры типичных задач: CORS, логирование, обработка ошибок. Упомяните про порядок выполнения в Django и про ограничения Flask. Если спросят про производительность - скажите, что чистый ASGI middleware в FastAPI быстрее, чем BaseHTTPMiddleware, и что Django sync middleware блокирует event loop в async-режиме. Не углубляйтесь в детали, если не спрашивают.

Что проверяет интервьюер

Интервьюер проверяет понимание архитектуры фреймворков, а не просто знание синтаксиса. Он хочет увидеть, что вы понимаете разницу между синхронной и асинхронной моделью, знаете, как работает WSGI/ASGI, и можете объяснить, почему в FastAPI middleware работает иначе, чем в Django. Также проверяется умение выбирать подходящий инструмент под задачу и знание подводных камней (например, проблемы BaseHTTPMiddleware).

Типичные ошибки

• Путать before_request в Flask с middleware в FastAPI - это разные уровни.
• Считать, что Django middleware работает асинхронно по умолчанию - это не так, если не использовать async-версии.
• Использовать BaseHTTPMiddleware для WebSocket - он ломает работу с WebSocket.
• Забывать про порядок middleware в Django - это приводит к трудноуловимым багам.
• Пытаться в Flask middleware делать асинхронные вызовы - Flask не поддерживает async без дополнительных обёрток.
• Не учитывать, что в FastAPI middleware может быть несколько, и порядок их добавления важен.