Flask-Anfrage-Lebenszyklus
Das Verständnis des vollständigen Lebenszyklus einer Flask-Anfrage ist der Schlüssel zum Schreiben guter Flask-Anwendungen.
Dieses Kapitel zerlegt den gesamten Prozess einer HTTP-Anfrage vom Eintreffen am Server bis zur Rückgabe einer Antwort auf Quellcodeebene und hilft Ihnen, ein klares Ausführungsmodell aufzubauen.
Was ist der Request-Lebenszyklus
Der Request-Lebenszyklus bezeichnet die vollständige Verarbeitung, die eine HTTP-Anfrage innerhalb von Flask durchläuft.
Er umfasst die folgenden Phasen:Anfrage empfangen → Kontext erstellen → Vorverarbeiten → Route-Dispatch → View ausführen → Antwort aufbauen → Kontext bereinigen → Antwort zurückgeben。
Wenn Sie diesen Prozess verstehen, können Sie die folgenden Fragen richtig beantworten:
- gWann werden die Daten des Objekts verfügbar? Wann werden sie bereinigt?
- before_requestundafter_requestWie ist die Ausführungsreihenfolge?
- Wenn eine Ausnahme auftritt, welche Verarbeitungsphasen durchläuft sie nacheinander?
- Warum verwendet man [es] außerhalb der View-FunktionrequestWird dadurch ein Fehler ausgelöst?
Vollständiges Flussdiagramm
Das folgende Diagramm zeigt die vollständige Aufrufkette vom Empfang einer Anfrage durch Flask bis zur Rückgabe einer Antwort:
Detaillierte Schritt-für-Schritt-Erklärung
Stufe 1: WSGI-Einstieg
Wenn eine HTTP-Anfrage am Server eintrifft, ruft der WSGI-Server (z. B. Gunicorn, Werkzeug-Entwicklungsserver) die Flask-Anwendungsinstanz auf.
Flask implementiert die__call__-Methode und macht es damit zu einer gültigen WSGI-Anwendung:
Beispiel
# Der WSGI-Server ruft Ihre Anwendung folgendermaßen auf:
# response = app(environ, start_response)
class Flask(App):
def __call__(self, environ, start_response):
"""Vom WSGI-Server aufgerufener Einstiegspunkt"""
return self.wsgi_app(environ, start_response)
def wsgi_app(self, environ, start_response):
"""Die tatsächliche WSGI-Verarbeitungslogik"""
# Schritt 1: Anfragekontext basierend auf environ erstellen
ctx = self.request_context(environ)
try:
ctx.push() # Auf den Kontextstapel legen
response = self.full_dispatch_request(ctx) # Vollständiger Dispatch
except Exception as e:
response = self.handle_exception(ctx, e) # Ausnahme-Fallback
finally:
ctx.pop(error) # Kontext entfernen und Aufräumen durchführen
return response(environ, start_response)
Flask gestaltet den Einstiegspunkt so, dass die Methodewsgi_appaufgerufen wird, anstatt die Logik direkt in__call__zu schreiben. Auf diese Weise können Sieapp.wsgi_app ersetzenum Middleware einzufügen, ohne das Aufrufen der Instanz durchappselbst zu beeinflussen.
Phase 2: Kontext erstellen
request_context(environ)Erstellen Sie anhand der WSGI-Umgebungsvariablen einAppContext-Objekt.
Dieses Objekt enthält alle Informationen über die aktuelle Anfrage. Sobald es auf den Stapel gelegt wurde, beginnenrequest、session、g、current_appdiese globalen Proxys, auf die Daten der aktuellen Anfrage zu verweisen.
Beispiel
from flask import Flask, request, current_app
app = Flask(__name__)
with app.app_context():
# Nur der Anwendungskontext ist verfügbar — current_app ist nutzbar, request hingegen nicht.
print(current_app.name) # ✓ OK
# print(request.method) # ✗ Fehler: Arbeiten außerhalb des Anfragekontexts
with app.test_request_context("/hello?name=example"):
# Der Anfragekontext enthält auch den Anwendungskontext — beide sind verfügbar.
print(current_app.name) # ✓ Gibt App-Namen aus
print(request.path) # ✓ Gibt /hello aus
print(request.args["name"]) # ✓ Gibt example aus
| Kontexttyp | Wann erstellt | Wann zerstört | Verfügbare globale Variablen |
|---|---|---|---|
| Anwendungskontext | Wenn eine Anfrage eintrifft / Manuell mit app.app_context() | Ende der Anfrage / Verlassen des with-Blocks | current_app, g |
| Anfragekontext | Wenn eine Anfrage eintrifft / manuell mit app.test_request_context() | Ende der Anfrage / Verlassen des with-Blocks | request, session (alle Variablen im Anwendungskontext) |
Der häufigste Fehler, den Anfänger machen, ist der direkte Zugriff auf Modulebene aufrequest. Denken Sie daran:requestEs existiert nur innerhalb des Anfragekontexts. Sie können nur innerhalb von View-Funktionen (oder von ihnen aufgerufenen Funktionen) darauf zugreifen.
Phase 3: preprocess_request (Vorverarbeitung)
Sobald der Kontext bereit ist,full_dispatch_requestruft zuerstpreprocess_request auf。
In dieser Phase wird der gesamte Code ausgeführt, der mit den durch@app.before_requestregistrierten Funktionen registriert wurde.
Wenn eine beliebigebefore_request-Funktion einen Nicht-None-Wert zurückgibt, behandelt Flask sie als endgültige Antwort und überspringt die Ausführung nachfolgender View-Funktionen.
Beispiel
app = Flask(__name__)
app.secret_key = "dev-secret"
@app.before_request
def check_authentication():
"""Prüfen, ob der Benutzer vor jeder Anfrage angemeldet ist"""
# Authentifizierungsprüfungen für Anmelde- und Registrierungsseiten überspringen
if request.endpoint in ("login", "register", "static"):
return None # None bedeutet, mit dem normalen Ablauf fortzufahren
# Wenn nicht angemeldet, direkt eine Weiterleitungsantwort zurückgeben (die View-Funktion überspringen)
if "username" not in session:
return redirect(url_for("login"))
# Benutzer ist angemeldet, normal fortfahren
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 "Registrierungsseite (keine Anmeldung erforderlich)"
@app.route("/dashboard")
def dashboard():
return f"Willkommen {session['username']} in der EXAMPLE-Konsole"
Phase 4: dispatch_request (Routenverteilung)
Nachdem die Vorverarbeitung abgeschlossen ist, tritt Flask in die zentrale Dispatch-Phase ein:
- URL mit der entsprechenden Routenregel abgleichen (Rule)
- Variablenparameter aus der URL extrahieren (view_args)
- Die entsprechende View-Funktion aufrufen und die extrahierten Parameter übergeben
Beispiel
def dispatch_request(self, ctx):
req = ctx.request
# Die passende Routing-Regel abrufen (Rule-Objekt)
rule = req.url_rule
# Variablenparameter aus der URL abrufen. Zum Beispiel /post/42 → {"post_id": 42}
view_args = req.view_args
# Die entsprechende Funktion im view_functions-Wörterbuch finden und aufrufen
return self.view_functions[rule.endpoint](**view_args)
Wenn der Abgleich fehlschlägt, wirdRoutingException, und sie wird schließlich vom Fehlerhandler abgefangen und gibt 404 zurück.
Phase 5: Ausführung der View-Funktion
Hier schreiben Sie Ihre Geschäftslogik. Flask ruft Ihre View-Funktion auf und erhält den Rückgabewert.
Der Rückgabewert kann von vielen Typen sein—Strings, Dicts, Tupel, Response-Objekte—die alle in der nächsten Phase einheitlich behandelt werden.
Phase 6: finalize_request (Response-Konstruktion)
Nachdem die View-Funktion die Ausführung beendet hat,finalize_requestdafür verantwortlich, den Rückgabewert in ein Standard-ResponseObjekt umzuwandeln:
Beispiel
def finalize_request(self, ctx, rv):
# 1. make_response aufrufen, um verschiedene Arten von Rückgabewerten in Response-Objekte umzuwandeln
response = self.make_response(rv)
# 2. after_request-Hooks über process_response ausführen
response = self.process_response(ctx, response)
# 3. Signal senden: request_finished
request_finished.send(self, response=response)
return response
make_responseKonvertierungsregeln:
| Rückgabetyp | Konvertierungsmethode |
|---|---|
| str / bytes | Als Antwortkörper, Content-Type: text/html |
| dict / list | jsonify() aufrufen, Content-Type: application/json |
| tuple | Wird als (body, status) oder (body, headers) interpretiert |
| Response-Objekt | Direkt verwendet |
| iterator / generator | als Streaming-Antwort |
Phase 7: after_request-Hook
process_responseWährend der Ausführungmake_responseDanach ruft es alle registrierten@app.after_requestregistrierten Funktionen.
jedeafter_request-Funktion empfängt und gibt einResponse-Objekt zurück, du kannst Response-Header ändern, Cookies hinzufügen und so weiter.
Beispiel
@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 # Muss ein Response-Objekt zurückgeben
# Wird auch häufig verwendet, um CORS-Header hinzuzufügen
@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
Phase 8: Kontextbereinigung
Nachdem die Antwort gesendet wurde,finallyim Blockctx.pop()Kontextbereinigung durchführen:
- alle Funktionen aufrufen, die mitteardown_requestregistriert wurden (werden unabhängig vom Erfolg oder Fehlschlag der Anfrage ausgeführt)
- alle mitteardown_appcontextregistrierten Funktionen aufrufen
- Signalrequest_tearing_downundappcontext_tearing_downsenden
- freigebengalle im Objekt gespeicherten Daten
Beispiel
@app.teardown_appcontext
def close_database_connection(error):
"""Stelle sicher, dass die Datenbankverbindung geschlossen wird, auch wenn die Anfrage fehlschlägt"""
db = g.pop("db", None)
if db is not None:
db.close()
# error-Parameter: Wenn während der Anfrage eine Ausnahme auftritt, wird sie hier empfangen
if error:
app.logger.warning(f"Anfrageausnahme, Datenbankverbindung geschlossen: {error}")
# Unterschied zwischen teardown und after_request
@app.after_request
def after(response):
# after_request läuft im normalen Ablauf, nicht, wenn eine Ausnahme auftritt
# Wird verwendet, um erfolgreiche Antworten zu ändern
return response
@app.teardown_request
def teardown(error):
# teardown wird immer ausgeführt — ob die Anfrage erfolgreich ist oder fehlschlägt
# Wird verwendet, um Ressourcen aufzuräumen (Dateien schließen, Sperren freigeben usw.)
pass
Ablauf der Ausnahmebehandlung
Wenn eine View-Funktion eine Ausnahme auslöst, hat Flask einen eigenen Pfad zur Ausnahmebehandlung:
- full_dispatch_requestAusnahmen abfangen
- Rufehandle_user_exceptionauf, um den Ausnahmetyp zu bestimmen
- HTTP-Ausnahmen (wieabort(404)) → finde den entsprechendenerrorhandler
- normale Ausnahme → denerrorhandler der Ausnahmeklasse finden
- kein Handler gefunden →handle_exceptionaufrufen, einen 500-Fehler zurückgeben
- Unabhängig von Ausnahmen wird es letztendlichfinalize_requestdurchlaufen, um die Antwort zu erstellen
Wichtige Punkte im Ausnahmepfad:after_requestHooks werden auch für Fehlerantworten ausgeführt (seit Flask 1.1), aberbefore_requestEin davon zurückgegebener Non-None-Wert unterbricht den gesamten Ablauf; nachfolgende View-Funktionen und Hooks werden nicht ausgeführt.
Kurzübersicht der Hook-Funktionen
| Hook | Registrierungsmethode | Ausführungszeitpunkt | Typische Verwendung |
|---|---|---|---|
| before_request | @app.before_request | vor dem Routen-Dispatch | Login-Prüfungen, Request-Logs, Berechtigungsüberprüfung |
| before_first_request | @app.before_request (veraltet) | Vor der ersten Anfrage (nur einmal) | Initialisierungsvorgänge (es wird empfohlen, stattdessen das Factory-Muster zu verwenden) |
| after_request | @app.after_request | Nachdem die Antwort erstellt wurde, vor dem Senden | Antwort-Header hinzufügen, CORS, Logs |
| teardown_request | @app.teardown_request | Wenn der Request-Kontext entfernt wird (wird immer ausgeführt) | Ressourcen freigeben, Dateien schließen |
| teardown_appcontext | @app.teardown_appcontext | Wenn der Anwendungskontext entfernt wird (wird immer ausgeführt) | Datenbankverbindungen schließen, Cache leeren |
| errorhandler | @app.errorhandler(code) | Wenn der entsprechende Fehlercode/die entsprechende Ausnahme auftritt | benutzerdefinierte Fehlerseiten |
Signalereignis
Flask verwendetblinkerDie Bibliothek sendet Signale an wichtigen Punkten:
Beispiel
app = Flask(__name__)
# Signal verbinden — aufzeichnen, wenn die Anfrage eintrifft
@signals.request_started.connect_via(app)
def log_request_start(sender, **extra):
print("Request started")
# Signal verbinden — aufzeichnen, wenn die Anfrage abgeschlossen ist
@signals.request_finished.connect_via(app)
def log_request_end(sender, response, **extra):
print(f"Request finished, response status code: {response.status_code}")
# Signal verbinden — Ausnahmen abfangen
@signals.got_request_exception.connect_via(app)
def log_exception(sender, exception, **extra):
print(f"Während der Anfrage ist eine Ausnahme aufgetreten: {exception}")
| signal | Auslösezeitpunkt |
|---|---|
| request_started | Nachdem der Anfragekontext eingerichtet wurde, vor der Vorverarbeitung |
| request_finished | Nachdem die Antwort erstellt wurde, vor dem Senden |
| got_request_exception | Wenn während der Verarbeitung der Anfrage eine Ausnahme auftritt |
| request_tearing_down | Wenn der Anfragekontext zerstört wird |
| appcontext_pushed | Wenn der Anwendungskontext auf den Stack gelegt wird |
| appcontext_popped | Wenn der Anwendungskontext vom Stack entfernt wird |
| message_flashed | beim Aufruf von flash() |
| template_rendered | wenn das Rendern des Templates erfolgreich ist |
Zusammenfassung der wichtigsten Punkte
Kernregeln: In einem vollständigen Request-Lebenszyklus,before_request → View-Funktion → after_request → teardownDiese vier Knoten werden garantiert in der Reihenfolge ausgeführt (teardown wird immer ausgeführt, unabhängig davon, ob die ersten drei fehlschlagen).
Weitere ErweiterungenNach dem Verständnis des Request-Lebenszyklus wissen Sie beim Schreiben von Flask-Anwendungen: Authentifizierungslogik inbefore_request, Geschäftslogik in View-Funktionen legen und das Ändern von Response-Headern inafter_request legenRessourcenbereinigung inteardown legen。