python模块websockets，浏览器与服务器之间的双向通信

一、简介

WebSocket是一种在Web浏览器和服务器之间进行实时双向通信的协议。它通过建立一条持久的连接，允许服务器主动向客户端推送数据，实现实时性和双向通信的能力。
与传统的HTTP请求-响应模式不同，WebSocket提供了一个长时间运行的连接，可以在客户端和服务器之间进行双向通信。这意味着服务器可以主动向客户端发送数据，而不需要客户端发起请求。这种实时性和双向通信的特性使得WebSocket在许多应用场景下非常有用，如实时聊天应用、在线游戏、股票市场报价等。
WebSocket协议建立在HTTP协议之上，使用HTTP的握手过程来建立连接，然后协议切换到WebSocket协议进行数据交换。WebSocket使用了一种轻量级的帧格式来传输数据，可以发送文本和二进制数据。它还支持心跳机制，以保持连接的活跃状态。
以下是WebSocket的一些优点：
1.实时性：WebSocket提供了低延迟的实时通信，允许服务器主动推送数据给客户端，而不需要客户端频繁地发送请求。这使得WebSocket非常适合实时聊天、在线游戏、股票行情等需要快速更新数据的应用场景。
2.双向通信：WebSocket支持双向通信，客户端和服务器可以同时发送和接收数据。这使得应用程序可以实现实时的双向交互，例如聊天应用中的即时消息发送和接收。
3.较少的网络开销：相比于传统的HTTP请求-响应模式，WebSocket使用较少的网络开销。它使用轻量级的帧格式传输数据，减少了头部开销，并且在建立连接后保持长时间的连接状态，避免了重复的握手过程。
4.跨平台和跨浏览器：WebSocket是基于标准的Web技术，可以在各种平台和浏览器上使用。它提供了一致的API和协议，简化了开发和部署的复杂性。
尽管WebSocket有很多优点，但也有一些考虑的缺点：
1.兼容性：虽然WebSocket在现代浏览器中得到广泛支持，但在一些旧版本的浏览器中可能不被完全支持。为了兼容性，开发人员可能需要提供备用的通信方式，如长轮询或服务器发送事件（Server-Sent Events）。
2.长连接维护：由于WebSocket使用长时间运行的连接，服务器需要维护和管理大量的连接状态。这可能对服务器的资源和性能造成一定的压力。
3.安全性考虑：WebSocket的持久连接可能会增加一些安全风险，如跨站脚本攻击（Cross-Site Scripting）和跨站请求伪造（Cross-Site Request Forgery）。开发人员需要注意对这些安全问题进行适当的防护措施。
总体而言，WebSocket是一种强大的协议，适用于需要实时性和双向通信的应用场景。它提供了一种高效、简单和标准化的方式来实现实时Web应用程序。

二、安装

pip install websockets

三、websockets之websockets.serve服务端WebSocket

1. scoket = websockets.serve(ws_handler, …, write_limit) ：创建websocket服务端对象，async with 时返回WebSocketServer对象

• ws_handler：WebSocket 连接的处理函数，接收两个参数：websocket 和 path。websocket 是一个 WebSocketServerProtocol 实例，用于与客户端进行通信。path 是客户端请求的路径。
• host：要绑定的主机地址，可以是 IP 地址或域名，默认为 ‘localhost’。
• port：要绑定的端口号，默认为 None，表示由操作系统自动选择一个可用的端口。
• create_protocol：可选参数，用于自定义创建 WebSocket 协议实例的函数。默认为 None，表示使用 WebSocketServerProtocol 类创建协议实例。
• logger：可选参数，用于指定日志记录器。默认为 None，表示不进行日志记录。
• compression：可选参数，用于指定压缩算法。默认为 None，表示不启用压缩。可以是 ‘deflate’ 或 ‘gzip’。
• origins：可选参数，用于限制允许的来源。可以是字符串或列表。默认为 None，表示不进行来源限制。
• extensions：可选参数，用于指定支持的扩展。可以是字符串或列表。默认为 None，表示不启用扩展。
• subprotocols：可选参数，用于指定支持的子协议。可以是字符串或列表。默认为 None，表示不启用子协议。
• extra_headers：可选参数，用于指定额外的响应头。可以是字典或可调用对象。默认为 None，表示不添加额外的响应头。
• server_header：可选参数，用于指定服务器响应头。默认为 True，表示在响应中包含服务器信息。
• process_request：可选参数，用于自定义处理客户端请求的函数。默认为 None，表示使用默认处理逻辑。
• select_subprotocol：可选参数，用于选择子协议的函数。默认为 None，表示不进行子协议选择。
• open_timeout：可选参数，用于指定握手超时时间（秒）。默认为 None，表示没有超时限制。
• ping_interval：可选参数，用于指定发送 ping 帧的间隔（秒）。默认为 None，表示不发送 ping 帧。
• ping_timeout：可选参数，用于指定 ping 帧的超时时间（秒）。默认为 None，表示没有超时限制。
• close_timeout：可选参数，用于指定关闭连接的超时时间（秒）。默认为 None，表示没有超时限制。
• max_size：可选参数，用于指定接收的消息的最大大小（字节）。默认为 None，表示没有大小限制。
• max_queue：可选参数，用于指定消息队列的最大大小。默认为 None，表示没有队列大小限制。
• read_limit：可选参数，用于指定读取数据的限制（字节）。默认为 2 ** 16。
• write_limit：可选参数，用于指定写入数据的限制（字节）。默认为 2 ** 16。

import asyncio
import websockets

async def recv_message(websocket, message):
    print('接收到的消息:', message)
    await websocket.send('已收到消息: ' + message)

async def create_socket(websocket, path):
    print('服务端已连接')
    try:
        async for message in websocket:
            await recv_message(websocket, message)
    except websockets.exceptions.ConnectionClosedOK:
        print('连接已关闭')
    except Exception as e:
        print(f'连接失败: {e}')

async def main():
    socket_server = await websockets.serve(create_socket, '127.0.0.1', 8080)
    async with socket_server as server:
        await server.serve_forever()


asyncio.run(main())

四、websockets之websockets.client客户端WebSocket

1. clientSocket = websockets.connect(uri,…,write_limit)：创建websocket客户端对象，async with 时返回WebSocketClientProtocol对象

• uri：WebSocket 服务器的 URI。可以是字符串或 WebSocketURI 实例。
• create_protocol：可选参数，用于自定义创建 WebSocket 协议实例的函数。默认为 None，表示使用 WebSocketClientProtocol 类创建协议实例。
• logger：可选参数，用于指定日志记录器。默认为 None，表示不进行日志记录。
• compression：可选参数，用于指定压缩算法。默认为 None，表示不启用压缩。可以是 ‘deflate’ 或 ‘gzip’。
• origin：可选参数，用于指定请求的来源。默认为 None。
• extensions：可选参数，用于指定支持的扩展。可以是字符串或列表。默认为 None，表示不启用扩展。
• subprotocols：可选参数，用于指定支持的子协议。可以是字符串或列表。默认为 None，表示不启用子协议。
• extra_headers：可选参数，用于指定额外的请求头。可以是字典或可调用对象。默认为 None，表示不添加额外的请求头。
• user_agent_header：可选参数，用于指定用户代理请求头。默认为 True，表示在请求中包含用户代理信息。
• open_timeout：可选参数，用于指定握手超时时间（秒）。默认为 None，表示没有超时限制。
• ping_interval：可选参数，用于指定发送 ping 帧的间隔（秒）。默认为 None，表示不发送 ping 帧。
• ping_timeout：可选参数，用于指定 ping 帧的超时时间（秒）。默认为 None，表示没有超时限制。
• close_timeout：可选参数，用于指定关闭连接的超时时间（秒）。默认为 None，表示没有超时限制。
• max_size：可选参数，用于指定接收的消息的最大大小（字节）。默认为 None，表示没有大小限制。
• max_queue：可选参数，用于指定消息队列的最大大小。默认为 None，表示没有队列大小限制。
• read_limit：可选参数，用于指定读取数据的限制（字节）。默认为 2 ** 16。
• write_limit：可选参数，用于指定写入数据的限制（字节）。默认为 2 ** 16。

2. clientSocket.handle_redirect(uri)：更新连接状态以连接到新的URI

import asyncio
import websockets


async def recv_message(websocket):
    response = await websocket.recv()  # 接收服务器的消息
    print(f'接收到的消息: {response}')

async def send_message(websocket, message):
    await websocket.send(message)

async def main():
    socket_client = websockets.connect('ws://127.0.0.1:8080')
    async with socket_client as websocket:
        await send_message(websocket, 'hello server')
        await recv_message(websocket)


asyncio.run(main())

五、websockets之websockets.WebSocketServer服务端WebSocket，websockets.serve

1. webSocketServer = websockets.WebSocketServer(logger)：创建webSocketServer对象
2. webSocketServer.close(close_connections)：关闭WebSocket服务器。close_connections是一个布尔值，表示是否关闭所有当前连接的WebSocket连接。
3. webSocketServer.wrap(server)：将底层的asyncio服务器对象包装为WebSocketServer对象。server是一个asyncio服务器对象。
4. webSocketServer.get_loop()：获取与WebSocket服务器关联的事件循环。
5. webSocketServer.wait_closed()：等待WebSocket服务器关闭，即所有连接关闭后才返回。
6. webSocketServer.start_serving()：启动WebSocket服务器，开始监听指定的主机和端口。可以与serve_forever()方法一起使用。
7. webSocketServer.serve_forever()：持续运行WebSocket服务器，直到调用stop()方法停止服务器。
8. webSocketServer.is_serving()：检查WebSocket服务器是否正在运行。
9. webSocketServer.unregister(protocol)：从WebSocket服务器中注销指定的协议（WebSocketCommonProtocol实例）。
10. webSocketServer.register(protocol)：向WebSocket服务器注册指定的协议（WebSocketCommonProtocol实例）。
11. webSocketServer.sockets：WebSocket服务器正在监听的套接字列表。

六、websockets之websockets.exceptionsl与 WebSocket 相关的异常类

1. websockets.ConnectionClosedOK：表示连接已正常关闭的异常。
2. websockets.ConnectionClosed：表示连接已关闭的异常。
3. websockets.WebSocketException：WebSocket 相关异常的基类。
4. websockets.InvalidMessage：表示接收到的消息无效的异常。
5. websockets.ConnectionClosedError：表示连接关闭时发生错误的异常。
6. websockets.SecurityError：表示与 WebSocket 安全性相关的错误的异常。
7. websockets.RedirectHandshake：表示重定向握手的异常。
8. websockets.ProtocolError：表示与 WebSocket 协议相关的错误的异常。
9. websockets.NegotiationError：表示协商过程中发生错误的异常。
10. websockets.PayloadTooBig：表示接收到的消息超过了允许的最大大小的异常。
11. websockets.InvalidParameterName：表示参数名称无效的异常。
12. websockets.InvalidParameterValue：表示参数值无效的异常。
13. websockets.InvalidStatusCode：表示接收到的状态码无效的异常。
14. websockets.InvalidURI：表示提供的 URI（Uniform Resource Identifier）无效的异常。
15. websockets.InvalidHeaderValue：表示头部值无效的异常。
16. websockets.InvalidHeaderFormat：表示头部格式无效的异常。
17. websockets.InvalidUpgrade：表示升级过程无效的异常。
18. websockets.InvalidState：表示状态无效的异常。
19. websockets.InvalidOrigin：表示来源无效的异常。
20. websockets.InvalidHandshake：表示握手过程中发生无效握手的异常。
21. websockets.DuplicateParameter：表示重复参数的异常。
22. websockets.AbortHandshake：表示中止握手的异常。
23. websockets.WebSocketProtocolError：表示 WebSocket 协议错误的异常。
24. websockets.InvalidHeader：表示头部无效的异常。
25. websockets.MultipleValuesError：表示多个值错误的异常。

七、websockets之websockets.WebSocketCommonProtocol基本协议类

1. socketCommonProtocol = websockets.WebSocketCommonProtocol(logger,ping_interval, ping_timeout, close_timeout,max_size,max_queue,read_limit,write_limit,host,port,secure,legacy_recv,loop,timeout)：创建WebSocketCommonProtocol对象

• logger：日志记录器，用于记录WebSocket通信过程中的日志信息。
• ping_interval：发送ping帧的时间间隔（以秒为单位）。如果设置为非零值，则WebSocket连接会定期发送ping帧以保持连接活跃。
• ping_timeout：等待pong帧的超时时间（以秒为单位）。如果在指定的时间内没有收到pong帧作为对ping帧的响应，则认为连接已断开。
• close_timeout：等待关闭帧的超时时间（以秒为单位）。如果在指定的时间内没有收到关闭帧，则强制关闭连接。
• max_size：接收消息的最大字节数。如果接收到的消息超过此大小限制，则会引发异常。
• max_queue：接收消息的最大队列长度。如果接收到的消息队列超过此长度限制，则会引发异常。
• read_limit：每次读取操作的最大字节数。用于限制从网络接收数据的速率。
• write_limit：每次写入操作的最大字节数。用于限制向网络发送数据的速率。
• host：WebSocket服务器的主机名。
• port：WebSocket服务器的端口号。
• secure：指示是否使用安全的WebSocket连接（例如，使用TLS/SSL）。
• legacy_recv：指示是否使用旧版本的接收方法。默认为False，应使用新版本的接收方法。
• loop：事件循环对象，用于执行异步操作。
• timeout：连接的超时时间（以秒为单位）

2. socketCommonProtocol.close(code, reason)：关闭WebSocket连接。
3. socketCommonProtocol.recv()：接收一个WebSocket消息。
4. socketCommonProtocol.send(message)：发送一个WebSocket消息。
5. socketCommonProtocol.wait_closed()：等待WebSocket连接关闭。
6. socketCommonProtocol.close_connection()：关闭底层连接。
7. socketCommonProtocol.abort_pings()：停止发送Ping帧。
8. socketCommonProtocol.close_transport()：关闭底层传输。
9. socketCommonProtocol.connection_closed_exc()：返回一个异常，表示连接已关闭。
10. socketCommonProtocol.connection_lost(exc)：在连接丢失时调用。
11. socketCommonProtocol.connection_made(transport)：在连接建立时调用。
12. socketCommonProtocol.connection_open()：指示连接已打开。
13. socketCommonProtocol.data_received(data)：接收到底层传输的数据。
14. socketCommonProtocol.drain()：等待传输缓冲区为空。
15. socketCommonProtocol.ensure_open()：确保连接处于打开状态。
16. socketCommonProtocol.eof_received()：指示已接收到文件结束符。
17. socketCommonProtocol.fail_connection(code, reason)：以错误状态关闭连接。
18. socketCommonProtocol.keepalive_ping()：发送一个保持活动的Ping帧。
19. socketCommonProtocol.pause_writing()：暂停写入数据。
20. socketCommonProtocol.ping(data)：发送一个Ping帧。
21. socketCommonProtocol.pong(data)：发送一个Pong帧。
22. socketCommonProtocol.read_data_frame(max_size)：读取数据帧。
23. socketCommonProtocol.read_frame(max_size)：读取帧。
24. socketCommonProtocol.read_message()：读取一个完整的WebSocket消息。
25. socketCommonProtocol.resume_writing()：恢复写入数据。
26. socketCommonProtocol.transfer_data()：传输数据。
27. socketCommonProtocol.wait_for_connection_lost()：等待连接丢失。
28. socketCommonProtocol.write_close_frame(close, data)：写入关闭帧。
29. socketCommonProtocol.write_frame(fin, opcode, data)：写入帧。
30. socketCommonProtocol.write_frame_sync(fin, opcode, data)：同步写入帧。
31. socketCommonProtocol.open：WebSocket连接是否打开。
32. socketCommonProtocol.host：WebSocket连接的远程主机地址。
33. socketCommonProtocol.port：WebSocket连接的远程端口号。
34. socketCommonProtocol.closed：WebSocket连接是否已关闭。
35. socketCommonProtocol.close_code：关闭连接时的状态码。
36. socketCommonProtocol.close_reason：关闭连接时的原因。
37. socketCommonProtocol.is_client：指示WebSocket连接是作为客户端还是服务器端。
38. socketCommonProtocol.local_address：WebSocket连接的本地地址。
39. socketCommonProtocol.remote_address：WebSocket连接的远程地址。
40. socketCommonProtocol.secure：指示WebSocket连接是否通过安全通道（例如TLS）进行加密。
41. socketCommonProtocol.side：WebSocket连接的一侧（"client"表示客户端，"server"表示服务器）。

八、websockets之websockets.WebSocketServerProtocol服务端WebSocket协议，继承WebSocketCommonProtocol，async with websockets.serve

1. webSocketServerProtocol = websockets.WebSocketServerProtocol(ws_handler,…,open_timeout)：创建WebSocketServerProtocol对象

• ws_handler：用于处理 WebSocket 连接的请求和消息。用于处理接收到的消息和处理连接事件。
• ws_server：表示与该协议关联的 WebSocket 服务器。
• logger：用于记录日志的日志记录器对象。它用于记录 WebSocket 服务器协议的事件和调试信息。
• origins：允许连接到 WebSocket 服务器的来源。如果提供了这个参数，服务器将验证连接请求的来源是否在允许的列表中。
• extensions：服务器支持的 WebSocket 扩展。如果提供了这个参数，服务器将在握手过程中尝试启用这些扩展。
• subprotocols：服务器支持的子协议。如果提供了这个参数，服务器将在握手过程中选择一个与客户端提供的子协议匹配的子协议。
• extra_header：表示要在服务器的握手响应头中包含的额外标头。
• server_header：表示要在服务器的握手响应头中包含的服务器标头。
• process_request：用于在处理 WebSocket 握手请求之前自定义处理 HTTP 请求。它可以用于验证身份、检查权限等。
• select_subprotocol：用于选择服务器支持的子协议。它接受客户端提供的子协议列表，并返回服务器选择的子协议。
• open_timeout：表示连接的超时时间（以秒为单位）。如果连接在指定的超时时间内没有建立成功，将会被关闭。

2. webSocketClientProtocol.connection_made(transport)：当底层传输建立连接时调用此方法。它接受一个传输对象作为参数，用于与客户端进行通信。
3. webSocketClientProtocol.handler()：WebSocket 服务器协议的主要处理方法。它是一个协程函数，用于处理接收到的消息和处理连接事件。可以在此方法中编写自定义的逻辑来处理消息和事件。
4. webSocketClientProtocol.read_http_request()：读取来自客户端的 HTTP 请求。它解析 HTTP 头部和请求行，并返回一个表示请求的元组。
5. webSocketClientProtocol.write_http_response(status, body)：向客户端写入 HTTP 响应。它接受状态码和响应正文作为参数，并将响应发送给客户端。
6. webSocketClientProtocol.process_request(path, request_headers)：在处理 WebSocket 握手请求之前调用此方法。它接受请求路径和请求头作为参数，并可以用于自定义处理 HTTP 请求，例如验证身份、检查权限等。
7. webSocketClientProtocol.process_origin(headers, origins)：处理 WebSocket 握手请求的来源验证。它接受请求头和允许的来源列表作为参数，并确定请求的来源是否在允许的列表中。
8. webSocketClientProtocol.process_extensions(headers, available_extensions)：处理 WebSocket 握手请求中的扩展。它接受请求头和服务器支持的扩展列表作为参数，并确定要启用的扩展。
9. webSocketClientProtocol.process_subprotocol(headers, available_subprotocols)：处理 WebSocket 握手请求中的子协议。它接受请求头和服务器支持的子协议列表作为参数，并确定要选择的子协议。
10. webSocketClientProtocol.select_subprotocol(client_subprotocols, server_subprotocols)：选择服务器支持的子协议。它接受客户端提供的子协议列表和服务器支持的子协议列表，并返回服务器选择的子协议。
11. webSocketClientProtocol.handshake(origins, available_extensions, available_subprotocols, extra_headers)：执行 WebSocket 握手过程。它接受允许的来源列表、可用的扩展列表、可用的子协议列表和额外的标头作为参数，并执行握手过程与客户端进行握手。

九、websockets之websockets.WebSocketClientProtocol客户端WebSocket协议，继承WebSocketCommonProtocol，async with websockets.client

1. webSocketClientProtocol=websockets.WebSocketClientProtocol(logger,…,user_agent_header)：创建WebSocketClientProtocol对象

• logger：用于记录日志的日志器对象。
• origin：WebSocket连接的来源。它是一个字符串，表示连接的来源URL。
• extensions：可用的WebSocket扩展列表。它是一个字符串列表，表示支持的扩展。
• subprotocols：可用的子协议列表。它是一个字符串列表，表示支持的子协议。
• extra_headers：要添加到握手请求的附加标头。它是一个字典，包含额外的HTTP标头。
• user_agent_header：User-Agent标头的值。它是一个字符串，表示User-Agent。

2. webSocketClientProtocol.write_http_request(path, headers)：用于发送HTTP请求。

• ath：示请求的路径，
• headers：示要发送的HTTP标头

3. webSocketClientProtocol.read_http_response()：用于读取HTTP响应。返回一个包含HTTP响应的元组，包括响应状态码、响应头和响应体。该方法从服务器接收HTTP响应。
4. webSocketClientProtocol.process_extensions(headers, available_extensions)：用于处理WebSocket扩展

• headers：示从服务器接收到的握手响应标头
• ailable_extensions示客户端支持的扩展列表

5. webSocketClientProtocol.process_subprotocol(headers, available_subprotocols)：用于处理子协议

• headers：示从服务器接收到的握手响应标头，
• available_subprotocols：示客户端支持的子协议列表

6. webSocketClientProtocol.handshake(wsuri, origin, available_extensions, available_subprotocols, extra_headers)：用于执行WebSocket握手过程

• wsuri：示WebSocket服务器的URI，
• origin：示连接的来源，
• available_extensions：示客户端支持的扩展列表，
• available_subprotocols：示客户端支持的子协议列表，
• extra_headers：示要添加到握手请求的附加标头。

十、websockets之websockets.ServerProtocol服务器协议

1. serverProtocol=websockets.ServerProtocol(origins,…,max_size,logger)：创建ServerProtocol对象

• origins：一个可选的字符串列表，用于指定允许连接的来源（origin）。如果提供了该参数，服务器将仅接受具有匹配的来源的连接。如果未提供该参数，则允许来自任何来源的连接。
• extensions：一个可选的字符串列表，用于指定服务器支持的扩展。当客户端发起连接时，服务器可以选择使用其中的一个或多个扩展来增强通信功能。
• subprotocols：一个可选的字符串列表，用于指定服务器支持的子协议。当客户端发起连接时，服务器可以选择从中选择一个子协议与客户端进行通信。
• select_subprotocol：一个可选的回调函数，用于选择与客户端通信的子协议。如果提供了该函数，它将在握手期间被调用，以从客户端提供的子协议列表中选择一个子协议。该函数应接受客户端提供的子协议列表作为参数，并返回要使用的子协议，或者返回 None 表示不选择任何子协议。
• state：一个可选的字典，用于存储和传递自定义状态信息。您可以在处理程序中使用该字典来存储和访问与连接相关的自定义数据。
• max_size：一个可选的整数，用于指定接收消息的最大大小（以字节为单位）。如果未提供该参数，则使用库的默认值。
• logger：一个可选的日志记录器，用于记录服务器的日志信息。如果未提供该参数，则使用库的默认日志记录器。

2. serverProtocol.origins：用于指定允许连接的来源（origin）。如果提供了该参数，服务器将仅接受具有匹配的来源的连接。如果未提供该参数，则允许来自任何来源的连接。
3. serverProtocol.extensions：用于指定服务器支持的扩展。当客户端发起连接时，服务器可以选择使用其中的一个或多个扩展来增强通信功能。
4. serverProtocol.subprotocols：用于指定服务器支持的子协议。当客户端发起连接时，服务器可以选择从中选择一个子协议与客户端进行通信。
5. serverProtocol.select_subprotocol：用于选择与客户端通信的子协议。如果提供了该函数，它将在握手期间被调用，以从客户端提供的子协议列表中选择一个子协议。该函数应接受客户端提供的子协议列表作为参数，并返回要使用的子协议，或者返回 None 表示不选择任何子协议。
6. serverProtocol.state：用于存储和传递自定义状态信息。您可以在处理程序中使用该字典来存储和访问与连接相关的自定义数据。
7. serverProtocol.max_size：用于指定接收消息的最大大小（以字节为单位）。如果未提供该参数，则使用库的默认值。
8. serverProtocol.logger：用于记录服务器的日志信息。如果未提供该参数，则使用库的默认日志记录器。process_subprotocol(headers)：用于处理传入请求的子协议。它接收一个包含请求头的字典作为参数，并返回服务器选择的子协议。
9. serverProtocol.process_extensions(headers)：用于处理传入请求的扩展。它接收一个包含请求头的字典作为参数，并返回服务器选择的扩展列表。
10. serverProtocol.reject(status, text)：用于拒绝连接请求。它接收一个状态码和一个可选的文本消息作为参数，并向客户端发送一个相应的拒绝响应。
11. serverProtocol.accept(request)：用于接受连接请求。它接收一个请求对象作为参数，并向客户端发送一个接受连接的响应。
12. serverProtocol.parse()：用于解析传入请求的头部信息并返回解析后的结果。
13. serverProtocol.process_origin(headers)：用于处理传入请求的来源（origin）。它接收一个包含请求头的字典作为参数，并返回处理后的来源。
14. serverProtocol.process_request(request)：用于处理传入请求的方法。它接收一个请求对象作为参数，并返回处理后的结果。
15. serverProtocol.select_subprotocol(subprotocols)：用于选择服务器支持的子协议。它接收一个子协议列表作为参数，并返回要使用的子协议，或者返回 None 表示不选择任何子协议。
16. serverProtocol.send_response(response)：用于向客户端发送响应。它接收一个响应对象作为参数，并将响应发送到客户端。
17. serverProtocol.state：用于存储和传递自定义状态信息。您可以在处理程序中使用该字典来存储和访问与连接相关的自定义数据。
18. serverProtocol.close_code：表示连接关闭的状态码。如果连接未关闭，则为 None。
19. serverProtocol.close_reason：表示连接关闭的原因。如果连接未关闭，则为 None

十一、websockets之websockets.ClientProtocol客户端协议

1. clientProtocol=websockets.ClientProtocol(wsuri,origin,extensions,subprotocols,state,max_size,logger)：创建ClientProtocol对象

• wsuri：WebSocket 服务器的 URI（Uniform Resource Identifier），指定要连接的服务器地址。例如，ws://example.com/socket。
• origin：指定连接的来源（origin）。它是一个字符串，表示发起连接的来源地址。默认为 None。
• extensions：指定要使用的扩展。它是一个扩展列表，用于在连接过程中协商和使用扩展。默认为 []。
• subprotocols：指定要使用的子协议。它是一个子协议列表，用于在连接过程中协商和选择子协议。默认为 []。
• state：指定初始状态信息。它是一个字典，用于存储和传递自定义状态信息。默认为 {}。
• max_size：指定接收消息的最大大小（以字节为单位）。如果接收到的消息大小超过此限制，连接将被关闭。默认为 2**20（1MB）。
• logger：指定日志记录器。它是一个实现了 logging.Logger 接口的对象，用于记录日志信息。默认为 None，表示不进行日志记录。

2. clientProtocol.parse()：解析从服务器接收到的数据。这个方法通常由库内部调用，用于解析 WebSocket 协议的帧。
3. clientProtocol.connect()：建立 WebSocket 连接。这个方法用于向服务器发送连接请求并进行握手。
4. clientProtocol.process_subprotocol(headers)：处理子协议。这个方法用于解析和处理服务器返回的子协议列表。
5. clientProtocol.process_extensions(headers)：处理扩展。这个方法用于解析和处理服务器返回的扩展列表。
6. clientProtocol.process_response(response)：处理服务器的响应。这个方法用于解析和处理服务器返回的 HTTP 响应。
7. clientProtocol.send_request(request)：发送请求。这个方法用于向服务器发送 HTTP 请求。

十二、其他函数

1. websockets.basic_auth_protocol_factory(realm, credentials, check_credentials, create_protocol)：创建一个基本身份验证协议的工厂函数，并返回一个协议工厂函数。

• realm：领域
• credentials：凭据
• check_credentials：检查凭据的函数
• create_protocol：创建协议的函数

2. websockets.broadcast(websockets, message, raise_exceptions)：将消息广播给多个WebSocket连接的函数。它接受一个WebSocket连接列表（websockets）、要广播的消息（message）和一个布尔值（raise_exceptions）来指定是否在发送消息时引发异常。

• websockets：WebSocket连接列表
• message：消息
• raise_exceptions：是否在发送消息时引发异常

3. websockets.unix_connect(path, uri)：通过Unix域套接字连接到WebSocket服务器的函数，并返回一个表示WebSocket连接的协程。

• path：Unix域套接字路径
• uri：WebSocket服务器的URI

4. websockets.unix_serve(ws_handler, path)：使用Unix域套接字在指定路径上提供WebSocket服务器的函数。并启动一个WebSocket服务器来处理传入的连接。

• ws_handler：WebSocket处理程序
• path：Unix域套接字路径