El principio de WebSocket y su aplicación en Python
Principio de WebSocket
WebSocket es un protocolo para la comunicación full-duplex sobre una única conexión TCP. Permite la interacción en tiempo real al establecer una conexión persistente entre el cliente y el servidor. En comparación con el modo de respuesta de solicitud HTTP tradicional, el protocolo WebSocket tiene las siguientes características:
- Comunicación full-duplex : WebSocket permite que el cliente y el servidor envíen y reciban datos al mismo tiempo, realizando una comunicación bidireccional.
- Conexión persistente : la conexión WebSocket siempre se mantiene abierta entre el cliente y el servidor, y no es necesario establecer y cerrar la conexión repetidamente.
- Baja latencia : Debido a que WebSocket usa una única conexión TCP, evita el protocolo de enlace HTTP y la sobrecarga del encabezado, por lo que tiene una latencia baja.
- Compatibilidad con dominios cruzados : WebSocket admite la comunicación entre dominios, que puede comunicarse entre diferentes nombres de dominio o puertos.
El principio de funcionamiento del protocolo WebSocket es el siguiente:
- El cliente envía una solicitud HTTP al servidor, la solicitud contiene un campo de encabezado Actualizar y el protocolo especificado es WebSocket.
- Después de que el servidor recibe la solicitud, si es compatible con el protocolo WebSocket, devolverá una respuesta 101 Switching Protocols, lo que indica que el protocolo se cambia y se establece una conexión persistente al mismo tiempo.
- Una vez establecida la conexión, el cliente y el servidor pueden comunicarse mediante el envío de tramas. Los marcos incluyen datos e información de control y se pueden utilizar para enviar y recibir mensajes.
- Los clientes y servidores pueden enviar marcos en cualquier momento y los datos pueden estar en formato de texto o binario.
- Cuando se cierra la conexión, el cliente o servidor envía una trama con un código de cierre, indicando que la conexión está cerrada.
Implementar servidor WebSocket con Python
Python proporciona múltiples bibliotecas y marcos para implementar aplicaciones WebSocket, las más utilizadas son las bibliotecas websockety websockets. Aquí hay un websocketsejemplo simple implementado usando la biblioteca:
pip install websockets
import asyncio
import websockets
# 定义WebSocket处理逻辑
async def websocket_handler(websocket, path):
# 接收客户端消息
async for message in websocket:
# 处理消息
response = process_message(message)
# 发送响应给客户端
await websocket.send(response)
# 处理消息的函数
def process_message(message):
# 处理逻辑...
return response
# 启动WebSocket服务器
start_server = websockets.serve(websocket_handler, 'localhost', 8000)
# 运行事件循环
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
En el ejemplo anterior, websocketsse crea un servidor WebSocket usando la biblioteca, escuchando en el puerto 8000 localmente. websocket_handlerLa función se usa para procesar el mensaje recibido y process_messagela función se usa para procesar la lógica del mensaje. método websocket.send()para enviar una respuesta al cliente.
Puede usar la API WebSocket de su navegador u otros clientes WebSocket para comunicarse con este servidor, enviar y recibir mensajes.
Usando Python para implementar el cliente WebSocket
Preparación
Antes de comenzar, asegúrese de tener instalado Python y la biblioteca WebSocket.
pip install websocket-client
Crear un cliente WebSocket
Primero, necesitamos crear un cliente WebSocket para conectarnos al servidor y comunicarnos.
import websocket
def on_open(ws):
print("连接已建立")
def on_message(ws, message):
print("收到消息：", message)
def on_close(ws):
print("连接已关闭")
def on_error(ws, error):
print("发生错误：", error)
# 创建WebSocket连接
ws = websocket.WebSocketApp("ws://localhost:8000/ws",
on_open=on_open,
on_message=on_message,
on_close=on_close,
on_error=on_error)
# 启动WebSocket客户端
ws.run_forever()
En el código anterior, definimos varias funciones de devolución de llamada para manejar diferentes eventos:
on_open(): Se llama cuando se establece una conexión.on_message(): Se llama cuando se recibe un mensaje.on_close(): Se llama cuando se cierra la conexión.on_error(): Llamado cuando ocurre un error.
Luego, usamos websocket.WebSocketAppla clase para crear una conexión WebSocket y especificar la función de devolución de llamada. Finalmente, llame run_forever()al método para iniciar el cliente WebSocket.
comunicarse con el servidor
Ahora que hemos creado el cliente WebSocket, intentemos comunicarnos con el servidor.
import websocket
def on_open(ws):
print("连接已建立")
# 发送消息给服务器
ws.send("Hello, server!")
def on_message(ws, message):
print("收到消息：", message)
def on_close(ws):
print("连接已关闭")
def on_error(ws, error):
print("发生错误：", error)
# 创建WebSocket连接
ws = websocket.WebSocketApp("ws://localhost:8000/ws",
on_open=on_open,
on_message=on_message,
on_close=on_close,
on_error=on_error)
# 启动WebSocket客户端
ws.run_forever()
En el código anterior, on_open()hemos enviado un mensaje al servidor en la función. Podemos enviar cualquier tipo de mensaje como queramos.
ejemplo completo
A continuación se muestra un ejemplo completo que muestra cómo implementar una aplicación WebSocket simple usando Python.
import websocket
def on_open(ws):
print("连接已建立")
# 发送消息给服务器
ws.send("Hello, server!")
def on_message(ws, message):
print("收到消息：", message)
def on_close(ws):
print("连接已关闭")
def on_error(ws, error):
print("发生错误：", error)
# 创建WebSocket连接
ws = websocket.WebSocketApp("ws://localhost:8000/ws",
on_open=on_open,
on_message=on_message,
on_close=on_close,
on_error=on_error)
# 启动WebSocket客户端
ws.run_forever()
Resumir
WebSocket es un protocolo que realiza comunicación full-duplex y realiza interacción en tiempo real al establecer una conexión persistente. Python proporciona múltiples bibliotecas y marcos para implementar aplicaciones WebSocket, como websockets，websocket-clientbibliotecas. La comunicación en tiempo real, la sala de chat, la actualización de datos en tiempo real y otras funciones se pueden realizar mediante el uso de WebSocket.