Ciclo de vida de una solicitud en Flask

Comprender el ciclo de vida completo de una solicitud en Flask es clave para escribir aplicaciones Flask correctamente.

Este capítulo desglosa a nivel de código fuente el proceso completo de una solicitud HTTP desde que llega al servidor hasta que devuelve la respuesta, ayudándote a construir un modelo de ejecución claro.


¿Qué es el ciclo de vida de una solicitud?

El ciclo de vida de una solicitud (Request Lifecycle) se refiere al proceso completo de manejo que atraviesa una solicitud HTTP dentro de Flask.

Incluye las siguientes fases:Recibir solicitud → crear contexto → preprocesar → despachar ruta → ejecutar vista → construir respuesta → limpiar contexto → devolver respuesta。

Si entiendes este proceso, podrás responder correctamente las siguientes preguntas:

  • g¿Cuándo están disponibles los datos del objeto? ¿Cuándo se limpian?
  • before_requestyafter_request¿Cuál es el orden de ejecución?
  • Cuando ocurre una excepción, ¿qué etapas de manejo recorre en orden?
  • ¿Por qué usar fuera de la función de vistarequestcausa un error?

Diagrama de flujo completo

La siguiente figura muestra la cadena de llamadas completa de Flask desde que recibe la solicitud hasta que devuelve la respuesta:

Flask 请求处理生命周期

Explicación detallada paso a paso

Primera fase: entrada WSGI

Cuando una solicitud HTTP llega al servidor, el servidor WSGI (como Gunicorn o el servidor de desarrollo Werkzeug) llama a la instancia de la aplicación Flask.

Flask implementa__call__el método, lo que la convierte en una aplicación WSGI válida:

Ejemplo

# Versión simplificada del código fuente de Flask (ubicación real: flask/app.py)
# El servidor WSGI llamará a tu aplicación de esta manera:
# response = app(environ, start_response)

class Flask(App):
    def __call__(self, environ, start_response):
        """Punto de entrada llamado por el servidor WSGI"""
        return self.wsgi_app(environ, start_response)

    def wsgi_app(self, environ, start_response):
        """Lógica de manejo WSGI real"""
        # Primer paso: crear el contexto de solicitud a partir de environ
        ctx = self.request_context(environ)
        try:
            ctx.push()                    # Empujar a la pila de contextos
            response = self.full_dispatch_request(ctx)  # Despacho completo
        except Exception as e:
            response = self.handle_exception(ctx, e)    # Manejo de excepciones de respaldo
        finally:
            ctx.pop(error)               # Extraer el contexto y realizar la limpieza
        return response(environ, start_response)

Flask diseña el punto de entrada para llamarwsgi_appal método, en lugar de escribir directamente en__call__la lógica. De esta manera, puedes reemplazarapp.wsgi_apppara insertar middleware, sin afectar la llamada aappla propia instancia.

Segunda fase: creación del contexto

request_context(environ)Crear un objeto a partir de las variables de entorno WSGIAppContextobjeto.

Este objeto contiene toda la información de la solicitud actual; cuando es empujado a la pila,request、session、g、current_applos proxies globales comienzan a apuntar a los datos de la solicitud actual.

Ejemplo

# Experimento sencillo para entender el contexto
from flask import Flask, request, current_app

app = Flask(__name__)

with app.app_context():
    # Solo el contexto de aplicación: current_app está disponible, request no
    print(current_app.name)  # ✓ Normal
    # print(request.method) # ✗ Error: Working outside of request context

with app.test_request_context("/hello?name=ejemplo"):
    # El contexto de solicitud también incluye el contexto de aplicación: ambos están disponibles
    print(current_app.name)     # ✓ Imprime el nombre de la app
    print(request.path)         # ✓ Imprime /hello
    print(request.args["name"]) # ✓ Imprime ejemplo
Tipo de contexto Cuándo se crea Cuándo se destruye Variables globales disponibles
Contexto de aplicación Cuando llega la solicitud / manualmente con app.app_context() Cuando termina la solicitud / se sale del bloque with current_app, g
Contexto de solicitud Cuando llega la solicitud / manualmente con app.test_request_context() Cuando termina la solicitud / se sale del bloque with request, session (incluye todas las variables del contexto de aplicación)

El error más común entre los principiantes es acceder directamente a nivel de módulorequest. Recuerda:requestsolo existe en el contexto de solicitud. Solo puedes acceder a él dentro de la función de vista (o en las funciones que esta llame).

Tercera fase: preprocess_request (preprocesamiento)

Una vez que el contexto está listo,full_dispatch_requestprimero se llama apreprocess_request。

Esta fase ejecuta todas las funciones registradas con@app.before_requestlas funciones registradas.

Si cualquiera de lasbefore_requestfunciones devuelve un valor noNoneNone, Flask lo tratará como la respuesta final y omitirá la ejecución posterior de la función de vista.

Ejemplo

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

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

@app.before_request
def check_authentication():
    """Comprobar si el usuario ha iniciado sesión antes de cada solicitud"""
    # Omitir la verificación de autenticación para las páginas de inicio de sesión y registro
    if request.endpoint in ("login", "register", "static"):
        return None  # None indica que se continúa con el flujo normal

    # Si no ha iniciado sesión, devolver directamente una respuesta de redirección (omite la función de vista)
    if "username" not in session:
        return redirect(url_for("login"))

    # El usuario ha iniciado sesión, continuar normalmente
    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 "Página de registro (no requiere inicio de sesión)"

@app.route("/dashboard")
def dashboard():
    return f"Bienvenido {session['username']} a la consola de EJEMPLO"

Cuarta fase: dispatch_request (despacho de rutas)

Después del preprocesamiento, Flask entra en la fase central de despacho:

  1. Hacer coincidir la URL con la regla de ruta correspondiente (Rule)
  2. Extraer los parámetros variables de la URL (view_args)
  3. Llamar a la función de vista correspondiente, pasando los parámetros extraídos

Ejemplo

# Versión simplificada del código fuente: flujo de trabajo de dispatch_request
def dispatch_request(self, ctx):
    req = ctx.request
    # Obtener la regla de ruta coincidente (objeto Rule)
    rule = req.url_rule
    # Obtener los parámetros variables de la URL. Por ejemplo /post/42 → {"post_id": 42}
    view_args = req.view_args
    # Buscar la función correspondiente en el diccionario view_functions y llamarla
    return self.view_functions[rule.endpoint](**view_args)

Cuando no hay coincidencia, se lanzaRoutingException, que finalmente es capturado por el manejador de errores y devuelve 404.

Quinta fase: ejecución de la función de vista

Aquí es donde escribes la lógica de negocio. Flask llama a tu función de vista y obtiene su valor de retorno.

El valor de retorno puede ser de varios tipos (cadena, diccionario, tupla, objeto Response), y todos serán procesados de manera uniforme en la siguiente fase.

Sexta fase: finalize_request (construcción de la respuesta)

Después de que la función de vista termina de ejecutarse,finalize_requestse encarga de convertir el valor de retorno en un objetoResponseResponse estándar:

Ejemplo

# Versión simplificada del código fuente: flujo de trabajo de finalize_request
def finalize_request(self, ctx, rv):
    # 1. Llamar a make_response para convertir los valores de retorno de varios tipos en un objeto Response
    response = self.make_response(rv)

    # 2. Ejecutar los hooks after_request mediante process_response
    response = self.process_response(ctx, response)

    # 3. Enviar la señal: request_finished
    request_finished.send(self, response=response)

    return response

make_responseReglas de conversión:

Tipo de valor de retorno Método de conversión
str / bytes Como cuerpo de la respuesta, Content-Type: text/html
dict / list Llamar a jsonify(), Content-Type: application/json
tuple Se analiza según (body, status) o (body, headers)
Objeto Response Usar directamente
iterator / generator Como respuesta de flujo (streaming)

Séptima fase: hook after_request

process_responseDespués de ejecutarmake_responsea continuación, se llaman sucesivamente todas las funciones@app.after_requestregistradas.

Cadaafter_requestfunción recibe y devuelveResponseobjeto, puede modificar las cabeceras de respuesta, añadir cookies, etc.

Ejemplo

# after_request uso típico: añadir cabeceras de seguridad a cada respuesta
@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  # Debe devolver el objeto response

# También se usa a menudo para añadir cabeceras 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

Octava fase: limpieza del contexto

Después de enviar la respuesta,finallyen el bloquectx.pop()se realiza la limpieza del contexto:

  1. Se invocan todas lasteardown_requestfunciones registradas (se ejecutan tanto si la solicitud tiene éxito como si falla)
  2. Se invocan todas lasteardown_appcontextfunciones registradas
  3. Se envíarequest_tearing_downyappcontext_tearing_downla señal
  4. Se liberangtodos los datos almacenados en el objeto

Ejemplo

# Uso típico de teardown: cerrar la conexión de la base de datos
@app.teardown_appcontext
def close_database_connection(error):
    """Aunque la solicitud falle, asegura que la conexión a la base de datos se cierre"""
    db = g.pop("db", None)
    if db is not None:
        db.close()
    # Parámetro error: si hay una excepción durante la solicitud, aquí se recibirá
    if error:
        app.logger.warning(f"Excepción en la solicitud, conexión a la base de datos cerrada: {error}")

# Diferencia entre teardown y after_request
@app.after_request
def after(response):
    # after_request se ejecuta en el flujo normal, no se ejecuta cuando hay una excepción
    # Se usa para modificar respuestas exitosas
    return response

@app.teardown_request
def teardown(error):
    # teardown siempre se ejecuta, ya sea que la solicitud tenga éxito o falle
    # Se usa para liberar recursos (cerrar archivos, liberar bloqueos, etc.)
    pass

Flujo de manejo de excepciones

Cuando una función de vista lanza una excepción, Flask tiene una ruta especial de manejo de excepciones:

  1. full_dispatch_requestCapturar la excepción
  2. Llamarhandle_user_exceptionDeterminar el tipo de excepción
  3. Excepción HTTP (por ejemplo,abort(404)) → buscar el correspondienteerrorhandler
  4. Excepción normal → buscar el de la clase de excepciónerrorhandler
  5. No se encuentra un manejador → llamarhandle_exception, devolver error 500
  6. Tanto si hay excepción como si no, al final se pasa porfinalize_requestla construcción de la respuesta

Puntos clave en la ruta de excepción:after_requestLos hooks también se ejecutan para respuestas de error (desde Flask 1.1), perobefore_requestEl valor devuelto que no sea None cortocircuita todo el flujo, y las funciones de vista y hooks posteriores no se ejecutarán.


Tabla de referencia rápida de funciones hook

Hook Método de registro Momento de ejecución Uso típico
before_request @app.before_request Antes del despacho de rutas Verificación de inicio de sesión, registro de solicitudes, validación de permisos
before_first_request @app.before_request (deprecado) Antes de la primera solicitud (solo una vez) Operaciones de inicialización (se recomienda usar el patrón de fábrica)
after_request @app.after_request Después de construir la respuesta, antes de enviarla Añadir cabeceras de respuesta, CORS, registros
teardown_request @app.teardown_request Al hacer pop del contexto de solicitud (siempre se ejecuta) Liberar recursos, cerrar archivos
teardown_appcontext @app.teardown_appcontext Al hacer pop del contexto de aplicación (siempre se ejecuta) Cerrar conexiones de base de datos, limpiar caché
errorhandler @app.errorhandler(code) Cuando ocurre el código de error/excepción correspondiente Página de error personalizada

Eventos de señal

Flask usablinkerla biblioteca, que envía señales en puntos clave:

Ejemplo

from flask import Flask, signals

app = Flask(__name__)

# Conectar señal: registrar cuando llega la solicitud
@signals.request_started.connect_via(app)
def log_request_start(sender, **extra):
    print("Inicio de la solicitud")

# Conectar señal: registrar cuando se completa la solicitud
@signals.request_finished.connect_via(app)
def log_request_end(sender, response, **extra):
    print(f"Fin de la solicitud, código de estado de la respuesta: {response.status_code}")

# Conectar señal: capturar excepciones
@signals.got_request_exception.connect_via(app)
def log_exception(sender, exception, **extra):
    print(f"Ocurrió una excepción en la solicitud: {exception}")
Señal Momento de activación
request_started Después de establecerse el contexto de solicitud, antes del preprocesamiento
request_finished Después de construir la respuesta, antes de enviarla
got_request_exception Cuando ocurre una excepción durante el procesamiento de la solicitud
request_tearing_down Cuando se destruye el contexto de solicitud
appcontext_pushed Cuando se empuja el contexto de aplicación a la pila
appcontext_popped Cuando se extrae de la pila el contexto de aplicación
message_flashed Cuando se llama a flash()
template_rendered Cuando el renderizado de la plantilla tiene éxito

Resumen de puntos clave

Regla central: en un ciclo de vida completo de una solicitud,before_request → función de vista → after_request → teardownEstos cuatro nodos siempre se ejecutan en orden (teardown siempre se ejecuta, sin importar si los tres anteriores fallan).

Después de entender el ciclo de vida de la solicitud, al escribir aplicaciones Flask sabrás: la lógica de autenticación se coloca enbefore_request, la lógica de negocio en la función de vista, la modificación de cabeceras de respuesta enafter_request, la liberación de recursos enteardown。

Otras extensiones