FastAPI-Middleware
Middleware ist eine Funktion, die ausgeführt wird, bevor jede Anfrage den Route-Handler erreicht, und danach.
Middleware kann für allgemeine Logik wie das Hinzufügen von Logs, das Ändern von Anfragen/Antworten, die Behandlung von CORS usw. verwendet werden.
Wie Middleware funktioniert
Ausführungsablauf der Middleware:
- Anfrage erreicht Middleware
- Middleware führt Vorverarbeitungslogik aus
- Middleware übergibt die Anfrage an die nächste Middleware oder Route-Funktion.
- Route-Funktion gibt Antwort zurück
- Middleware führt Nachverarbeitungslogik aus
- Antwort wird an den Client zurückgegeben

| Name | Funktion |
|---|---|
| Client | Browser, Frontend-Apps, Postman usw. senden HTTP-Anfragen an FastAPI |
| Anfrage | HTTP-Anfrageobjekt, das Daten wie URL, Header, Body, Cookie enthält |
| Middleware 1 | Die erste Verarbeitungsebene, nachdem eine Anfrage eingeht |
| Middleware 2 | Verarbeitungslogik der zweiten Ebene |
| Middleware N | Mehrere Middlewares werden der Reihe nach ausgeführt |
| Route-Handler-Funktion (Pfadoperation) | Der Ort, an dem der Business-Code tatsächlich ausgeführt wird |
| Response-Phase | Nachdem die Route eine Response zurückgibt, durchläuft die Antwort erneut die Middleware. |
| Middleware gibt in umgekehrter Reihenfolge zurück | Antworten erfolgen in "umgekehrter Reihenfolge" |
| Response response | Die letztlich an den Client zurückgegebenen Daten |
Middleware erstellen
Nutzung@app.middleware("http")Middleware mit Dekoratoren erstellen:
Beispiel
from fastapi import FastAPI, Request
app = FastAPI()
@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
# 1. Vorverarbeitung der Anfrage: Startzeit aufzeichnen
start_time = time.time()
# 2. Anfrage an die nächste Middleware- oder Routenfunktion weiterleiten
response = await call_next(request)
# 3. Verarbeitung nach der Antwort: Verarbeitungszeit berechnen und Antwort-Header hinzufügen.
process_time = time.time() - start_time
response.headers["X-Process-Time"] = str(process_time)
return response
@app.get("/")
async def root():
return {"message": "Hello World"}
Code-Erklärung:
| Teil | Beschreibung |
|---|---|
@app.middleware("http") | Deklariere dies als HTTP-Middleware. |
request: Request | Aktuelles Anfrageobjekt |
call_next | Callback zum Aufrufen der nächsten Middleware- oder Routenfunktion. |
await call_next(request) | Die Anfrage an die nächste Ebene weiterleiten und die Antwort erhalten |
call_nextEmpfangenrequestParameter und Rückgaberesponse. Du kannst aufrufencall_nextÄndern Sie die Anfrage vor dem Aufruf und ändern Sie die Antwort nach dem Aufruf.
Middleware zur Anfrageprotokollierung
Die folgende Middleware protokolliert grundlegende Informationen zu jeder Anfrage:
Beispiel
import logging
from fastapi import FastAPI, Request
app = FastAPI()
logger = logging.getLogger("uvicorn.access")
@app.middleware("http")
async def log_requests(request: Request, call_next):
# Anfrageinformationen protokollieren
logger.info(fAnfrage: {request.method} {request.url})
start_time = time.time()
response = await call_next(request)
process_time = time.time() - start_time
# Antwortinformationen protokollieren
logger.info(
f"Antwort: {request.method} {request.url} "
fStatuscode={response.status_code} verstrichene Zeit={process_time:.3f}s
)
return response
Middleware-Ausführungsreihenfolge
Middleware wird in der Reihenfolge ihrer Registrierung ausgeführt; Anfragen durchlaufen Middleware in Vorwärtsrichtung und Antworten in umgekehrter Reihenfolge:
请求 -> 中间件A(前) -> 中间件B(前) -> 路由函数 响应 <- 中间件A(后) <- 中间件B(后) <- 路由函数
Die Reihenfolge der Middleware-Registrierung ist wichtig. Wenn Sie zwei Middleware A und B haben und A zuerst registrieren, durchläuft die Anfrage zuerst A, dann B, aber die Antwort durchläuft zuerst B, dann A.
Verwendung der in Starlette integrierten Middleware
FastAPI erbt von Starlette, daher kann die von Starlette bereitgestellte Middleware direkt verwendet werden:
Beispiel
from starlette.middleware.httpsredirect import HTTPSRedirectMiddleware
app = FastAPI()
# HTTPS-Weiterleitung erzwingen
app.add_middleware(HTTPSRedirectMiddleware)
@app.get("/")
async def root():
return {"message": Zugriff über HTTPS}
Gängige integrierte Middleware:
| Middleware | Beschreibung |
|---|---|
HTTPSRedirectMiddleware | HTTP-Anfragen zwangsweise auf HTTPS umleiten |
TrustedHostMiddleware | Erlaubte Hostnamen einschränken |
GZipMiddleware | Antwortinhalte automatisch komprimieren |
CORSMiddleware | Cross-Origin-Anfragen behandeln (ausführlich im nächsten Kapitel) |
GZip-Komprimierungs-Middleware
Das Aktivieren der GZip-Komprimierung kann die Antwortgröße reduzieren und die Übertragungsgeschwindigkeit verbessern:
Beispiel
from fastapi.middleware.gzip import GZipMiddleware
app = FastAPI()
# Automatisch komprimieren, wenn die Antwortgröße 1000 Bytes überschreitet
app.add_middleware(GZipMiddleware, minimum_size=1000)
@app.get("/")
async def root():
return {"message": "Diese Antwort kann GZip-komprimiert sein"}
Zusammenfassung
- Middleware führt gemeinsame Logik in der Request-/Response-Verarbeitungskette aus.
- Nutzung
@app.middleware("http")Benutzerdefinierte Middleware erstellen call_next(request)Die Anfrage an die nächste Schicht weitergeben- Middleware wird in der Reihenfolge der Registrierung ausgeführt (Anfragen in Vorwärtsreihenfolge, Antworten in umgekehrter Reihenfolge)
- FastAPI/Starlette bietet integrierte Middleware wie CORS, GZip, HTTPS-Umleitung usw.