手动重新加载网页龙卷风

数据更新时是否可以重新加载页面？

import socket
import tornado.ioloop
import tornado.web
import tornado.gen
import tornado.ioloop
import tornado.iostream
import tornado.tcpserver
import os
import tornado.websocket
last_messages = dict()

class TcpClient(object):
    client_id = 0
    def __init__(self, stream):
        super(TcpClient, self).__init__()
        TcpClient.client_id += 1
        self.id = 'Connection#%d' % TcpClient.client_id
        self.stream = stream
        self.stream.socket.setsockopt(
            socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        self.stream.socket.setsockopt(
            socket.IPPROTO_TCP, socket.SO_KEEPALIVE, 1)
        self.stream.set_close_callback(self.on_disconnect)
    @tornado.gen.coroutine
    def on_disconnect(self):
        self.log("disconnected")
        yield []
    @tornado.gen.coroutine
    def dispatch_client(self):
        try:
            while True:
                line = yield self.stream.read_until(b'n')
                text_line = line.decode('utf-8').strip()
                last_messages[self.id] = text_line
                # UPDATE GUI, webpage HERE
                self.log('got |%s|' % text_line)
        except tornado.iostream.StreamClosedError:
            pass
    @tornado.gen.coroutine
    def on_connect(self):
        raddr = 'closed'
        try:
            raddr = '%s:%d' % self.stream.socket.getpeername()
        except Exception:
            pass
        self.log('new, %s' % raddr)
        yield self.dispatch_client()
    def log(self, msg, *args, **kwargs):
        print('[%s] %s' % (self.id, msg.format(*args, **kwargs)))

class TcpServer(tornado.tcpserver.TCPServer):
    @tornado.gen.coroutine
    def handle_stream(self, stream, address):
        connection = TcpClient(stream)
        yield connection.on_connect()

class LastMessagesHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    def get(self):
        self.render(
            'template.html',
            sources=last_messages
        )

class WebSocketHandler(tornado.websocket.WebSocketHandler):
    def on_message(self, message):
        print message
        self.write(last_messages)
def main():
    tcp = TcpServer()
    tcp.listen(8008)
    print('tcp://localhost:8008')
    settings = dict(
        template_path=os.path.join(os.path.dirname(__file__), 'templates'),
        static_path=os.path.join(os.path.dirname(__file__), 'static'),
        debug=True,
    )
    app = tornado.web.Application(
        [
            (r'/', LastMessagesHandler),
            (r'/ws', WebSocketHandler)
        ],
        **settings
    )
    app.listen(8009)
    print('http://localhost:8009')
    tornado.ioloop.IOLoop.instance().start()

if __name__ == "__main__":
    main()

这是template.html

<html>
<head>
<title>TCP server</title>
</head>
<body>
    <title>Tornado WebSockets</title>
    <script src="http://code.jquery.com/jquery-1.9.1.min.js"></script>
    <script>
        jQuery(function($){
          if (!("WebSocket" in window)) {
            alert("Your browser does not support web sockets");
          }else{
            setup();
          }

          function setup() {
            var host = "ws://localhost:8008/ws";
            var socket = new WebSocket(host);
            // event handlers for websocket
            if(socket){
              socket.onopen = function(){
                //alert("connection opened....");
              }
              socket.onmessage = function(msg){
                showServerResponse(msg.data);
              }
              /*socket.onclose = function(){
                //alert("connection closed....");
                showServerResponse("The connection has been closed.");
              }*/
            }else{
              console.log("invalid socket");
            }
            function showServerResponse(txt){
              var p = document.createElement('p');
              p.innerHTML = txt;
              document.getElementById('output').appendChild(p);
            }

          }
        });
    </script>
    <div>
        <ul id="output">
        {% for key, value in sources.iteritems() %}
            <ul> {{key}} |  {{value}} </ul>
        {% end %}
        </ul>
    </div>
</body>
</html>

每当last_messages更改时（smth从dict中删除，smth已添加到dict中），我都需要更新客户端（网页）。我不能用龙卷风网络插座来做这件事。你能帮忙吗？在阅读了套接字中的行之后，我需要更新gui（你可以在代码中找到我需要更新网页的注释：#update gui，webpage HERE）。因此，套接字仍然可以打开（我们正在继续阅读行），但gui必须更新。有可能做到吗？

如果您真的想重新加载页面，那么可以在JavaScript中启动对window.location.reload()的调用。

但是，这将从客户端关闭WebSocket连接。

如果您只想更新DOM（GUI），那么就监听客户端上传入的消息并相应地进行更新。

要观察和跟踪数据变化，您可以使用JavaScript，或者使用Object.observe（如果您仅在现代Chrome上运行），或者使用polyfill，或者使用Backbone.js等现有工具。

如果您选择后者，我还可以推荐一个工具来帮助您使用WebSockets和Backbone。

免责声明：我是Backbone.WS.

的作者

相关内容

最新更新

热门标签：