Einführung in die serverseitige WebSocket-Programmierung in Pythons Tornado

Dieser Artikel bietet Ihnen eine Einführung in die WebSocket-Serverprogrammierung in Pythons Tornado. Ich hoffe, dass er Ihnen als Referenz dienen wird.

Tornado definiert die Klasse tornado.websocket.WebSocketHandler zur Verarbeitung von WebSocket-Link-Anfragen. Anwendungsentwickler sollten diese Klasse erben und ihre Funktionen open(), on_message() und on_close() implementieren.

• WebSocketHandler.open()-Funktion: Das Tornado-Framework ruft diese Funktion auf, wenn eine neue WebSocket-Verbindung hergestellt wird. In dieser Funktion können Entwickler die Funktion get_argument() verwenden, um die vom Client übermittelten Parameter wie in get(), post() und anderen Funktionen abzurufen, und get_secure_cookie/set_secure_cookir zum Betreiben von Cookies usw. verwenden.

• WebSocketHandler.on_message(message)-Funktion: Nach dem Herstellen einer WebSocket-Verbindung ruft das Tornado-Framework diese Funktion auf, wenn eine Nachricht vom Client empfangen wird. Normalerweise ist dies die Kernfunktion der serverseitigen WebSocket-Programmierung, die die empfangene Nachricht entsprechend verarbeitet.

• WebSocketHandler.on_close()-Funktion: Wenn der WebSocket-Link geschlossen ist, ruft das Tornado-Framework diese Funktion auf. In dieser Funktion können Sie den Grund für das Schließen abfragen, indem Sie auf self.close_code und self.close_reason zugreifen.

Zusätzlich zu diesen drei vom Tornado-Framework automatisch aufgerufenen Einstiegsfunktionen bietet WebSocketHandler auch zwei Entwicklern die Möglichkeit, WebSocket-Funktionen aktiv zu bedienen.

• WebSocketHandler.write_message(message,binary=False) Funktion: wird verwendet, um Nachrichten an den Client relativ zu diesem Link zu schreiben.

• WebSocketHandler.close(code=None,reason=None) Funktion: WebSocket-Link aktiv schließen. Der Code und der Grund werden verwendet, um dem Client mitzuteilen, warum der Link geschlossen wird. Der Parametercode muss ein numerischer Wert sein und der Grund muss eine Zeichenfolge sein.

Das Folgende ist das Tornado WebSocket-Programm, das kontinuierlich Zeitnachrichten an den Client sendet:

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()

Der obige Code wird wie folgt analysiert:

• Das globale Variablenwörterbuch „Clients“ ist so definiert, dass alle Client-Informationen gespeichert werden, die eine WebSocket-Verbindung mit dem Server herstellen. Der Schlüssel des Wörterbuchs ist die Client-ID, und der Wert ist ein Tupel bestehend aus der ID und der entsprechenden WebSocketHandler-Instanz

• IndexHandler ist ein gewöhnlicher Seitenprozessor, der zum Melden an Clients verwendet wird Homepage index.html auf der Clientseite. Diese Seite enthält das WebSocket-Clientprogramm.

• MyWebSocketHandler ist der Kernprozessor in diesem Beispiel, geerbt von tornado.web.WebSocketHandler. Die open()-Funktion speichert alle Client-Verbindungen im Client-Wörterbuch; on_message() wird verwendet, um Nachrichten vom Client anzuzeigen; on_close() wird verwendet, um geschlossene WebSocket-Links aus dem Client-Wörterbuch zu entfernen.

• Die Funktion sendTime() wird in einem separaten Thread ausgeführt, fragt alle 1 Sekunde alle Clients in Clients ab und sendet Zeitnachrichten über die Funktion MyWebSocketHandler.write_message() an den Client.

• In diesem Beispiel sind nur zwei Routen in der tornado.web.Application-Instanz konfiguriert, die auf IndexHandler bzw. MyWebSocketHandler verweisen, die weiterhin von Tornado IOLoop gestartet und ausgeführt werden.

Das obige ist der detaillierte Inhalt vonEinführung in die serverseitige WebSocket-Programmierung in Pythons Tornado. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!