websocket理解

简介

在实际开发中，可能会出现一个需求场景，要求网页的数据可以实时更新。在这种情况下，我们一般会采用轮询的方式，间隔性获取数据，即通过定时器间隔性请求相应接口获取数据，此方式由于是不断请求服务器，资源开销相对较大，且由于数据更新是间隔性，会导致数据时效性欠缺，可能会出现部分延迟，因此衍生出另一种方式：长轮询，长轮询一般是客户端请求服务端，但服务器不是即时返回，而当内容有所更新时，服务器会返回相应内容给客户端，从名义上为服务器向客户端推送信息。

综合以上，可以总结出轮询、长轮询的优缺点

轮询：

1.服务器的CPU、带宽资源消耗较大，也可能会存在大量的无效请求

2.由于是间隔性获取数据，数据时效性欠缺，会有部分延迟，当然，间隔时间越短，相对的数据的时效性越好，但会导致资源开销大

长轮询

1.解决了轮询过程中的数据时效性较差的问题

2.由于一直在等待服务器返回，对于内存的消耗会相对较大

轮询、长轮询都或多或少存在一些缺陷，因此websocket协议就此诞生，它就是为了实现消息的实时更新而出现的。

websocket简介

websocket协议是网络传输协议，位于应用层，可在单个tcp连接上进行全双工通信，能够更好的节省资源开销实现消息通讯，websocket基于tcp协议，所以也是需要建立连接和关闭连接的，不像tcp的三次握手，客户端与服务器建立一次连接后即可实现双向通信。

为了实现和HTTP的兼容性，WebSocket握手使用HTTP的Upgrade头将HTTP协议转换成Websocket协议。

作为一种协议，websocket自然也是有其用于协议控制的头部信息的，但是相对于HTTP请求每次都要带上完整的头部信息，传输数据时，websocket数据包的头部信息就相对较小，从而降低了控制开销。

特点

全双工通信；

在数据传输中，有三种类型；单工通信、半双工通信、全双工通信，

单工通信：只能向一个方向进行传输

半双工通信：可以双向传输，但是不能同时进行

全双工通信：可以双向传输，也可以同时传输

二进制帧

采用了二进制帧结构，语法、语义与 HTTP 完全不兼容，相比http/2，WebSocket更侧重于“实时通信”，而HTTP/2 更侧重于提高传输效率
协议名与http协议类似

引入ws和wss分别代表明文和密文的websocket协议，且默认端口使用80或443，与http几乎一致

websocket建立连接的流程

1.建立连接， 客户端与服务器端连接

2.握手：验证服务器是否支持websocket

    发送的数据如下：

    GET /chat HTTP/1.1

    Host: server.example.com

    Upgrade: websocket

    Connection: Upgrade

    Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==

    Sec-WebSocket-Protocol: chat, superchat

    Sec-WebSocket-Version: 13

    Origin: http://example.com

    Sec-WebSocket-Key:浏览器随机生成的key，base64生成

    Sec-WebSocket-Protocol：websocket的协议

    Sec-WebSocket-Version：websocket的版本

    其中客户端有一个：Sec-WebSocket-Key字段，服务器有一个：Sec-WebSocket-Accept字段，

        浏览器发送随机生成的key到服务器，

        服务器返回对应Sec-WebSocket-Accept key的原理：

            取出Sec-WebSocket-Key(随机产生)，与一个magic string “258EAFA5-E914-47DA-95CA-C5AB0DC85B11” 连接成一个新的key串

            将新的key串SHA1编码，生成一个由多组两位16进制数构成的加密串

            把加密串进行base64编码生成最终的key，这个key就是Sec-WebSocket-Accept

            简化：取出浏览器发送的key 与magic string连接成一个新字符串

                对新key进行sha1加密返回新的加密串

                对新的加密串进行base64加密并将结果返回给浏览器

        浏览器接收到key与自己本地加密的key进行比较，如果验证通过则说明支持websocket协议，则进行下一步收发数据动作

     为了表示服务器同意和客户端进行Socket连接， 服务器端需要使用客户端发送的这个Key进行校验 ，然后返回一个校验过的字符串给客户端，客户端验证通过后才能正式建立Socket连接。

3.收发数据

4.关闭连接

简易流程如下：

1.建立连接

2.握手：校验服务器是否支持websocket协议：

3.收发数据

4.关闭连接（一般为长连接）

websocket的优点

较少的控制开销：数据包头部协议较小，不同于http每次请求需要携带完整的头部
更强的实时性：相对于HTTP请求需要等待客户端发起请求服务端才能响应，延迟明显更少
保持连接状态：创建通信后，可省略状态信息，不同于HTTP每次请求需要携带身份验证
更好的二进制支持：定义了二进制帧，更好处理二进制内容

支持扩展：用户可以扩展websocket协议、实现部分自定义的子协议
更好的压缩效果：Websocket在适当的扩展支持下，可以沿用之前内容的上下文，在传递类似的数据时，可以显著地提高压缩率

websocket的异常处理

由于websocket可能由于网络波动、连接异常断开导致无法正常进行通信，因此对于一般websocket而言，需要添加异常处理机制，即在出现异常断开时进行重连，因此衍生出心跳重连机制。

心跳重连机制：

    原因：由于网络原因导致的websocket连接未能正常关闭，从而导致服务器继续推送数据导致数据丢失，因此需要一种判断客户端和服务端是否存货的方式

    概念: 心跳机制是每隔一段时间会向服务器发送一个数据包，告诉服务器自己还活着，同时客户端会确认服务器端是否还活着，如果还活着的话，就会回传一个数据包给客户端来确定服务器端也还活着，否则的话，有可能是网络断开连接了。需要重连~

需要注意的是，在websocket的一方出现异常时，需要先将原始连接关闭后再建立新的连接，如果原始连接还在，可能会出现消息数据发送错误的情况

websocket的使用场景

视频平台的弹幕发送
聊天室
协同编辑：例如在线文档的多人协作
服务器推送客户端消息
其他需要保持长时间实时更新的任务或需求

websocket在python中的简单使用

客户端

首先先创建一个简易的服务端，使用flask_sockets创建

from flask import Flask

from flask_sockets import Sockets

app = Flask(__name__)

socket = Sockets(app=app)

@socket.route('/start_websocket')

def start_websocket(ws):

    try:

        while not ws.closed:

            data = ws.receive()

            print(f'recv data:{data}')

            ws.send(data)

    except Exception as e:

      print(f'start_websocket error:{e}')

if __name__ ==  "__main__":

    from gevent import pywsgi

    from geventwebsocket.handler import WebSocketHandler

    server = pywsgi.WSGIServer(listener=("0.0.0.0", 5050), application=app, handler_class=WebSocketHandler)

    print('server start')

    server.serve_forever()

create_connection连接

此方法不建议使用，链接不稳定，容易断，并且连接很耗时

pip3 install websocket-client

from websocket import create_connection

url='ws://127.0.0.1:5050/start_websocket'

ws =  create_connection(url)

ws.send('hello')

while True:

    recv_data = ws.recv()

    print(f'recv_data:{recv_data}')

ws4py.client.threadedclient import WebSocketClient

此方法很容易连接，获取数据的速度也挺快

# 需要安装ws4py

pip3 install ws4py

from ws4py.client.threadedclient import WebSocketClient

class EchoClient(WebSocketClient):

    def opened(self):

        self.send('hello')

    def closed(self, code, reason):

        print(("Closed down", code, reason))

    def received_message(self, m):

        print("=> %d %s" % (len(m), str(m)))

try:

    ws = EchoClient('ws://127.0.0.1:5050/start_websocket', protocols=['http-only', 'chat'])

    ws.connect()

    ws.run_forever()

except KeyboardInterrupt:

    ws.close()

使用websocket自带的Websocket

与第一种方式类似，容易断，连接耗时长

pip install websocket

from websocket import WebSocket

try:

    ws = WebSocket()

    url='ws://127.0.0.1:5050/start_websocket'

    ws.connect(url)

    ws.send('hello')

    while True:

        data = ws.recv()

        print(f'data:{data}')

except Exception as e:

    print(f'start websocket fail:{e}')

使用websocket模块的WebSocketApp

使用方法类似于js的websocket api

# 需要安装websocket

pip3 install websocket

from websocket import WebSocketApp

import websocket

def open(ws:WebSocketApp):

    print(f'ws:{ws}')

    ws.send('hello')

def receive_msg(ws, msg):

    print(f'ws:{ws}, msg:{msg}')

def error(ws, error):

    print(f'ws:{ws}, error:{error}')

def close(ws, status, code):

    print(f'ws:{ws}, status:{status}, code:{code}')

if __name__ == "__main__":

    # 打开可追溯性，打印项目日志debug

    websocket.enableTrace(True)

    url='ws://127.0.0.1:5050/start_websocket'

    ws = WebSocketApp(url=url, on_open=open, on_message=receive_msg, on_error=error, on_close=close)

    ws.run_forever()

结果如下

--- request header ---

GET /start_websocket HTTP/1.1

Upgrade: websocket

Host: 127.0.0.1:5050

Origin: http://127.0.0.1:5050

Sec-WebSocket-Key: xP5FfO+M3UzHuug2rjAMMA==

Sec-WebSocket-Version: 13

Connection: Upgrade

-----------------------

--- response header ---

HTTP/1.1 101 Switching Protocols

Upgrade: websocket

Connection: Upgrade

Sec-WebSocket-Accept: eKkIqEQa+7niXqEbW6bHN1tMnA0=

-----------------------

ws:<websocket._app.WebSocketApp object at 0x7f8d8721acc0>

++Sent raw: b'\x81\x85\xa7\xc1\xf2\x11\xcf\xa4\x9e}\xc8'

++Sent decoded: fin=1 opcode=1 data=b'hello'

++Rcv raw: b'\x81\x05hello'

++Rcv decoded: fin=1 opcode=1 data=b'hello'

ws:<websocket._app.WebSocketApp object at 0x7f8d8721acc0>, msg:hello

由此可以看出，发送的key为eKkIqEQa+7niXqEbW6bHN1tMnA0=，协议为websocket，版本为13

服务端

flask_sockets

上文已经写了一个简单的服务端程序

from flask import Flask

from flask_sockets import Sockets

app = Flask(__name__)

socket = Sockets(app=app)

@socket.route('/start_websocket')

def start_websocket(ws):

    try:

        while not ws.closed:

            data = ws.receive()

            print(f'recv data:{data}')

            ws.send(data)

    except Exception as e:

      print(f'start_websocket error:{e}')

if __name__ ==  "__main__":

    from gevent import pywsgi

    # 将连接转为websocket协议，具体连接过程详见上述连接过程的建立连接

    from geventwebsocket.handler import WebSocketHandler

    server = pywsgi.WSGIServer(listener=("0.0.0.0", 5050), application=app, handler_class=WebSocketHandler)

    print('server start')

    server.serve_forever()

WebSocketHandler:就是将连接转为websocket协议，存在一个magic string，以及支持的版本

SUPPORTED_VERSIONS = ('13', '8', '7')

GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"

注意事项

flask和Flask-Sockets版本不能过高, 过高会导致无法正常启动websocket

flask:1.1.2

Flask-Sockets:1.0.1

Werkzeug：1.0.0

另外，此方法在官方文档中已经不再推荐

参考链接 flask_websockts

flask-sockeio

pip3 install flask-socketio

必要条件：

Flask SocketIO与Python 3.6+兼容。此包所依赖的异步服务可以在三个选项中选择：

1.eventlet

2.gevent

3.Werkzeug

from flask import Flask

# send:用于自带的event发送数据， emit用于定制的event发送数据

from flask_socketio import SocketIO,send, emit

app = Flask(__name__)

app.config['SECRET_KEY'] = 'secret'

socketio = SocketIO(app)

'''

使用socketio.on装饰器来接收从客户端发送来的WebSocket信息。

socketio.on的第一个参数是event名称。connect, disconnect, message和json是SocketIO产生的特殊events。

其它event名称被认为是定制events。

'''

@socketio.on('message', namespace='/start_websocket')

def handle_message(message):

    print(f'handle_message:{message}')

    send(message)

@socketio.on('json')

def handle_json(json):

    print('received json:　'+ str(json))

@socketio.on('my event')

def handle_my_custom_event(json):

    print('received json: ' + str(json))

# 声明命名空间，方便多路复用， 类似于flask_websockets下的socket.route中的参数

@socketio.on('my event2', namespace='/test')

def handle_my_custom_namespace_event(json):

    print('received json: ' + str(json))

if __name__ == "__main__":

    # 函数socketio.run()封装了网络服务器的启动部分，并且代替了flask开发服务器的标准启动语句app.run()

    socketio.run(app)

与其他服务端不同，客户端还需引用Socket.IO库并且建立一个连接：

<script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js" integrity="sha512-q/dWJ3kcmjBLU4Qc47E4A9kTB4m3wuTY7vkFJDTZKjTs8jhyGQnaUrxa0Ytd0ssMZhbNua9hE+E7Qv1j+DyZwA==" crossorigin="anonymous"></script>

<script type="text/javascript" charset="utf-8">

    var socket = io();

    socket.on('connect', function() {

        socket.emit('my event', {data: 'I\'m connected!'});

    });

</script>

目前发现比较适用与前端界面到后端的交互

参考文档：flask_socketio官网、flask_socketio中文翻译

flask-sock

此方法不再依赖于其他的异步组件

pip3 install flask-sock

from flask import Flask

from flask_sock import Sock

app = Flask(__name__)

sock = Sock(app)

app.config['SOCK_SERVER_OPTIONS'] = {'ping_interval': 25}

@sock.route('/start_websocket')

def start_websocket(ws):

    while True:

        data = ws.receive()

        print(f'data:{data}')

        if data != 'close':

            ws.send(data)

        else:

            ws.close()

if __name__ == "__main__":

    app.run(port=5050)

flask-sock的适用方式与flask_sockets类似，但是，它不依赖于gevent等，类似于http请求接口一样，并且自带发送ping消息的功能。

参考文档：flask_sock、flask_sock文档

巴特西