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:
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
# 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
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
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:
- Hacer coincidir la URL con la regla de ruta correspondiente (Rule)
- Extraer los parámetros variables de la URL (view_args)
- Llamar a la función de vista correspondiente, pasando los parámetros extraídos
Ejemplo
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
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
@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:
- Se invocan todas lasteardown_requestfunciones registradas (se ejecutan tanto si la solicitud tiene éxito como si falla)
- Se invocan todas lasteardown_appcontextfunciones registradas
- Se envíarequest_tearing_downyappcontext_tearing_downla señal
- Se liberangtodos los datos almacenados en el objeto
Ejemplo
@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:
- full_dispatch_requestCapturar la excepción
- Llamarhandle_user_exceptionDeterminar el tipo de excepción
- Excepción HTTP (por ejemplo,abort(404)) → buscar el correspondienteerrorhandler
- Excepción normal → buscar el de la clase de excepciónerrorhandler
- No se encuentra un manejador → llamarhandle_exception, devolver error 500
- 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
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).
Otras extensionesDespué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。