Жизненный цикл запроса Flask

Понимание полного жизненного цикла запроса Flask — ключ к написанию хороших приложений Flask.

В этой главе на уровне исходного кода разбирается весь процесс HTTP-запроса от поступления на сервер до возврата ответа, что помогает построить чёткую модель выполнения.


Что такое жизненный цикл запроса

Жизненный цикл запроса — это полная обработка, которую HTTP-запрос проходит внутри Flask.

Он включает следующие этапы:Получение запроса → Создание контекста → Предварительная обработка → Маршрутизация → Выполнение представления → Формирование ответа → Очистка контекста → Возврат ответа。

Понимая этот процесс, вы сможете правильно ответить на следующие вопросы:

  • gКогда данные объекта становятся доступными? Когда они очищаются?
  • before_requestиafter_requestКаков порядок выполнения?
  • Когда возникает исключение, через какие этапы обработки оно последовательно проходит?
  • Почему использование [его] вне функции представленияrequestприводит к ошибке?

Полная блок-схема

На следующей диаграмме показана полная цепочка вызовов от получения запроса Flask до возврата ответа:

Flask 请求处理生命周期

Пошаговое подробное объяснение

Этап 1: точка входа WSGI

Когда HTTP-запрос поступает на сервер, WSGI-сервер (например, Gunicorn, сервер разработки Werkzeug) вызывает экземпляр приложения Flask.

Flask реализует метод__call__, что делает его валидным WSGI-приложением:

Пример

# Упрощённый исходный код Flask (фактическое расположение: flask/app.py)
# WSGI-сервер вызовет ваше приложение так:
# response = app(environ, start_response)

class Flask(App):
    def __call__(self, environ, start_response):
        """Точка входа, вызываемая WSGI-сервером"""
        return self.wsgi_app(environ, start_response)

    def wsgi_app(self, environ, start_response):
        """Фактическая логика обработки WSGI"""
        # Шаг 1: Создать контекст запроса на основе environ
        ctx = self.request_context(environ)
        try:
            ctx.push()                    # Поместить в стек контекста
            response = self.full_dispatch_request(ctx)  # Полная диспетчеризация
        except Exception as e:
            response = self.handle_exception(ctx, e)    # Резервная обработка исключений
        finally:
            ctx.pop(error)               # Извлечь контекст и выполнить очистку
        return response(environ, start_response)

Flask оформляет точку входа как вызов методаwsgi_app, а не как прямую запись логики__call__внутри. Так вы можете заменитьapp.wsgi_appчтобы вставить middleware, не влияя на то, чтоappвызывает сам экземпляр.

Этап 2: Создание контекста

request_context(environ)Создайте на основе переменных окружения WSGI объектAppContext.

Этот объект содержит всю информацию о текущем запросе. После того как он помещён в стек,request、session、g、current_appэти глобальные прокси начинают указывать на данные текущего запроса.

Пример

# Простой эксперимент для понимания контекста
from flask import Flask, request, current_app

app = Flask(__name__)

with app.app_context():
    # Доступен только контекст приложения — current_app можно использовать, request — нет.
    print(current_app.name)  # ✓ ОК
    # print(request.method) # ✗ Ошибка: работа вне контекста запроса

with app.test_request_context("/hello?name=example"):
    # Контекст запроса также включает контекст приложения — доступны оба.
    print(current_app.name)     # ✓ Выводит имя приложения
    print(request.path)         # ✓ Выводит /hello
    print(request.args["name"]) # ✓ Выводит example
Тип контекста Когда создаётся Когда уничтожается Доступные глобальные переменные
Контекст приложения Когда приходит запрос / Вручную с app.app_context() Конец запроса / выход из блока with current_app, g
Контекст запроса Когда приходит запрос / вручную с app.test_request_context() Конец запроса / выход из блока with request, session (все переменные в контексте приложения)

Самая распространённая ошибка начинающих — обращаться напрямую на уровне модуля кrequest. Запомните:requestсуществует только внутри контекста запроса. Обращаться к нему можно только внутри функций представления (или вызываемых ими функций).

Фаза 3: preprocess_request (предварительная обработка)

Когда контекст готов,full_dispatch_requestсначала вызываетpreprocess_request。

На этом этапе выполняется весь код, зарегистрированный с помощью@app.before_request, а именно зарегистрированные функции.

Если любаяbefore_requestфункция возвращает не-Noneзначение, Flask рассматривает его как окончательный ответ и пропускает выполнение последующих функций представления.

Пример

from flask import Flask, request, session, redirect, url_for

app = Flask(__name__)
app.secret_key = "dev-secret"

@app.before_request
def check_authentication():
    """Проверить, вошёл ли пользователь в систему перед каждым запросом"""
    # Пропустить проверки аутентификации для страниц входа и регистрации
    if request.endpoint in ("login", "register", "static"):
        return None  # None означает продолжить обычный поток выполнения

    # Если пользователь не вошёл в систему, сразу вернуть ответ с перенаправлением (пропустить функцию представления)
    if "username" not in session:
        return redirect(url_for("login"))

    # Пользователь вошёл в систему, продолжаем как обычно
    return None

@app.route("/login", methods=["GET", "POST"])
def login():
    if request.method == "POST":
        session["username"] = request.form["username"]
        return redirect(url_for("dashboard"))
    return '<form method="post"><input name="username"><input type="submit"></form>'

@app.route("/register")
def register():
    return "Страница регистрации (вход не требуется)"

@app.route("/dashboard")
def dashboard():
    return f"Добро пожаловать, {session['username']}, в консоль EXAMPLE"

Этап 4: dispatch_request (Диспетчеризация маршрутов)

После завершения предварительной обработки Flask переходит к основному этапу диспетчеризации:

  1. Сопоставить URL с соответствующим правилом маршрута (Rule)
  2. Извлечь переменные параметры из URL (view_args)
  3. Вызвать соответствующую функцию представления, передав извлечённые параметры

Пример

# Упрощённый исходный код: рабочий процесс dispatch_request
def dispatch_request(self, ctx):
    req = ctx.request
    # Получить сопоставленное правило маршрутизации (объект Rule)
    rule = req.url_rule
    # Получить переменные параметры из URL. Например /post/42 → {"post_id": 42}
    view_args = req.view_args
    # Найти соответствующую функцию в словаре view_functions и вызвать её
    return self.view_functions[rule.endpoint](**view_args)

Когда сопоставление не удаётся, выбрасываетсяRoutingException, и в конечном итоге оно перехватывается обработчиком ошибок и возвращает 404.

Этап 5: Выполнение функции представления

Здесь вы пишете свою бизнес-логику. Flask вызывает вашу функцию представления и получает возвращаемое значение.

Возвращаемое значение может быть многих типов — строки, словари, кортежи, объекты Response — все они единообразно обрабатываются на следующем этапе.

Этап 6: finalize_request (построение Response)

После завершения выполнения функции представленияfinalize_requestотвечает за преобразование возвращаемого значения в стандартныйResponseобъект:

Пример

# Упрощённый исходный код: процесс finalize_request
def finalize_request(self, ctx, rv):
    # 1. Вызвать make_response, чтобы преобразовать различные типы возвращаемых значений в объекты Response
    response = self.make_response(rv)

    # 2. Выполнить хуки after_request через process_response
    response = self.process_response(ctx, response)

    # 3. Отправка сигнала: request_finished
    request_finished.send(self, response=response)

    return response

make_responseправила преобразования:

Тип возвращаемого значения Способ преобразования
str / bytes Как тело ответа, Content-Type: text/html
dict / list Вызов jsonify(), Content-Type: application/json
tuple Интерпретируется как (body, status) или (body, headers)
Объект Response Используется напрямую
iterator / generator как потоковый ответ

Этап 7: хук after_request

process_responseВо время выполненияmake_responseПосле этого он вызывает все зарегистрированные@app.after_requestзарегистрированные функции.

каждаяafter_requestфункция получает и возвращаетResponseобъект, можно изменять заголовки ответа, добавлять cookies и так далее.

Пример

# Типичное использование after_request: добавление заголовков безопасности к каждому ответу
@app.after_request
def add_security_headers(response):
    response.headers["X-Content-Type-Options"] = "nosniff"
    response.headers["X-Frame-Options"] = "DENY"
    response.headers["X-XSS-Protection"] = "1; mode=block"
    return response  # Нужно вернуть объект ответа

# Также часто используется для добавления заголовков CORS
@app.after_request
def add_cors_headers(response):
    response.headers["Access-Control-Allow-Origin"] = "*"
    response.headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, DELETE"
    return response

Этап 8: Очистка контекста

После отправки ответа,наконец,в блокеctx.pop()Выполнить очистку контекста:

  1. вызвать всеteardown_requestфункции, зарегистрированные с помощью (выполняются независимо от успеха или неудачи запроса)
  2. вызвать всеteardown_appcontextзарегистрированные функции
  3. отправитьrequest_tearing_downиappcontext_tearing_downсигнал
  4. освободитьgвсе данные, хранящиеся в объекте

Пример

# Типичное использование teardown: закрыть соединение с базой данных
@app.teardown_appcontext
def close_database_connection(error):
    """Убедитесь, что соединение с базой данных закрыто, даже если запрос завершится ошибкой"""
    db = g.pop("db", None)
    if db is not None:
        db.close()
    # параметр error: если во время запроса возникает исключение, оно будет получено здесь
    if error:
        app.logger.warning(f"Исключение при запросе, соединение с базой данных закрыто: {error}")

# Разница между teardown и after_request
@app.after_request
def after(response):
    # after_request выполняется в обычном потоке, а не при возникновении исключения
    # Используется для изменения успешных ответов
    return response

@app.teardown_request
def teardown(error):
    # teardown всегда выполняется — независимо от того, успешен запрос или завершился неудачей
    # Используется для очистки ресурсов (закрытие файлов, освобождение блокировок и т. д.)
    pass

поток обработки исключений

Когда функция представления вызывает исключение, Flask имеет выделенный путь обработки исключений:

  1. full_dispatch_requestПерехват исключений
  2. Вызовhandle_user_exceptionопределить тип исключения
  3. Исключения HTTP (такие какabort(404)) → найти соответствующийerrorhandler
  4. обычное исключение → найтиerrorhandler класса исключения
  5. обработчик не найден → вызватьhandle_exception, вернуть ошибку 500
  6. Независимо от исключений, в конечном итоге выполнение пройдёт черезfinalize_requestПостроение ответа

Ключевые моменты в пути обработки исключений:after_requestХуки также выполняются для ответов с ошибками (начиная с Flask 1.1), ноbefore_requestЗначение, отличное от None, возвращённое из него, прерывает весь поток; последующие функции представления и хуки не выполняются.


Краткий справочник по функциям-хукам

Хук Метод регистрации Момент выполнения Типичное использование
before_request @app.before_request перед диспетчеризацией маршрута проверки входа, журналирование запросов, проверка прав
before_first_request @app.before_request (устарело) Перед первым запросом (только один раз) Операции инициализации (вместо этого рекомендуется использовать фабричный шаблон)
after_request @app.after_request После формирования ответа, перед отправкой Добавление заголовков ответа, CORS, логов
teardown_request @app.teardown_request Когда контекст запроса снимается (выполняется всегда) Освобождение ресурсов, закрытие файлов
teardown_appcontext @app.teardown_appcontext Когда контекст приложения снимается (выполняется всегда) Закрытие подключений к базе данных, очистка кэша
errorhandler @app.errorhandler(code) Когда возникает соответствующий код ошибки/исключение пользовательские страницы ошибок

Событие сигнала

Flask используетblinkerЭта библиотека отправляет сигналы в ключевых точках:

Пример

from flask import Flask, signals

app = Flask(__name__)

# Подключить сигнал — записывать при поступлении запроса
@signals.request_started.connect_via(app)
def log_request_start(sender, **extra):
    print("Запрос начат")

# Подключить сигнал — записывать при завершении запроса
@signals.request_finished.connect_via(app)
def log_request_end(sender, response, **extra):
    print(f"Запрос завершён, код состояния ответа: {response.status_code}")

# Подключить сигнал — перехватывать исключения
@signals.got_request_exception.connect_via(app)
def log_exception(sender, exception, **extra):
    print(f"Во время запроса произошло исключение: {exception}")
signal Момент срабатывания
request_started После установления контекста запроса, перед предварительной обработкой
request_finished После завершения построения ответа, перед отправкой
got_request_exception Когда во время обработки запроса возникает исключение
request_tearing_down Когда контекст запроса уничтожается
appcontext_pushed Когда контекст приложения помещается в стек
appcontext_popped Когда контекст приложения извлекается из стека
message_flashed при вызове flash()
template_rendered когда рендеринг шаблона завершается успешно

сводка ключевых моментов

Основные правила: В полном жизненном цикле запроса,before_request → Функция представления → after_request → teardownЭти четыре узла гарантированно выполняются по порядку (teardown всегда выполняется независимо от того, завершатся ли первые три с ошибкой).

Поняв жизненный цикл запроса, при написании приложений Flask вы будете знать: помещать логику аутентификации вbefore_request, помещать бизнес-логику в функции представления, а изменение заголовков ответа — вafter_requestпомещать очистку ресурсов вteardown。

Другие расширения