O princípio do WebSocket e sua aplicação em Python
Princípio do WebSocket
WebSocket é um protocolo para comunicação full-duplex em uma única conexão TCP. Ele permite a interação em tempo real, estabelecendo uma conexão persistente entre cliente e servidor. Comparado com o modo de resposta de solicitação HTTP tradicional, o protocolo WebSocket possui as seguintes características:
- Comunicação full-duplex : O WebSocket permite que o cliente e o servidor enviem e recebam dados ao mesmo tempo, realizando uma comunicação bidirecional.
- Conexão persistente : A conexão WebSocket é sempre mantida aberta entre o cliente e o servidor, não sendo necessário estabelecer e fechar repetidamente a conexão.
- Baixa latência : como o WebSocket usa uma única conexão TCP, ele evita o handshake do HTTP e a sobrecarga do cabeçalho, portanto, tem baixa latência.
- Suporte entre domínios : o WebSocket oferece suporte à comunicação entre domínios, que pode se comunicar entre diferentes nomes de domínio ou portas.
O princípio de funcionamento do protocolo WebSocket é o seguinte:
- O cliente envia uma solicitação HTTP ao servidor, a solicitação contém um campo de cabeçalho Upgrade e o protocolo especificado é WebSocket.
- Depois que o servidor receber a solicitação, se ele suportar o protocolo WebSocket, ele retornará uma resposta de 101 protocolos de comutação, indicando que o protocolo foi trocado e uma conexão persistente é estabelecida ao mesmo tempo.
- Depois que a conexão é estabelecida, o cliente e o servidor podem se comunicar enviando quadros. Os quadros incluem dados e informações de controle e podem ser usados para enviar e receber mensagens.
- Clientes e servidores podem enviar quadros a qualquer momento, e os dados podem estar em formato de texto ou binário.
- Quando a conexão é encerrada, o cliente ou servidor envia um quadro com um código de fechamento, indicando que a conexão foi encerrada.
Implementar servidor WebSocket com Python
O Python fornece várias bibliotecas e estruturas para implementar aplicativos WebSocket, sendo as mais usadas as bibliotecas websocketand . websocketsAqui está um websocketsexemplo simples implementado usando a 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()
No exemplo acima, websocketsum servidor WebSocket é criado usando a biblioteca, escutando na porta 8000 localmente. websocket_handlerA função é usada para processar a mensagem recebida e process_messagea função é usada para processar a lógica da mensagem. para websocket.send()enviar uma resposta ao cliente.
Você pode usar a API WebSocket do seu navegador ou outros clientes WebSocket para se comunicar com este servidor, enviando e recebendo mensagens.
Usando Python para implementar o cliente WebSocket
Preparação
Antes de começar, certifique-se de ter instalado o Python e a biblioteca WebSocket.
pip install websocket-client
Criar um cliente WebSocket
Primeiro, precisamos criar um cliente WebSocket para se conectar ao servidor e se comunicar.
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()
No código acima, definimos várias funções de retorno de chamada para lidar com diferentes eventos:
on_open(): Chamado quando uma conexão é estabelecida.on_message(): Chamado quando uma mensagem é recebida.on_close(): Chamado quando a conexão é fechada.on_error(): Chamado quando ocorre um erro.
Em seguida, usamos websocket.WebSocketAppa classe para criar uma conexão WebSocket e especificar a função de retorno de chamada. Finalmente, chame run_forever()o método para iniciar o cliente WebSocket.
comunicar com o servidor
Agora que criamos o cliente WebSocket, vamos tentar nos comunicar com o 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()
No código acima, on_open()enviamos uma mensagem para o servidor na função. Podemos enviar qualquer tipo de mensagem que quisermos.
exemplo completo
Abaixo está um exemplo completo mostrando como implementar um aplicativo WebSocket simples 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 é um protocolo que realiza comunicação full-duplex e realiza interação em tempo real estabelecendo uma conexão persistente. O Python fornece várias bibliotecas e estruturas para implementar aplicativos WebSocket, como websockets，websocket-clientbibliotecas. Comunicação em tempo real, sala de bate-papo, atualização de dados em tempo real e outras funções podem ser realizadas usando o WebSocket.