python 实现 websocket

1、websocket概要：

　　websocket是基于TCP传输层协议实现的一种标准协议（关于网络协议，能够看看文末的图片），用于在客户端和服务端双向传输数据

　　传统的客户端想要知道服务端处理进度有两个途径：

　　1）经过ajax不断轮询，因为http的无状态性，每次轮询服务器都须要去解析http协议，对服务器压力也很大

　　2）采用long poll的方式，服务端不给客户端反馈，客户端就一直等待，服务就一直被挂起，此阶段一直是阻塞状态

　　而当服务器完成升级（http-->websocket）后，上面两个问题就获得解决了：

　　　　1）被动性，升级后，服务端能够主动推送消息给客户端，解决了轮询形成的同步延迟问题

　　　　2）升级后，websocket只须要一次http握手，服务端就能一直与客户端保持通讯，直到关闭链接，这样就解决了服务器须要反复解析http协议，减小了资源的开销

2、websocket通讯过程：

　　websocket目前基本主流浏览器都已经支持，IE10如下不支持。

 

　　一、创建链接

　　　　在客户端，new WebSocket实例化一个新的WebSocket客户端对象，链接相似 ws://yourdomain:port/path 的服务端 WebSocket URL， WebSocket 客户端对象会自动解析并识别为 WebSocket 请求，从而链接服务端接口，执行双方握手过程，客户端发送数据格式相似：

　　　　1）客户端请求报文：

GET / HTTP/1.1

Upgrade:websocket　　#line1

Connection:Upgrade　　#line2 ：与http请求报文比，多了line1和line2这两行，它告诉服务器这次发起的是websocket协议，而不是http协议了，记得要升级哦

Host:example.com

Origin:http://example.com

Sec-WebSocket-Key:sN9cRrP/n9NdMgdcy2VJFQ==　　# line3：这个是浏览器随机生成的一个base64加密值，提供基本的防御，告诉服务器，我有提供的密码的，我会作验证的，防止恶意或无心的链接
　　
Sec-WebSocket-Version:13　　#line4 ：告诉服务器使用的websocket版本，若是服务器不支持该版本，会返回一个Sec-WebSocket-Versionheader，里面包含服务器支持的版本号

　　　　客户端建立websocket链接

　　　　　　var ws = new websocket("ws:127.0.0.1:8000")

　　　　完整客户端代码以下：

<script type="text/javascript">
    var ws;
    var box = document.getElementById("box");
    
    function startWS(){
        ws = new websocket("ws:127.0.0.1:8000");
        ws.onopen = function(msg){
            console.log("websocket opened!");
        }
        ws.onomessage = function(message){
            console.log("receive message:"+message.data);
            box.insertAdjacentHTML("beforeend", "<p>"+message.data+"</p>");
        }
        ws.onerror = function(err){
            console.log("error:"+err.name+err.number);
        }
        ws.onclose = function(){
            console.log("websocket closed!")
        }
    }

    function sendMsg(){
        console.log("sending a message...");
        var text = document.getElementById("text");
        ws.send(text.value);
    }

    window.onbeforeunload = function(){
        ws.onclose = function(){}
        ws.close()
    }
</script>

　　　　2）服务端响应报文：

HTTP/1.1 101 Switching Protocols　　# 101表示服务端已经理解了客户端的请求，并将经过Upgrade消息头通知客户端采用不一样的协议来完成这个请求

Upgrade:websocket

Connection:Upgrade　　# 这里两行是告诉浏览器，我已经成功切换协议了，协议是websocket

Sec-WebSocket-Accept:HSmrc0sM1YUkAGmm50PpG2HaGwK=　　#通过服务器确认并加密后的Sec-WebSocket-Key

Sec-WebSocket-Protocol:chat　　# 表示最终使用的协议，至此http就已经完成所有的工做，接下来就是彻底按照websocket协议进行了。

　　　　　上文的Sec-WebSocket-Accept加密算法：

　　　　　　　　a)将Sec-WebSocket-Key和258EAFA5-E914-47DA-95CA-C5AB0DC85B11拼接

　　　　　　　　b)经过SHA1计算出摘要，并转成Base64字符串

　　　　　　　　　　如token = base64.b64encode(hashlib.sha1(key+magic_str).encode("utf8").degist())

　　　　　　　　　　这里在作加密以前，key必定要记得看先后有没有空白，有的话要记得去空白，否则加密的结果会一直报错不匹配，这个坑被坑了好久

　　　　　　　　注意：此处的Sec-WebSocket-Key/Sec-WebSocket-Accept的换算，只能带来基本保障，但链接是否安全，数据是否安全，客户端 服务端是不是合法的ws客户端 ws服务端，并无实际保证

　　　　　　Sec-WebSocket-Protocol：表示最终使用的协议

完整的服务端代码：

　　1）建立websocket服务端

import socket
import threading

global clients
clients = {}


class Websocket_Server(threading.Thread):
    def __init__(self, port):
        self.port = port
        super(Websocket_Server, self).__init__()

    def run(self):
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        sock.bind(("127.0.0.1", self.port))
        sock.listen(5)
        
        while(True):
　　　　　　　# 等待客户端链接
            conn, addr = sock.accept()
            print("客户端{}链接成功:".format(addr))
            conn.send(("welcome...").encode("utf8"))
            while(True):
                try: 
                    info = conn.recv(1024)
                    connId = "ID:"+str(addr[1])
                    clients[connId] = conn
                    
                    print("{0}:{1}".format(connId, info.decode("utf8")))

                except Exception as e:
                    print(e) 

                msg = input()
                conn.send(msg.encode("utf8"))
                
                if info == b"bye":
                    print("客户端退出")
                    conn.close()
                    break

上面建立了websocket服务端，经过socket.socket()建立了TCP服务对象

　　　　接收两个参数：family和type

　　　　　　family：有三种：

　　　　　　　　AF_INET ：即IPV4（默认）

　　　　　　　　AF_INET6：即IPV6

　　　　　　　　AF_UNIX：只可以用于单一的Unix系统进程间通讯

　　　　　　type：套接字类型：

　　　　　　　　流套接字（SOCK_STREAM）（默认）:只读取TCP协议的数据，用于提供面向链接，可靠的数据传输服务。该服务能够保证数据能够实现无差错无重复发送，并按序接收。之因此可以实现可靠的数据传输，缘由在于使用了传输控制协议（TCP）

　　　　　　　　数据报套接字（SOCK_DGRAM）：只读取UDP协议的数据。提供了一种无链接服务，该服务并不能保证数据的可靠性。有可能在数据传输过程当中出现数据丢失，错乱重复等。因为数据包套接字不能保证数据的可靠性，对于有可能出现数据丢失的状况，在程序中要作相应的处理。

　　　　　　　　原始套接字（SOCK_RAW）：原始套接字和标准套接字（上面两种）的区别是：原始套接字能够读取内核没有处理的IP数据包。而流套接字只能读取TCP协议的数据；数据包套接字只能读取UDP协议的数据

　　　　　　　　可靠UDP形式：（SOCK_RDM）,会对数据进行校验，通常不会使用

　　　　　　　　可靠的连续数据包：（SOCK_SEQPACKET）通常也不会使用

　　2）建立websocket客户端

import socket
import threading

class Websocket_Client(threading.Thread):
    def __init__(self):
        self.host ="localhost"
        self.port = 8000
        self.address = (host, port)
        self.buffer = 1024
    
    def run():
        #建立TCP客户端程序
        tcp_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 链接服务端
        tcp_client.connect(self.address)
        while True:
            info = tcp_client.recv(self.buffer)
            print("{}".format(str(info, encoding="utf8")))
            
            msg = input()
            tcp_client.send(msg.encode("utf8"))
            if info.lower().decode("utf8")=="bye":
                tcp_client.close()
                break

完成上述代码，分别打开两个终端，运行WebSocket_Server和WebSocket_Client代码，控制台交互结果以下，能够看到已经成功实现了客户端和服务端的通讯：

 

　　3）如何监听浏览发送过来的socket链接请求？修改上面的WebSocket_Client以下：

class WebSocket_Client():
　　def __init__(self, conn, connId):
　　　　self.connection = conn
　　　　self.connId= connId

　　　　super(WebSocket_Client, self).__init__()
　　
　　def run():
　　　　print("new socket joined")
　　　　# 前端传递过来的请求链接数据
　　　　data = self.connection.recv(1024)
　　　　try:
　　　　　　headers = self.parse_header(data)
　　　　　　token = self.generate_token(headers["Sec-WebSocket-Key"]).decode("utf8")
　　　　　　response ="HTTP/1.1 101 Switching Protocols\r\n" \
　　　　　　　　　　　　"Connection:Upgrade\r\n" \
　　　　　　　　　　　　"Upgrade:websocket\r\n" \
　　　　　　　　　　　　"Sec-WebSocket-Accept:{0}\r\n" \
　　　　　　　　　　　　"WebSocket-Protocol:chat\r\n\r\n".format(token)
　　　　　　# 通知前端已经成功创建链接
　　　　　　self.connection.send(response.encode("utf8"))
　　　　except socket.error as e:
　　　　　　print("unexpect error:", e)
　　　　　　clients.pop(self.connId)

　　　　while True:
　　　　　　
 # 启动 Socket 并监听链接，使用socket中的同名方法，建立TCP服务对象 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)　　# socket.AF_INET是指使用哪一种IP地址，socket.AF_INET即便用IPv4，若是是socket.AF_INET6的话，则使用IPv6；socket.SOCKET_STREAM是指使用的套接字类型，在这里咱们使用流式套接字。 try: sock.bind(("127.0.0.1",8000)) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.listen(5) except Exception as e: logging.error(e) return else: logging.info(Server running...) 　　# 等待访问 while True: conn, addr = sock.accept() #此时会进入waiting状态 data = str(conn.recv(1024)) logging.debug(data) header_dict = {} header, _ = data.split(r"\r\n\r\n", 1) for line in header.split(r"\r\n")[1:]: key, val = line.split(":",1) header_dict[key] = val if "Sec-WebSocket-Key" not in header_dict: logging.error(this socket is not websocket, connection closed...) conn.close() return magic_key = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" sec_key = header_dic["Sec-WebSocket-Key"]+magic_key key = base64.b64encode(hashlib.sha1(bytes(sec_key, encoding="utf-8")).digest()) key_str = str(key)[2:30] logging.debug(key_str) response = "HTTP/1.1 101 Switching Protocols\r\n"\ "Connection:Upgrade\r\n"\ "Upgrade:websocket\r\n"\ "Sec-WebSocket-Accept:{0}\r\n"\ "WebSocket-Protocol:chat\r\n\r\n".format(key_str) conn.send(bytes(response),encoding="utf-8") logging.debug("send the handshake data") WebsocketThread(conn).start() 

　　　　3）进行通讯：

　　　　　　Sever端接收到client发来的报文进行解析

　　　　　　

 

下面是软件通讯的七层结构：

　　下三层结构偏向于数据通讯，上三层更偏向于数据处理，中间的传输层是上三层与下三层之间的链接桥梁，每一层作不一样的工做，上层协议依赖于下层协议，上层协议须要调用下层协议的接口，下层协议使用上层协议的参数，分工合做。

　　socket是应用层与TCP/IP协议族通讯的中间软件抽象层，它是一组接口。属于传输控制层协议，websocket是一个典型的应用层协议。

 

 

参考资料：https://www.cnblogs.com/JetpropelledSnake/p/9033064.html

    　　　　https://www.cnblogs.com/lichmama/p/3931212.html