Cycle de vie des requêtes Flask
Comprendre le cycle de vie complet d'une requête Flask est essentiel pour écrire de bonnes applications Flask.
Ce chapitre décompose tout le processus d'une requête HTTP depuis son entrée dans le serveur jusqu'au retour d'une réponse au niveau du code source, vous aidant à construire un modèle d'exécution clair.
Qu'est-ce que le cycle de vie d'une requête
Le cycle de vie d'une requête désigne le traitement complet qu'une requête HTTP subit à l'intérieur de Flask.
Il comprend les étapes suivantes :Recevoir la requête → Créer le contexte → Prétraiter → Répartir la route → Exécuter la vue → Construire la réponse → Nettoyer le contexte → Renvoyer la réponse。
En comprenant ce processus, vous pouvez répondre correctement aux questions suivantes :
- gQuand les données de l'objet deviennent-elles disponibles ? Quand sont-elles nettoyées ?
- before_requestetafter_requestQuel est l'ordre d'exécution ?
- Lorsqu'une exception se produit, par quelles étapes de traitement passe-t-elle successivement ?
- Pourquoi utiliser [it] en dehors de la fonction de vuerequestVa-t-il lever une erreur ?
Organigramme complet
Le diagramme suivant montre la chaîne d'appel complète depuis la réception d'une requête par Flask jusqu'au retour d'une réponse :
Explication détaillée étape par étape
Étape 1 : Entrée WSGI
Lorsqu'une requête HTTP arrive au serveur, le serveur WSGI (comme Gunicorn, le serveur de développement Werkzeug) appelle l'instance d'application Flask.
Flask implémente la méthode__call__, ce qui en fait une application WSGI valide :
Exemple
# Le serveur WSGI appellera votre application comme ceci :
# response = app(environ, start_response)
class Flask(App):
def __call__(self, environ, start_response):
"""Point d'entrée appelé par le serveur WSGI"""
return self.wsgi_app(environ, start_response)
def wsgi_app(self, environ, start_response):
"""La logique de traitement WSGI réelle"""
# Étape 1 : Créer un contexte de requête basé sur environ
ctx = self.request_context(environ)
try:
ctx.push() # Empiler sur la pile de contexte
response = self.full_dispatch_request(ctx) # Répartition complète
except Exception as e:
response = self.handle_exception(ctx, e) # Repli en cas d'exception
finally:
ctx.pop(error) # Dépiler le contexte et effectuer le nettoyage
return response(environ, start_response)
Flask conçoit le point d'entrée comme un appel à la méthodewsgi_app, plutôt que d'écrire directement la logique dans__call__. Ainsi, vous pouvez remplacerapp.wsgi_apppour insérer un middleware, sans affecterappqui appelle l'instance elle-même.
Étape 2 : Créer le contexte
request_context(environ)Créer unAppContextObjet basé sur les variables d'environnement WSGI.
Cet objet contient toutes les informations sur la requête en cours. Une fois qu'il est empilé,request、session、g、current_appces proxys globaux commencent à pointer vers les données de la requête en cours.
Exemple
from flask import Flask, request, current_app
app = Flask(__name__)
with app.app_context():
# Seul le contexte d'application est disponible — current_app est utilisable, request ne l'est pas.
print(current_app.name) # ✓ OK
# print(request.method) # ✗ Erreur : exécution en dehors du contexte de requête
with app.test_request_context("/hello?name=example"):
# Le contexte de requête inclut aussi le contexte d'application — les deux sont disponibles.
print(current_app.name) # ✓ Affiche le nom de l'application
print(request.path) # ✓ Affiche /hello
print(request.args["name"]) # ✓ Affiche example
| Type de contexte | Quand créé | Quand détruit | Variables globales disponibles |
|---|---|---|---|
| Contexte d'application | Lorsqu'une requête arrive / Manuellement avec app.app_context() | Fin de la requête / sortie du bloc with | current_app, g |
| Contexte de requête | Lorsqu'une requête arrive / manuellement avec app.test_request_context() | Fin de la requête / sortie du bloc with | request, session (toutes les variables dans le contexte d'application) |
L'erreur la plus courante que commettent les débutants est d'accéder directement au niveau du modulerequest. Rappelez-vous :requestn'existe que dans le contexte de requête. Vous ne pouvez y accéder qu'à l'intérieur des fonctions de vue (ou des fonctions qu'elles appellent).
Phase 3 : preprocess_request (Prétraitement)
Une fois le contexte prêt,full_dispatch_requestappelle d'abordpreprocess_request。
Cette étape exécute tout le code enregistré avec@app.before_requestfonctions enregistrées.
Si une fonctionbefore_requestrenvoie une valeur autre queNone, Flask la traite comme la réponse finale et ignore l'exécution des fonctions de vue suivantes.
Exemple
app = Flask(__name__)
app.secret_key = "dev-secret"
@app.before_request
def check_authentication():
"""Vérifie si l'utilisateur est connecté avant chaque requête"""
# Ignorer les vérifications d'authentification pour les pages de connexion et d'inscription
if request.endpoint in ("login", "register", "static"):
return None # None signifie continuer avec le flux normal
# Si l'utilisateur n'est pas connecté, renvoyer directement une réponse de redirection (ignorer la fonction de vue)
if "username" not in session:
return redirect(url_for("login"))
# L'utilisateur est connecté, continuer normalement
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 "Page d'inscription (aucune connexion requise)"
@app.route("/dashboard")
def dashboard():
return f"Bienvenue {session['username']} dans la console EXAMPLE"
Phase 4 : dispatch_request (Répartition des routes)
Une fois le prétraitement terminé, Flask entre dans l'étape centrale de répartition :
- Faire correspondre l'URL à la règle de route correspondante (Rule)
- Extraire les paramètres variables de l'URL (view_args)
- Appeler la fonction de vue correspondante en transmettant les paramètres extraits
Exemple
def dispatch_request(self, ctx):
req = ctx.request
# Récupère la règle de routage correspondante (objet Rule)
rule = req.url_rule
# Récupère les paramètres variables depuis l'URL. Par exemple /post/42 → {"post_id": 42}
view_args = req.view_args
# Trouve la fonction correspondante dans le dictionnaire view_functions et appelle-la
return self.view_functions[rule.endpoint](**view_args)
Lorsque la correspondance échoue, cela lèveRoutingException, et c'est finalement intercepté par le gestionnaire d'erreurs et renvoie 404.
Étape 5 : Exécution de la fonction de vue
C'est ici que vous écrivez votre logique métier. Flask appelle votre fonction de vue et obtient la valeur de retour.
La valeur de retour peut être de nombreux types — chaînes de caractères, dictionnaires, tuples, objets Response — tous traités de manière uniforme à l'étape suivante.
Phase 6 : finalize_request (Construction de la Response)
Après que la fonction de vue a terminé son exécution,finalize_requestest chargé de convertir la valeur de retour en uneResponsestandard :
Exemple
def finalize_request(self, ctx, rv):
# 1. Appeler make_response pour convertir différents types de valeurs de retour en objets Response
response = self.make_response(rv)
# 2. Exécuter les hooks after_request via process_response
response = self.process_response(ctx, response)
# 3. Envoi du signal : request_finished
request_finished.send(self, response=response)
return response
make_responserègles de conversion :
| Type de valeur de retour | Méthode de conversion |
|---|---|
| str / bytes | Comme corps de réponse, Content-Type: text/html |
| dict / list | Appeler jsonify(), Content-Type: application/json |
| tuple | Interprété comme (body, status) ou (body, headers) |
| Objet Response | Utilisé directement |
| iterator / generator | en tant que réponse en streaming |
Phase 7 : hook after_request
process_responsePendant l'exécutionmake_responseEnsuite, il appelle toutes les@app.after_requestfonctions enregistrées.
chaqueafter_requestfonction reçoit et renvoie un objetResponse, vous pouvez modifier les en-têtes de réponse, ajouter des cookies, etc.
Exemple
@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 # Doit renvoyer un objet de réponse
# Également couramment utilisé pour ajouter des en-têtes 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
Étape 8 : Nettoyage du contexte
Après l'envoi de la réponse,enfindans le blocctx.pop()Effectuer le nettoyage du contexte :
- appeler toutes lesteardown_requestfonctions enregistrées avec (exécutées indépendamment du succès ou de l'échec de la requête)
- appeler toutes lesteardown_appcontextfonctions enregistrées
- envoyerrequest_tearing_downetappcontext_tearing_downsignal
- libérergtoutes les données stockées dans l'objet
Exemple
@app.teardown_appcontext
def close_database_connection(error):
"""S'assurer que la connexion à la base de données est fermée même si la requête échoue"""
db = g.pop("db", None)
if db is not None:
db.close()
# paramètre error : si une exception se produit pendant la requête, elle sera reçue ici
if error:
app.logger.warning(f"Exception de requête, connexion à la base de données fermée : {error}")
# Différence entre teardown et after_request
@app.after_request
def after(response):
# after_request s'exécute dans le flux normal, pas en cas d'exception
# Utilisé pour modifier les réponses réussies
return response
@app.teardown_request
def teardown(error):
# teardown s'exécute toujours — que la requête réussisse ou échoue
# Utilisé pour nettoyer les ressources (fermer des fichiers, libérer des verrous, etc.)
pass
flux de gestion des exceptions
Lorsqu'une fonction de vue lève une exception, Flask dispose d'un chemin dédié à la gestion des exceptions :
- full_dispatch_requestCapturer les exceptions
- Appelerhandle_user_exceptionpour déterminer le type d'exception
- Exceptions HTTP (telles queabort(404)) → trouver leerrorhandler correspondant
- exception normale → trouver l'errorhandler de la classe d'exception
- aucun gestionnaire trouvé → appelerhandle_exception, renvoyer une erreur 500
- Indépendamment des exceptions, il finira par passer parfinalize_requestpour construire la réponse
Points clés du chemin d'exception :after_requestLes hooks s'exécutent aussi pour les réponses d'erreur (depuis Flask 1.1), maisbefore_requestUne valeur non None renvoyée par celui-ci court-circuite tout le flux ; les fonctions de vue et les hooks suivants ne s'exécuteront pas.
Référence rapide des fonctions de hook
| Hook | Méthode d'inscription | Moment d'exécution | Utilisation typique |
|---|---|---|---|
| before_request | @app.before_request | avant la distribution de la route | vérifications de connexion, journaux de requêtes, vérification des permissions |
| before_first_request | @app.before_request (obsolète) | Avant la première requête (une seule fois) | Opérations d'initialisation (il est recommandé d'utiliser plutôt le patron de fabrique) |
| after_request | @app.after_request | Une fois la réponse construite, avant l'envoi | Ajouter des en-têtes de réponse, CORS, journaux |
| teardown_request | @app.teardown_request | Lorsque le contexte de requête est dépilé (toujours exécuté) | Libérer les ressources, fermer les fichiers |
| teardown_appcontext | @app.teardown_appcontext | Lorsque le contexte d'application est dépilé (toujours exécuté) | Fermer les connexions à la base de données, vider le cache |
| errorhandler | @app.errorhandler(code) | Lorsque le code d'erreur/l'exception correspondant(e) se produit | pages d'erreur personnalisées |
Événement signal
Flask utiliseblinkerLa bibliothèque envoie des signaux à des points clés :
Exemple
app = Flask(__name__)
# Connecter le signal — enregistrer quand la requête arrive
@signals.request_started.connect_via(app)
def log_request_start(sender, **extra):
print("Requête démarrée")
# Connecter le signal — enregistrer quand la requête se termine
@signals.request_finished.connect_via(app)
def log_request_end(sender, response, **extra):
print(f"Requête terminée, code d'état de la réponse : {response.status_code}")
# Connecter le signal — intercepter les exceptions
@signals.got_request_exception.connect_via(app)
def log_exception(sender, exception, **extra):
print(f"Une exception s'est produite lors de la requête : {exception}")
| signal | Moment du déclenchement |
|---|---|
| request_started | Après l'établissement du contexte de requête, avant le prétraitement |
| request_finished | Une fois la construction de la réponse terminée, avant l'envoi |
| got_request_exception | Lorsqu'une exception se produit pendant le traitement de la requête |
| request_tearing_down | Lorsque le contexte de requête est détruit |
| appcontext_pushed | Lorsque le contexte d'application est empilé sur la pile |
| appcontext_popped | Lorsque le contexte d'application est dépilé de la pile |
| message_flashed | lors de l'appel de flash() |
| template_rendered | lorsque le rendu du template réussit |
résumé des points clés
Règles fondamentales: Dans un cycle de vie complet d'une requête,before_request → Fonction de vue → after_request → teardownCes quatre nœuds sont garantis d'être exécutés dans l'ordre (teardown s'exécute toujours, peu importe si les trois premiers échouent).
autres extensionsAprès avoir compris le cycle de vie des requêtes, lorsque vous écrivez des applications Flask, vous saurez : placer la logique d'authentification dansbefore_request, placer la logique métier dans les fonctions de vue, et placer la modification des en-têtes de réponse dansafter_requestplacer le nettoyage des ressources dansteardown。