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 :

Flask 请求处理生命周期

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

# Code source simplifié de Flask (emplacement réel : flask/app.py)
# 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

# Expérience simple pour comprendre le contexte
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

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

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 :

  1. Faire correspondre l'URL à la règle de route correspondante (Rule)
  2. Extraire les paramètres variables de l'URL (view_args)
  3. Appeler la fonction de vue correspondante en transmettant les paramètres extraits

Exemple

# Code source simplifié : flux de travail de dispatch_request
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

# Code source simplifié : workflow de finalize_request
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

# Utilisation typique de after_request : ajouter des en-têtes de sécurité à chaque réponse
@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 :

  1. appeler toutes lesteardown_requestfonctions enregistrées avec (exécutées indépendamment du succès ou de l'échec de la requête)
  2. appeler toutes lesteardown_appcontextfonctions enregistrées
  3. envoyerrequest_tearing_downetappcontext_tearing_downsignal
  4. libérergtoutes les données stockées dans l'objet

Exemple

# Utilisation typique du démontage : fermer la connexion à la base de données
@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 :

  1. full_dispatch_requestCapturer les exceptions
  2. Appelerhandle_user_exceptionpour déterminer le type d'exception
  3. Exceptions HTTP (telles queabort(404)) → trouver leerrorhandler correspondant
  4. exception normale → trouver l'errorhandler de la classe d'exception
  5. aucun gestionnaire trouvé → appelerhandle_exception, renvoyer une erreur 500
  6. 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

from flask import Flask, signals

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).

Aprè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。

autres extensions