Memahami WebSockets menggunakan Python-Tutorial Python-php.cn

Understanding WebSockets using Python

Einführung

In der heutigen digitalen Landschaft, in der Echtzeitkommunikation wichtig ist. Herkömmliches HTTP ist aufgrund seines Anfrage-Antwort-Modells und der inhärenten Latenz unzureichend. Da Unternehmen und Anwendungen zunehmend eine sofortige Datenübertragung fordern – sei es bei Live-Aktualisierungen von Aktien, Multiplayer-Spielen oder Tools für die Zusammenarbeit – haben sich WebSockets zu einer bahnbrechenden Technologie entwickelt. Im Gegensatz zu HTTP ermöglichen WebSockets eine bidirektionale Vollduplex-Kommunikation, sodass sowohl der Server als auch der Client Nachrichten in Echtzeit über eine einzige, dauerhafte Verbindung senden und empfangen können. Dies reduziert nicht nur den Overhead, sondern verbessert auch die Leistung und Reaktionsfähigkeit von Webanwendungen erheblich.

Was ist WebSocket

WebSocket ist ein Kommunikationsprotokoll, das Vollduplex-Kommunikationskanäle über eine einzige, langlebige TCP-Verbindung bereitstellt. Dies bedeutet, dass, sobald eine WebSocket-Verbindung zwischen einem Client und einem Server hergestellt ist, beide Parteien gleichzeitig und kontinuierlich Daten senden und empfangen können, ohne dass eine Verbindung erneut geöffnet werden muss. WebSocket wurde so konzipiert, dass es effizient und mit geringer Latenz ist und sich daher ideal für Echtzeitanwendungen eignet.

Warum WebSocket?

WebSockets werden in Szenarien verwendet, in denen Echtzeitkommunikation zwischen einem Client und einem Server erforderlich ist. Im Gegensatz zu herkömmlichem HTTP, das einem Anfrage-Antwort-Modell folgt, bei dem der Client jede Anfrage initiieren muss, ermöglichen WebSockets eine bidirektionale Kommunikation. Dies macht WebSockets besonders nützlich in Anwendungen, bei denen Daten in Echtzeit vom Server an den Client übertragen werden müssen, ohne dass der Client dies anfordern muss.

Anwendungsfälle aus der realen Welt

Chat-Anwendungen: WebSockets werden häufig in Chat-Anwendungen verwendet, bei denen Nachrichten ohne Verzögerung in Echtzeit gesendet und empfangen werden müssen.
Live-Streaming: WebSockets können zum Streamen von Live-Video oder -Audio verwendet werden, sodass der Server neue Inhalte an den Client senden kann, sobald diese verfügbar sind.
Kollaborative Plattformen: In kollaborativen Tools wie Google Docs ermöglichen WebSockets mehreren Benutzern, von anderen vorgenommene Änderungen in Echtzeit zu sehen, ohne dass die Seite aktualisiert werden muss.

WebSockets vs. HTTP

Kommunikationsmodell

HTTP: Folgt einem Anfrage-Antwort-Modell, bei dem der Client eine Anfrage initiiert und der Server antwortet. Nach der Antwort wird die Verbindung geschlossen.
WebSockets: WebSockets bieten eine langlebige Vollduplex-Verbindung, bei der sowohl der Client als auch der Server kontinuierlich Daten senden und empfangen können, ohne die Verbindung jedes Mal neu öffnen zu müssen.

Verbindungsverwaltung

HTTP: Jede Anfrage öffnet eine neue Verbindung und die Verbindung wird nach der Antwort geschlossen.
WebSockets: Nach dem ersten Handshake (über HTTP) bleibt die Verbindung offen und ermöglicht so eine Kommunikation in Echtzeit, ohne dass Verbindungen erneut hergestellt werden müssen.

Effizienz

HTTP: Geeignet für einmalige Kommunikation oder Transaktionen, bei denen selten Anfragen gestellt werden. Es ist zustandslos, daher werden für die kontinuierliche Kommunikation Techniken wie Long-Polling verwendet, die ressourcenintensiv sein können.
WebSockets: WebSockets sind effizient für Echtzeit- und bidirektionale Kommunikation, da die Verbindung offen gehalten wird. Sie verbrauchen weniger Ressourcen im Vergleich zu Techniken wie Long-Polling.

Latenz

HTTP: Es gibt immer eine Verzögerung (Latenz), da der Client eine Anfrage stellen und der Server antworten muss. Dies ist für Echtzeit-Anwendungsfälle ineffizient.
WebSockets: Nachdem die Verbindung hergestellt wurde, können Daten fast sofort zwischen Client und Server fließen, was die Latenz reduziert und es ideal für Echtzeitanwendungen macht.

Anwendungsfall

HTTP: Am besten geeignet für herkömmliche Webanwendungen, bei denen Anforderungen vom Client initiiert werden (z. B. REST-APIs).
WebSockets: Ideal für Echtzeitanwendungen wie Chat-Apps, Aktienhandelsplattformen, Live-Dashboards und Online-Spiele.

Vorteile von WebSockets

Komunikasi Masa Nyata: WebSockets membenarkan komunikasi masa nyata, kependaman rendah, menjadikannya sesuai untuk aplikasi yang memerlukan kemas kini segera.
Aliran Data Dwi Arah: Kedua-dua pelanggan dan pelayan boleh menghantar dan menerima data pada bila-bila masa, tidak seperti HTTP di mana pelayan hanya boleh membalas permintaan yang dimulakan oleh klien.
Penurunan Overhed: Dengan mengekalkan sambungan terbuka, WebSockets mengurangkan keperluan untuk berulang kali mewujudkan sambungan HTTP baharu, menjimatkan lebar jalur dan mengurangkan kependaman.
Kecekapan: WebSockets menggunakan lebih sedikit sumber berbanding dengan tinjauan panjang atau permintaan HTTP untuk pemindahan data berterusan.
Skalabiliti: WebSockets boleh mengendalikan banyak sambungan serentak dengan cekap, menjadikannya sesuai untuk aplikasi masa nyata boleh skala.

Cara WebSockets Berfungsi

Berjabat tangan: Sambungan WebSocket bermula dengan jabat tangan HTTP. Pelanggan menghantar permintaan kepada pelayan dengan pengepala Naik Taraf untuk menukar protokol sambungan daripada HTTP kepada WebSocket.
Sambungan Diwujudkan: Selepas berjabat tangan, sambungan diwujudkan. Pelayan dan pelanggan mengekalkan sambungan TCP terbuka yang berterusan.
Komunikasi Dupleks Penuh: Setelah sambungan WebSocket dibuka, data boleh dihantar berulang-alik secara serentak. Kedua-dua pelayan dan pelanggan boleh memulakan komunikasi pada bila-bila masa.
Tutup Sambungan: Sama ada pelayan atau klien boleh menutup sambungan apabila ia tidak diperlukan lagi. Ini menamatkan sesi dan mengeluarkan sumber.

Kes Guna untuk WebSoket

Aplikasi Sembang: Perkhidmatan pemesejan segera seperti WhatsApp dan Slack menggunakan WebSockets untuk pemesejan masa nyata antara pengguna.
Kemas Kini Langsung: WebSockets menguasakan kemas kini data masa nyata dalam aplikasi seperti platform dagangan kewangan (harga saham), skor sukan atau suapan berita langsung.
Alat Kolaboratif: WebSockets mendayakan kemas kini masa nyata dalam alatan kolaboratif seperti Google Docs atau Figma, di mana berbilang pengguna boleh mengedit dokumen secara serentak.
Perjudian Dalam Talian: Permainan berbilang pemain bergantung pada WebSockets untuk tindakan dan interaksi pemain masa nyata.
IoT dan Data Sensor: Peranti dengan penstriman data masa nyata (cth., peranti IoT, penderia cuaca) menggunakan WebSockets untuk menghantar kemas kini berterusan.

Membina Aplikasi Masa Nyata dengan Python dan Soket Web

Mari bina aplikasi masa nyata menggunakan WebSockets dengan Python (menggunakan FastAPI) dan Streamlit.

1. Sediakan Pelayan WebSocket FastAPI

Kod ini menyediakan pelayan WebSocket menggunakan FastAPI.

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from typing import List

app = FastAPI()

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 broadcast(self, message: str):
        for connection in self.active_connections:
            await connection.send_text(message)

manager = ConnectionManager()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await manager.connect(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            await manager.broadcast(f"Message: {data}")
    except WebSocketDisconnect:
        manager.disconnect(websocket)

Salin selepas log masuk

Pelayan WebSocket ini boleh mengendalikan berbilang sambungan dan menyiarkan mesej kepada semua pelanggan yang disambungkan.

2. Perkemas Bahagian Hadapan

Sekarang, mari kita bina aplikasi masa nyata menggunakan Streamlit yang bersambung ke pelayan WebSocket dan menerima kemas kini langsung.

import streamlit as st
import asyncio
import websockets

async def websocket_receive():
    uri = "ws://localhost:8000/ws"
    async with websockets.connect(uri) as websocket:
        while True:
            message = await websocket.recv()
            st.write(f"Received: {message}")

st.title("Real-Time WebSocket Client")

if st.button("Connect to WebSocket"):
    st.write("Connected!")
    asyncio.run(websocket_receive())

Salin selepas log masuk

Penjelasan: Apabila pengguna mengklik butang "Sambung ke WebSocket", bahagian hadapan Streamlit mewujudkan sambungan dengan pelayan WebSocket dan mendengar mesej.

3. Menjalankan Aplikasi

Jalankan pelayan FastAPI:

uvicorn server:app --reload

Salin selepas log masuk

Jalankan apl Streamlit:

streamlit run your_script.py

Salin selepas log masuk

Langkah Utama dalam Komunikasi Masa Nyata:

Persediaan WebSocket: Pelayan WebSocket berjalan dan menerima sambungan.
Sambungan Streamlit: Bahagian hadapan streamlit memulakan sambungan ke pelayan WebSocket.
Komunikasi Dupleks Penuh: Kedua-dua pelanggan (Streamlit) dan pelayan (FastAPI) boleh menghantar/menerima mesej dalam masa nyata.

Atas ialah kandungan terperinci Memahami WebSockets menggunakan Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!