Implementering af WebSockets i FastAPI
Lær at tilføje WebSocket-endpoints til Deres FastAPI-applikation og håndtere forbindelser.
Implementering af WebSockets i FastAPI er en gratis Bootcamp i FastAPI-backendudvikling-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Bootcamp i FastAPI-backendudvikling, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i FastAPI-backendudvikling-kurset indeholder 4 lektioner i alt.
Realtid med FastAPI WebSockets
Velkommen til implementering af WebSockets med FastAPI! WebSockets giver en vedvarende, fuld-dupleks-kommunikationskanal mellem en klient og en server.
- Fuld dupleks: Både klienten og serveren kan sende og modtage beskeder samtidigt.
- Realtid: Ideelt til programmer, der har brug for øjeblikkelige opdateringer, f.eks. chat, live-dashboards eller spil.
FastAPI har fremragende indbygget understøttelse af WebSockets og udnytter Pythons async/await-funktioner.
Definition af et WebSocket-slutpunkt
Ligesom med HTTP-slutpunkter definerer du WebSocket-slutpunkter ved hjælp af en dekorator. I stedet for @app.get() eller @app.post() bruger du @app.websocket().
Din slutpunktsfunktion skal være async def og acceptere en parameter af typen websocket: WebSocket. Dette WebSocket-objekt er dit primære værktøj til interaktion.
Det første trin i din funktion er altid at kalde await websocket.accept() for at oprette forbindelsen.
Din første WebSocket-forbindelse
Lad os oprette vores første WebSocket-slutpunkt. Dette enkle eksempel accepterer en forbindelse, sender en velkomstbesked og lukker derefter forbindelsen.
Bemærk dekoratoren @app.websocket("/ws") og funktionen async def, som er afgørende for håndtering af WebSockets.
Prøv at køre dette eksempel, og observer forbindelsen:
from fastapi import FastAPI, WebSocket
app = FastAPI()
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
await websocket.accept()
await websocket.send_text("Welcome! Connection established.")
await websocket.close()Håndtering af afbrudte WebSocket-forbindelser
WebSocket-forbindelser kan blive afbrudt af forskellige årsager, f.eks. hvis klienten lukker fanen, eller der opstår en netværksfejl. Det er afgørende at håndtere disse afbrydelser på en robust måde.
FastAPI udløser en WebSocketDisconnect-undtagelse, når en klient afbryder forbindelsen. Du kan fange denne undtagelse for at udføre oprydningsopgaver, f.eks. fjerne klienten fra en liste over aktive forbindelser.
Pak din logik til WebSocket-kommunikation ind i en try...except WebSocketDisconnect-blok.
Modtagelse af beskeder fra klienter
Når forbindelsen er oprettet, kan din server modtage beskeder fra klienten. WebSocket-objektet indeholder metoder til dette:
await websocket.receive_text(): Til modtagelse af tekstdata.await websocket.receive_bytes(): Til modtagelse af binære data.await websocket.receive_json(): Til modtagelse af JSON-data (kræverpython-multipart).
Disse handlinger er asynkrone, så brug altid await.
Afsendelse af klientbeskeder retur
Dette eksempel demonstrerer en simpel ekko-server. Den accepterer en forbindelse, modtager løbende beskeder fra klienten og sender dem tilbage.
Løkken while True holder forbindelsen åben, og try...except WebSocketDisconnect håndterer situationen, hvor klienten forlader forbindelsen.
from fastapi import FastAPI, WebSocket, WebSocketDisconnect
app = FastAPI()
@app.websocket("/ws/echo")
async def websocket_echo(websocket: WebSocket):
await websocket.accept()
try:
while True:
data = await websocket.receive_text()
print(f"Received from client: {data}")
await websocket.send_text(f"Server echoed: {data}")
except WebSocketDisconnect:
print("Client disconnected.")Afsendelse af beskeder til klienter
På samme måde kan din server sende beskeder til klienten. WebSocket-objektet tilbyder:
await websocket.send_text("your message"): Til afsendelse af tekstdata.await websocket.send_bytes(b"your bytes"): Til afsendelse af binære data.await websocket.send_json({"key": "value"}): Til afsendelse af JSON-data.
Husk at bruge await med disse kald. Det er almindeligt at sende et svar lige efter modtagelsen af en besked.
Arbejde med JSON-data
Til strukturerede data foretrækkes det at sende og modtage JSON. FastAPIs WebSocket-objekt håndterer serialisering og deserialisering for dig.
- Afsendelse: Send en Python-
dicttilsend_json(). - Modtagelse:
receive_json()returnerer en Python-dict.
Det gør dataudvekslingen enklere end manuel fortolkning af tekststrenge.
Enkel forbindelsesadministrator
Hvis dit program har flere klienter, skal du administrere de aktive forbindelser. Et almindeligt mønster er at bruge en klasse til at holde styr på alle tilsluttede WebSocket-objekter.
Denne administrator kan derefter bruges til at tilføje og fjerne forbindelser samt sende beskeder til bestemte klienter eller udsende dem til alle.
from fastapi import WebSocket
class ConnectionManager:
def __init__(self):
self.active_connections: list[WebSocket] = []
async def connect(self, websocket: WebSocket):
await websocket.accept()
self.active_connections.append(websocket)
def disconnect(self, websocket: WebSocket):
self.active_connections.remove(websocket)
async def send_personal_message(self, message: str, websocket: WebSocket):
await websocket.send_text(message)
# In a real app, you'd integrate 'manager' into your FastAPI endpoint
manager = ConnectionManager()Kontrol af WebSocket-interaktion
Du har lært det grundlæggende i at oprette og interagere med WebSocket-forbindelser i FastAPI.
Lad os kontrollere, om du har forstået, hvordan nye forbindelser accepteres.
Opsummering: Implementering af WebSockets
Du har nu lært at implementere WebSockets i FastAPI!
- Brug
@app.websocket()til at definere slutpunkter. - Brug altid
await websocket.accept()til at oprette forbindelsen. - Håndter afbrydelser med
try...except WebSocketDisconnect. - Brug
await websocket.receive_text()ogawait websocket.send_text()til kommunikation. - Til strukturerede data er
send_json()ogreceive_json()nyttige.
Nu skal du bygge et chatprogram i realtid for at omsætte disse begreber til praksis!
Lær Bootcamp i FastAPI-backendudvikling med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 21
- Lektioner
- 84
Ofte stillede spørgsmål
Er lektionen “Implementering af WebSockets i FastAPI” gratis?
Ja — alle 3 lektioner i læringssporet Bootcamp i FastAPI-backendudvikling, inklusive “Implementering af WebSockets i FastAPI”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Bootcamp i FastAPI-backendudvikling-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Implementering af WebSockets i FastAPI”?
Lær at tilføje WebSocket-endpoints til Deres FastAPI-applikation og håndtere forbindelser. Du øver dig i Bootcamp i FastAPI-backendudvikling med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Bootcamp i FastAPI-backendudvikling?
Der kræves ingen tidligere erfaring. Bootcamp i FastAPI-backendudvikling på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “Implementering af WebSockets i FastAPI”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Bootcamp i FastAPI-backendudvikling-lektion?
Ja. Alle Bootcamp i FastAPI-backendudvikling-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Grundlæggende WebSocket-protokol
- Implementering af WebSockets i FastAPI
- Opbygning af en chatapplikation i realtid
- Skalering af WebSockets med en Pub/Sub-backplane