Introduction à la programmation côté serveur WebSocket dans Tornado de Python

Cet article vous présente une introduction à la programmation du serveur WebSocket dans Python's Tornado. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Tornado définit la classe tornado.websocket.WebSocketHandler pour gérer les demandes de liens WebSocket. Les développeurs d'applications doivent hériter de cette classe et implémenter ses fonctions open(), on_message() et on_close().

• Fonction WebSocketHandler.open() : Le framework Tornado appellera cette fonction lorsqu'une nouvelle connexion WebSocket est établie. Dans cette fonction, les développeurs peuvent utiliser la fonction get_argument() pour obtenir les paramètres soumis par le client comme dans get(), post() et d'autres fonctions, et utiliser get_secure_cookie/set_secure_cookir pour faire fonctionner les cookies, etc.

• Fonction WebSocketHandler.on_message(message) : Après avoir établi le lien WebSocket, le framework Tornado appellera cette fonction lorsqu'un message du client est reçu. Il s'agit généralement de la fonction principale de la programmation WebSocket côté serveur, qui traite le message reçu en conséquence. Fonction

• WebSocketHandler.on_close() : Lorsque le lien WebSocket est fermé, le framework Tornado appellera cette fonction. Dans cette fonction, vous pouvez interroger la raison de la fermeture en accédant à self.close_code et self.close_reason.

En plus de ces trois fonctions d'entrée automatiquement appelées par le framework Tornado, WebSocketHandler propose également deux développeurs pour exploiter activement les fonctions WebSocket.

• Fonction WebSocketHandler.write_message(message,binary=False) : utilisée pour écrire des messages au client relatifs à ce lien. Fonction

• WebSocketHandler.close(code=None,reason=None) : ferme activement le lien WebSocket. Le code et le motif sont utilisés pour indiquer au client pourquoi le lien est fermé. Le code du paramètre doit être une valeur numérique et le motif est une chaîne.

Ce qui suit est le programme Tornado WebSocket qui envoie continuellement des messages horaires au client :

import tornado.ioloop
import tornado.web
import tornado.websocket
from tornado import gen
from tornado.options import define,options,parse_command_line
import asyncio

clients=dict()#客户端Session字典

class IndexHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    @gen.coroutine
    def get(self):
        print("123")
        self.render("index.html")

class MyWebSocketHandler(tornado.websocket.WebSocketHandler):
    def open(self, *args, **kwargs): #有新链接时被调用
        self.id=self.get_argument("Id")
        self.stream.set_nodelay(True)
        clients[self.id]={"id":self.id,"object":self}#保存Session到clients字典中

    def on_message(self, message):#收到消息时被调用
        print("Client %s received a message:%s"%(self.id,message))

    def on_close(self): #关闭链接时被调用
        if self.id in clients:
            del clients[self.id]
            print("Client %s is closed"%(self.id))

    def check_origin(self, origin):
        return True
app=tornado.web.Application([
    (r'/',IndexHandler),
    (r'/websocket',MyWebSocketHandler),
])


import threading
import time
class SendThread(threading.Thread):
    # 启动单独的线程运行此函数，每隔1秒向所有的客户端推送当前时间
    def run(self):
        # tornado 5 中引入asyncio.set_event_loop,不然会报错
        asyncio.set_event_loop(asyncio.new_event_loop())
        import datetime
        while True:
            for key in clients.keys():
                msg = str(datetime.datetime.now())
                clients[key]["object"].write_message(msg)
                print("write to client %s:%s" % (key, msg))
            time.sleep(1)





if __name__ == '__main__':
    #启动推送时间线程
    SendThread().start()
    parse_command_line()
    app.listen(8888)
    #挂起运行
    tornado.ioloop.IOLoop.instance().start()

Le code ci-dessus est analysé comme suit :

• Le dictionnaire de variables globales clients est défini pour enregistrer toutes les informations client qui établissent des liens WebSocket avec le serveur. La clé du dictionnaire est l'identifiant du client, et la valeur est un tuple composé de l'identifiant et de l'instance WebSocketHandler correspondante

• IndexHandler est un processeur de page ordinaire utilisé pour signaler aux clients Rendre le page d'accueil index.html côté client. Cette page contient le programme client WebSocket.

• MyWebSocketHandler est le processeur principal de cet exemple, hérité de tornado.web.WebSocketHandler. La fonction open() enregistre toutes les connexions client au dictionnaire des clients ; on_message() est utilisé pour afficher les messages du client ; on_close() est utilisé pour supprimer les liens WebSocket fermés du dictionnaire des clients.

• La fonction sendTime() s'exécute dans un thread séparé, interroge tous les clients dans les clients toutes les secondes et envoie des messages horaires au client via la fonction MyWebSocketHandler.write_message().

• Dans cet exemple, seules deux routes sont configurées dans l'instance tornado.web.Application, pointant respectivement vers IndexHandler et MyWebSocketHandler, qui sont toujours démarrées et exécutées par Tornado IOLoop.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!