浏览器翻译的有问题，瓶，烧瓶就是flask
原文来源：https://flask-socketio.readthedocs.io/en/latest/#emitting-from-an-external-process
Flask-SocketIO使Flask应用程序能够访问客户端和服务器之间的低延迟双向通信。客户端应用程序可以使用 Javascript，C ++，Java和Swift中的任何SocketIO官方客户端库或任何兼容的客户端来建立与服务器的永久连接。
安装
您可以使用pip以下方式以常规方式安装此软件包：
pip install flask-socketio
要求
Flask-SocketIO兼容Python 2.7和Python 3.3+。可以从以下三个选项中选择此程序包所依赖的异步服务：
- eventlet是性能最佳的选项，支持长轮询和WebSocket传输。
- gevent在许多不同的配置中得到支持。gevent包完全支持长轮询传输，但与eventlet不同，gevent没有本机WebSocket支持。要添加对WebSocket的支持，目前有两种选择。安装gevent-websocket 包为gevent增加了WebSocket支持，或者可以使用带有WebSocket功能的uWSGI Web服务器。gevent的使用也是一种高性能选项，但略低于eventlet。
- 也可以使用基于Werkzeug的Flask开发服务器，但需要注意的是它缺乏其他两个选项的性能，因此它只应用于简化开发工作流程。此选项仅支持长轮询传输。
扩展会根据安装的内容自动检测要使用的异步框架。优先考虑eventlet，然后是gevent。对于gevent中的WebSocket支持，首选uWSGI，然后是gevent-websocket。如果既未安装eventlet也未安装gevent，则使用Flask开发服务器。
如果使用多个进程，则进程使用消息队列服务来协调诸如广播之类的操作。支持的队列是 Redis，RabbitMQ以及Kombu软件包支持的任何其他消息队列 。
在客户端，官方Socket.IO Javascript客户端库可用于建立与服务器的连接。还有使用Swift，Java和C ++编写的官方客户端。非官方客户端也可以工作，只要它们实现Socket.IO协议。
初始化
以下代码示例演示如何将Flask-SocketIO添加到Flask应用程序：
from flask import Flask, render_template
from flask_socketio import SocketIO
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)
if __name__ == '__main__':
socketio.run(app)
init_app()还支持初始化的样式。请注意Web服务器的启动方式。该socketio.run()函数封装了Web服务器的启动并替换了app.run()标准的Flask开发服务器启动。当应用程序处于调试模式时，Werkzeug开发服务器仍然在内部使用和配置正确socketio.run()。在生产模式中，如果可用，则使用eventlet Web服务器，否则使用gevent Web服务器。如果未安装eventlet和gevent，则使用Werkzeug开发Web服务器。
还支持基于Flask 0.11中引入的单击的命令行界面。此扩展提供了适用于启动Socket.IO服务器的新版本 命令。用法示例：flask run
$ FLASK_APP=my_app.py flask run
应用程序必须为加载Socket.IO库并建立连接的客户端提供页面：
<script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/socket.io/1.3.6/socket.io.min.js"></script>
<script type="text/javascript" charset="utf-8">
var socket = io.connect('http://' + document.domain + ':' + location.port);
socket.on('connect', function() {
socket.emit('my event', {data: 'I\'m connected!'});
});
</script>
接收消息
使用SocketIO时，双方都会将消息作为事件接收。在客户端使用Javascript回调。使用Flask-SocketIO，服务器需要为这些事件注册处理程序，类似于视图函数处理路由的方式。
以下示例为未命名的事件创建服务器端事件处理程序：
@socketio.on('message')
def handle_message(message):
print('received message: ' + message)
上面的示例使用字符串消息。另一种类型的未命名事件使用JSON数据：
@socketio.on('json')
def handle_json(json):
print('received json: ' + str(json))
最灵活的事件类型使用自定义事件名称。这些事件的消息数据可以是字符串，字节，整数或JSON：
@socketio.on('my event')
def handle_my_custom_event(json):
print('received json: ' + str(json))
自定义命名事件也可以支持多个参数：
@socketio.on('my event')
def handle_my_custom_event(arg1, arg2, arg3):
print('received args: ' + arg1 + arg2 + arg3)
命名事件是最灵活的，因为它们不需要包含额外的元数据来描述消息类型。
Flask-SocketIO还支持SocketIO命名空间，允许客户端在同一物理套接字上复用多个独立连接：
@socketio.on('my event', namespace='/test')
def handle_my_custom_namespace_event(json):
print('received json: ' + str(json))
如果未指定名称空间，'/'则使用具有名称的默认全局名称空间 。
对于装饰器语法不方便的情况，on_event可以使用该方法：
def my_function_handler(data):
pass
socketio.on_event('my event', my_function_handler, namespace='/test')
客户端可以请求确认回叫，确认收到他们发送的消息。处理函数返回的任何值都将作为回调函数中的参数传递给客户端：
@socketio.on('my event')
def handle_my_custom_event(json):
print('received json: ' + str(json))
return 'one', 2
在上面的示例中，将使用两个参数调用客户端回调函数，'one'和2。如果处理程序函数未返回任何值，则将调用客户端回调函数而不带参数。
发送消息
如上一节所示定义的SocketIO事件处理程序可以使用send()和emit() 函数将回复消息发送到连接的客户端。
以下示例将收到的事件退回给发送它们的客户端：
from flask_socketio import send, emit
@socketio.on('message')
def handle_message(message):
send(message)
@socketio.on('json')
def handle_json(json):
send(json, json=True)
@socketio.on('my event')
def handle_my_custom_event(json):
emit('my response', json)
注意如何send()和emit()分别用于无名和命名事件。
当有命名空间的工作，send()并emit()默认使用传入消息的命名空间。可以使用可选namespace参数指定不同的命名空间：
@socketio.on('message')
def handle_message(message):
send(message, namespace='/chat')
@socketio.on('my event')
def handle_my_custom_event(json):
emit('my response', json, namespace='/chat')
要发送具有多个参数的事件，请发送元组：
@socketio.on('my event')
def handle_my_custom_event(json):
emit('my response', ('foo', 'bar', json), namespace='/chat')
SocketIO支持确认回调，确认客户端收到了一条消息：
def ack():
print 'message was received!'
@socketio.on('my event')
def handle_my_custom_event(json):
emit('my response', json, callback=ack)
使用回调时，Javascript客户端会收到一个回调函数，以便在收到消息时调用。客户端应用程序调用回调函数后，服务器将调用相应的服务器端回调。如果使用参数调用客户端回调，则这些回调也作为服务器端回调的参数提供。
广播
SocketIO的另一个非常有用的功能是广播消息。烧瓶SocketIO支持通过此功能broadcast=True可选参数send()和emit()：
@socketio.on('my event')
def handle_my_custom_event(data):
emit('my response', data, broadcast=True)
在启用广播选项的情况下发送消息时，连接到命名空间的所有客户端都会接收它，包括发件人。如果未使用名称空间，则连接到全局名称空间的客户端将收到该消息。请注意，不会为广播消息调用回调。
在此处显示的所有示例中，服务器响应客户端发送的事件。但对于某些应用程序，服务器需要是消息的发起者。这对于向客户端发送通知在服务器中的事件（例如在后台线程中）非常有用。该socketio.send()和socketio.emit()方法可用于广播到所有连接的客户端：
def some_function():
socketio.emit('some event', {'data': 42})
请注意，它socketio.send()与socketio.emit()上下文感知send()和功能不同emit()。另请注意，在上面的用法中没有客户端上下文，因此broadcast=True假设并且不需要指定。
房间
对于许多应用程序，有必要将用户分组为可以一起寻址的子集。最好的例子是具有多个房间的聊天应用程序，其中用户从他们所在的房间或房间接收消息，而不是从其他用户所在的其他房间接收消息。烧瓶SocketIO支持通过房间的概念join_room()和leave_room()功能：
from flask_socketio import join_room, leave_room
@socketio.on('join')
def on_join(data):
username = data['username']
room = data['room']
join_room(room)
send(username + ' has entered the room.', room=room)
@socketio.on('leave')
def on_leave(data):
username = data['username']
room = data['room']
leave_room(room)
send(username + ' has left the room.', room=room)
在send()和emit()函数接受一个可选room导致被发送到所有的都在定房客户端的消息的说法。
所有客户端在连接时都会被分配一个房间，以连接的会话ID命名，可以从中获取request.sid。给定的客户可以加入任何房间，可以给出任何名称。当客户端断开连接时，它将从其所在的所有房间中删除。无上下文socketio.send() 和socketio.emit()函数也接受一个room参数，以广播给房间中的所有客户端。
由于为所有客户端分配了个人房间，为了向单个客户端发送消息，客户端的会话ID可以用作房间参数。
连接事件
Flask-SocketIO还会调度连接和断开连接事件。以下示例显示如何为它们注册处理程序：
@socketio.on('connect', namespace='/chat')
def test_connect():
emit('my response', {'data': 'Connected'})
@socketio.on('disconnect', namespace='/chat')
def test_disconnect():
print('Client disconnected')
连接事件处理程序可以选择返回False以拒绝连接。这样就可以在此时对客户端进行身份验证。
请注意，连接和断开连接事件将在使用的每个命名空间上单独发送。
基于类的命名空间
作为上述基于装饰器的事件处理程序的替代，属于命名空间的事件处理程序可以创建为类的方法。它flask_socketio.Namespace作为基类提供，用于创建基于类的命名空间：
from flask_socketio import Namespace, emit
class MyCustomNamespace(Namespace):
def on_connect(self):
pass
def on_disconnect(self):
pass
def on_my_event(self, data):
emit('my_response', data)
socketio.on_namespace(MyCustomNamespace('/test'))
使用基于类的命名空间时，服务器接收的任何事件都将调度到名为带有on_前缀的事件名称的方法。例如，事件my_event将由名为的方法处理on_my_event。如果收到的事件没有在命名空间类中定义的相应方法，则忽略该事件。基于类的命名空间中使用的所有事件名称必须使用方法名称中合法的字符。
为了方便在基于类的命名空间中定义的方法，命名空间实例包括类中的几个方法的版本，flask_socketio.SocketIO当namespace没有给出参数时，这些方法 默认为正确的命名空间。
如果事件在基于类的命名空间中具有处理程序，并且还有基于装饰器的函数处理程序，则仅调用修饰的函数处理程序。
错误处理
Flask-SocketIO还可以处理异常：
@socketio.on_error() # Handles the default namespace
def error_handler(e):
pass
@socketio.on_error('/chat') # handles the '/chat' namespace
def error_handler_chat(e):
pass
@socketio.on_error_default # handles all namespaces without an explicit error handler
def default_error_handler(e):
pass
错误处理函数将异常对象作为参数。
还可以使用request.event变量检查当前请求的消息和数据参数，这对于事件处理程序外部的错误记录和调试很有用：
from flask import request
@socketio.on("my error event")
def on_my_event(data):
raise RuntimeError()
@socketio.on_error_default
def default_error_handler(e):
print(request.event["message"]) # "my error event"
print(request.event["args"]) # (data,)
进入瓶的上下文全局
SocketIO事件的处理程序与路由处理程序不同，并且引入了很多关于SocketIO处理程序中可以做什么和不能做什么的混淆。主要区别在于为客户端生成的所有SocketIO事件都发生在单个长时间运行请求的上下文中。
尽管存在差异，但Flask-SocketIO试图通过使环境类似于常规HTTP请求来更轻松地使用SocketIO事件处理程序。以下列表描述了哪些有效，哪些无效：
- 应用程序上下文调用的事件处理决策前推
current_app，并g提供给处理器。 - 在调用处理程序之前也会推送请求上下文，同时生成
request和session可用。但请注意，WebSocket事件没有与之关联的单个请求，因此针对在连接生命期间调度的所有事件，将推送启动连接的请求上下文。 - 使用设置为连接的唯一会话ID
request的sid成员来增强上下文全局。此值用作添加客户端的初始房间。 - 在
request全球范围内进行了增强namespace，并event包含目前正在处理的命名空间和事件参数的成员。该event成员是带有message和args键的字典。 - 该
sessioncontext global的行为方式与常规请求的行为方式不同。在建立SocketIO连接时，用户会话的副本可供在该连接的上下文中调用的处理程序使用。如果SocketIO处理程序修改了会话，则将为未来的SocketIO处理程序保留修改后的会话，但常规HTTP路由处理程序将不会看到这些更改。实际上，当SocketIO处理程序修改会话时，会为这些处理程序专门创建会话的“分支”。此限制的技术原因是，为了保存用户会话，需要将cookie发送到客户端，并且需要HTTP请求和响应，这在SocketIO连接中不存在。使用Flask-Session或Flask-KVSession扩展提供的服务器端会话时， - 在
before_request和after_request钩子不调用的SocketIO事件处理程序。 - SocketIO处理程序可以使用自定义装饰器，但是大多数Flask装饰器都不适合用于SocketIO处理程序，因为
Response在SocketIO连接期间没有对象的概念。
认证
应用程序的常见需求是验证其用户的身份。基于Web表单和HTTP请求的传统机制不能在SocketIO连接中使用，因为没有地方可以发送HTTP请求和响应。如有必要，应用程序可以实现自定义登录表单，当用户按下提交按钮时，该表单将凭证作为SocketIO消息发送到服务器。
但是，在大多数情况下，在建立SocketIO连接之前执行传统的身份验证过程会更方便。然后可以将用户的身份记录在用户会话或cookie中，稍后当建立SocketIO连接时，SocketIO事件处理程序可以访问该信息。
使用烧瓶登录用的烧瓶SocketIO
Flask-SocketIO可以访问Flask-Login维护的登录信息 。执行常规Flask-Login身份验证并login_user() 调用该函数以在用户会话中记录用户后，任何SocketIO连接都可以访问current_user上下文变量：
@socketio.on('connect')
def connect_handler():
if current_user.is_authenticated:
emit('my response',
{'message': '{0} has joined'.format(current_user.name)},
broadcast=True)
else:
return False # not allowed here
请注意，login_required装饰器不能与SocketIO事件处理程序一起使用，但可以按如下方式创建断开未经身份验证的用户的自定义装饰器：
import functools
from flask import request
from flask_login import current_user
from flask_socketio import disconnect
def authenticated_only(f):
@functools.wraps(f)
def wrapped(*args, **kwargs):
if not current_user.is_authenticated:
disconnect()
else:
return f(*args, **kwargs)
return wrapped
@socketio.on('my event')
@authenticated_only
def handle_my_custom_event(data):
emit('my response', {'message': '{0} has joined'.format(current_user.name)},
broadcast=True)
部署
部署Flask-SocketIO服务器有很多选择，从简单到复杂。在本节中，描述了最常用的选项。
嵌入式服务器
最简单的部署策略是安装eventlet或gevent，并通过调用启动Web服务器，socketio.run(app)如上面的示例所示。这将在eventlet或gevent Web服务器上运行应用程序，无论哪个安装。
请注意，socketio.run(app)在安装eventlet或gevent时运行生产就绪服务器。如果这两个都没有安装，那么应用程序将在Flask的开发Web服务器上运行，该服务器不适合生产使用。
不幸的是，将gevent与uWSGI一起使用时，此选项不可用。有关此选项的信息，请参阅下面的uWSGI部分。
Gunicorn Web服务器
另一种方法socketio.run(app)是使用 gunicorn作为Web服务器，使用eventlet或gevent worker。对于此选项，除了gunicorn之外，还需要安装eventlet或gevent。通过gunicorn启动eventlet服务器的命令行是：
gunicorn --worker-class eventlet -w 1 module:app
如果您更喜欢使用gevent，则启动服务器的命令是：
gunicorn -k gevent -w 1 module:app
当使用gunicorn和gevent worker以及gevent-websocket提供的WebSocket支持时，必须更改启动服务器的命令以选择支持WebSocket协议的自定义gevent Web服务器。修改后的命令是：
gunicorn -k geventwebsocket.gunicorn.workers.GeventWebSocketWorker -w 1 module:app
在所有这些命令中，module是定义应用程序实例的Python模块或包，它app是应用程序实例本身。
由于gunicorn使用的负载平衡算法有限，因此在使用此Web服务器时不可能使用多个工作进程。出于这个原因，上面的所有例子都包括选项。-w 1
uWSGI Web服务器
将uWSGI服务器与gevent结合使用时，Socket.IO服务器可以利用uWSGI的本机WebSocket支持。
有关uWSGI服务器的配置和使用的完整说明超出了本文档的范围。uWSGI服务器是一个相当复杂的包，提供了大量全面的选项。它必须使用WebSocket和SSL编译进行编译，以便WebSocket传输可用。作为介绍的方式，以下命令为端口5000上的示例应用程序app.py启动uWSGI服务器：
$ uwsgi --http :5000 --gevent 1000 --http-websockets --master --wsgi-file app.py --callable app
使用nginx作为WebSocket反向代理
可以使用nginx作为将请求传递给应用程序的前端反向代理。但是，只有nginx 1.4版本和更新版本支持代理WebSocket协议。以下是代理HTTP和WebSocket请求的基本nginx配置：
server {
listen 80;
server_name _;
location / {
include proxy_params;
proxy_pass http://127.0.0.1:5000;
}
location /socket.io {
include proxy_params;
proxy_http_version 1.1;
proxy_buffering off;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "Upgrade";
proxy_pass http://127.0.0.1:5000/socket.io;
}
}
下一个示例添加了对多个Socket.IO服务器进行负载平衡的支持：
upstream socketio_nodes {
ip_hash;
server 127.0.0.1:5000;
server 127.0.0.1:5001;
server 127.0.0.1:5002;
# to scale the app, just add more nodes here!
}
server {
listen 80;
server_name _;
location / {
include proxy_params;
proxy_pass http://127.0.0.1:5000;
}
location /socket.io {
include proxy_params;
proxy_http_version 1.1;
proxy_buffering off;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "Upgrade";
proxy_pass http://socketio_nodes/socket.io;
}
}
虽然上面的示例可以作为初始配置，但请注意，nginx的生产安装需要更完整的配置，涵盖其他部署方面，例如提供静态文件资产和SSL支持。
使用多个工人
从2.0版本开始，Flask-SocketIO支持负载均衡器后面的多个工作人员。部署多个工作程序使使用Flask-SocketIO的应用程序能够在多个进程和主机之间传播客户端连接，并以此方式扩展以支持大量并发客户端。
使用多个Flask-SocketIO工作器有两个要求：
- 必须将负载均衡器配置为始终将来自给定客户端的所有HTTP请求转发给同一工作程序。这有时被称为“粘性会话”。对于nginx，使用该
ip_hash指令来实现此目的。Gunicorn不能与多个worker一起使用，因为它的负载均衡器算法不支持粘性会话。 - 由于每个服务器仅拥有客户端连接的子集，因此服务器使用诸如Redis或RabbitMQ之类的消息队列来协调诸如广播和房间之类的复杂操作。
使用消息队列时，需要安装其他依赖项：
- 对于Redis，
redis必须安装包（）。pip install redis - 对于RabbitMQ，
kombu必须安装包（）。pip install kombu - 对于Kombu支持的其他消息队列，请参阅Kombu文档 以找出所需的依赖项。
- 如果使用了eventlet或gevent，那么通常需要猴子修补Python标准库来强制消息队列包使用协程友好函数和类。
要启动多个Flask-SocketIO服务器，必须首先确保运行消息队列服务。要启动Socket.IO服务器并将其连接到消息队列，请将该message_queue参数添加到SocketIO构造函数：
socketio = SocketIO(app, message_queue='redis://')
message_queue参数的值是使用的队列服务的连接URL。对于在与服务器相同的主机上运行的redis队列，'redis://'可以使用URL。同样，对于默认的RabbitMQ队列，'amqp://'可以使用URL。Kombu软件包有一个文档部分 ，描述了所有支持的队列的URL格式。
从外部进程发出
对于许多类型的应用程序，必须从不是SocketIO服务器的进程发出事件，例如Celery工作者。如果SocketIO服务器或服务器配置为侦听消息队列，如上一节所示，那么任何其他进程都可以创建自己的 SocketIO实例，并使用它以与服务器相同的方式发出事件。
例如，对于在eventlet Web服务器上运行并使用Redis消息队列的应用程序，以下Python脚本会向所有客户端广播事件：
socketio = SocketIO(message_queue='redis://')
socketio.emit('my event', {'data': 'foo'}, namespace='/test')
SocketIO以这种方式使用实例时，Flask应用程序实例不会传递给构造函数。
该channel参数SocketIO可以用来选择通过消息队列通信的特定信道。当有多个独立的SocketIO服务共享同一队列时，必须使用自定义通道名称。
使用eventlet或gevent时，Flask-SocketIO不应用猴子修补。但是当使用消息队列时，如果Python标准库没有进行猴子修补，那么与消息队列服务对话的Python包很可能会挂起。
需要注意的是，想要连接到SocketIO服务器的外部进程不需要像主服务器那样使用eventlet或gevent。让服务器使用协程框架，而外部进程不是问题。例如，Celery worker不需要配置为仅使用eventlet或gevent，因为主服务器就是这样。但是如果您的外部进程出于某种原因确实使用了协程框架，则可能需要进行猴子修补，以便消息队列访问协程友好函数和类。
升级到烧瓶SocketIO 1.x和2.x从0.X版本
旧版本的Flask-SocketIO有一套完全不同的要求。那些旧版本依赖于 gevent-socketio和 gevent-websocket，这在1.0版本中是不需要的。
尽管依赖项发生了变化，但1.0版本中并未引入太多重大更改。以下是实际差异的详细列表：
- 1.0版本支持Python 2.6，并增加了对Python 3.3，Python 3.4和pypy的支持。
- 发布0.x需要旧版本的Socket.IO Javascript客户端。从1.0版开始，支持当前版本的Socket.IO和Engine.IO。不支持在1.0之前发布Socket.IO客户端。现在也支持Swift和C ++官方Socket.IO客户端。
- 0.x版本取决于gevent，gevent-socketio和gevent-websocket。在1.0版本中，不再使用gevent-socketio，而gevent是后端Web服务器的三个选项之一，包括eventlet和任何常规的多线程WSGI服务器，包括Flask的开发Web服务器。
- 版本1.0中的Socket.IO服务器选项已更改。它们可以在SocketIO构造函数中提供，也可以在
run()调用中提供。这两个中提供的选项在使用之前合并。 - 0.x版本暴露了gevent-socketio连接
request.namespace。在1.0版本中，此功能不再可用。请求对象定义request.namespace为正在处理的命名空间的名称，并添加request.sid，定义为客户端连接的唯一会话ID，并且request.event包含事件名称和参数。 - 要获取客户端在0.x版本中的房间列表，需要应用程序使用gevent-socketio的私有结构和表达式
request.namespace.rooms。这在版本1.0中不可用，它包含一个正确的rooms()功能。 - 向单个客户发送消息的推荐“技巧”是将每个客户端放在一个单独的房间中，然后将消息发送到所需的房间。这在版本1.0中正式化，客户端在连接时会自动分配一个房间。
'connect'全局命名空间的事件未在1.0之前的版本上触发。这已得到修复，现在此事件将按预期触发。- 1.0版中引入了对客户端回调的支持。
要升级到较新的Flask-SocketIO版本，您需要将Socket.IO客户端升级到与Socket.IO 1.0协议兼容的客户端。对于JavaScript客户端，1.3.x和1.4.x版本已经过广泛测试并且兼容。
在服务器端，有几点需要考虑：
- 如果你想继续使用gevent，那么从你的虚拟环境中卸载gevent-socketio，因为这个包不再使用了，可能会与它的替换python-socketio发生冲突。
- 如果您希望稍微提高性能和稳定性，那么建议您切换到eventlet。为此，请卸载gevent，gevent-socketio和gevent-websocket，然后安装eventlet。
- 如果您的应用程序使用猴子修补并切换到eventlet，请调用eventlet.monkey_patch（）而不是gevent的monkey.patch_all（）。此外，任何对gevent的调用都必须替换为对eventlet的等效调用。
- 必须使用对Flask-SocketIO函数的直接调用替换request.namespace的任何用法。例如，request.namespace.rooms必须替换为rooms（）函数。
- 必须删除内部gevent-socketio对象的任何使用，因为此包不再是依赖项。
API参考
class flask_socketio.SocketIO（app = None，** kwargs ）
创建Flask-SocketIO服务器。
| 参数： |
|
|---|
Socket.IO服务器选项详述如下：
| 参数： |
|
|---|
Engine.IO服务器配置支持以下设置：
| 参数： |
|
|---|
on（message，namespace = None ）
Decorator注册一个SocketIO事件处理程序。
此装饰器必须应用于SocketIO事件处理程序。例：
@socketio.on('my event', namespace='/chat')
def handle_my_custom_event(json):
print('received json: ' + str(json))
| 参数： |
|
|---|
on_error（namespace = None ）
Decorator为SocketIO事件定义自定义错误处理程序。
此装饰器可以应用于充当命名空间的错误处理程序的函数。当SocketIO事件处理程序引发异常时，将调用此处理程序。处理函数必须接受一个参数，这是引发的异常。例：
@socketio.on_error(namespace='/chat')
def chat_error_handler(e):
print('An error has occurred: ' + str(e))
| 参数： | namespace - 要为其注册错误处理程序的命名空间。默认为全局命名空间。 |
|---|
on_error_default（exception_handler ）
Decorator为SocketIO事件定义默认错误处理程序。
此装饰器可以应用于一个函数，该函数充当任何没有特定处理程序的命名空间的缺省错误处理程序。例：
@socketio.on_error_default
def error_handler(e):
print('An error has occurred: ' + str(e))
on_event（message，handler，namespace = None ）
注册SocketIO事件处理程序。
on_event是非装饰版的'on'。
例：
def on_foo_event(json):
print('received json: ' + str(json))
socketio.on_event('my event', on_foo_event, namespace='/chat')
| 参数： |
|
|---|
emit（事件，* args，** kwargs ）
发出服务器生成的SocketIO事件。
此函数向一个或多个连接的客户端发出SocketIO事件。JSON blob可以作为有效负载附加到事件。此函数可以在SocketIO事件上下文之外使用，因此在服务器是任何客户端上下文之外的事件的发起者时使用是合适的，例如在常规HTTP请求处理程序或后台任务中。例：
@app.route('/ping')
def ping():
socketio.emit('ping event', {'data': 42}, namespace='/chat')
| 参数： |
|
|---|
send（data，json = False，namespace = None，room = None，callback = None，include_self = True，skip_sid = None，** kwargs ）
发送服务器生成的SocketIO消息。
此函数将一个简单的SocketIO消息发送到一个或多个连接的客户端。消息可以是字符串或JSON blob。这是一个更简单的版本emit()，应该是首选。此函数可以在SocketIO事件上下文之外使用，因此在服务器是事件的发起者时使用它是合适的。
| 参数： |
|
|---|
close_room（房间，命名空间=无）
关闭一个房间。
此功能将删除给定房间中的所有用户，然后从服务器中删除该房间。此函数可以在SocketIO事件上下文之外使用。
| 参数： |
|
|---|
run（app，host = None，port = None，** kwargs ）
运行SocketIO Web服务器。
| 参数： |
|
|---|
stop（）
停止正在运行的SocketIO Web服务器。
必须从HTTP或SocketIO处理函数调用此方法。
start_background_task（目标，* args，** kwargs ）
使用适当的异步模型启动后台任务。
这是一个实用程序函数，应用程序可以使用与所选异步模式兼容的方法启动后台任务。
| 参数： |
|
|---|
此函数返回与Python标准库中的Thread类兼容的对象。此函数已调用此对象的start（）方法。
sleep（秒= 0 ）
使用适当的异步模型睡眠所需的时间。
这是一个实用程序功能，应用程序可以使用该功能将任务置于睡眠状态，而无需担心对所选的异步模式使用正确的调用。
test_client（app，namespace = None，query_string = None，headers = None ）
返回一个可用于单元测试的简单SocketIO客户端。
flask_socketio.emit（事件，* args，** kwargs ）
发出SocketIO事件。
此函数向一个或多个连接的客户端发出SocketIO事件。JSON blob可以作为有效负载附加到事件。这是一个只能从SocketIO事件处理程序调用的函数，就像从当前客户端上下文中获取一些信息一样。例：
@socketio.on('my event')
def handle_my_custom_event(json):
emit('my response', {'data': 42})
| 参数： |
|
|---|
flask_socketio.send（消息，** kwargs ）
发送SocketIO消息。
此函数将一个简单的SocketIO消息发送到一个或多个连接的客户端。消息可以是字符串或JSON blob。这是一个更简单的版本emit()，应该是首选。这是一个只能从SocketIO事件处理程序调用的函数。
| 参数： |
|
|---|
flask_socketio.join_room（room，sid = None，namespace = None ）
加入一个房间。
此函数将用户置于当前名称空间下的房间中。用户和命名空间是从事件上下文中获取的。这是一个只能从SocketIO事件处理程序调用的函数。例：
@socketio.on('join')
def on_join(data):
username = session['username']
room = data['room']
join_room(room)
send(username + ' has entered the room.', room=room)
| 参数： |
|
|---|
flask_socketio.leave_room（room，sid = None，namespace = None ）
离开房间。
此函数将用户从当前名称空间下的房间中删除。用户和命名空间是从事件上下文中获取的。例：
@socketio.on('leave')
def on_leave(data):
username = session['username']
room = data['room']
leave_room(room)
send(username + ' has left the room.', room=room)
| 参数： |
|
|---|
flask_socketio.close_room（房间，命名空间=无）
关闭一个房间。
此功能将删除给定房间中的所有用户，然后从服务器中删除该房间。
| 参数： |
|
|---|
flask_socketio.rooms（sid = None，namespace = None ）
返回客户所在房间的列表。
此函数返回客户端输入的所有房间，包括由Socket.IO服务器分配的自己的房间。
| 参数： |
|
|---|
flask_socketio.disconnect（sid = None，namespace = None，silent = False ）
断开客户端。
此函数终止与客户端的连接。作为此调用的结果，客户端将收到断开连接事件。例：
@socketio.on('message')
def receive_message(msg):
if is_banned(session['username']):
disconnect()
else:
# ...
| 参数： |
|
|---|
class flask_socketio.Namespace（namespace = None ）
trigger_event（event，* args ）
将事件分派给正确的处理程序方法。
在最常见的用法中，子方法不会重载此方法，因为它执行事件到方法的路由。但是，如果需要特殊的调度规则，或者如果需要使用单个方法捕获所有事件，则可以覆盖此方法。
emit（event，data = None，room = None，include_self = True，namespace = None，callback = None ）
向一个或多个连接的客户端发送自定义事件。
send（data，room = None，include_self = True，namespace = None，callback = None ）
向一个或多个连接的客户端发送消息。
close_room（房间，命名空间=无）
关闭一个房间。
类flask_socketio.SocketIOTestClient（应用程序，socketio，命名空间=无，QUERY_STRING =无，标题=无）
此类对于测试Flask-SocketIO服务器很有用。它的工作方式与Flask Test Client类似，但适用于Socket.IO服务器。
| 参数： |
|
|---|
connect（namespace = None，query_string = None，headers = None ）
连接客户端。
| 参数： |
|
|---|
请注意，通常不必显式调用此方法，因为在创建此类的实例时会自动建立连接。此方法有用的示例是应用程序接受多个命名空间连接时。
disconnect（namespace = None ）
断开客户端。
| 参数： | namespace - 要断开连接的命名空间。如果未提供此参数，则假定全局命名空间。 |
|---|
emit（事件，* args，** kwargs ）
向服务器发送事件。
| 参数： |
|
|---|
send（data，json = False，callback = False，namespace = None ）
将文本或JSON消息发送到服务器。
| 参数： |
|
|---|
get_received（namespace = None ）
返回从服务器收到的消息列表。
由于这不是真正的客户端，因此只要服务器发出事件，就会存储该事件。测试代码可以调用此方法来获取自上次调用以来收到的事件列表。
| 参数： | namespace - 从中获取事件的命名空间。如果未提供此参数，则假定全局命名空间 |
|---|
扫一扫
5978
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
