Python 定期打来电话

我的问题是这样的： 我有一个Twisted服务器，它通过TCP每隔2秒发送一次值，并使用callLater。我有一个twisted客户端，它接收值，并且应该用延迟的方法处理接收值

我的服务器如下所示：

from twisted.internet.protocol import ServerFactory
from twisted.protocols.basic import NetstringReceiver
from random import randint

class ServerProtocol(NetstringReceiver):
    def __init__(self, factory):
        self.factory = factory
        self.sendObject = None

    def connectionMade(self):        
        self.sendValue()

    def connectionLost(self, reason):
        sendObject, self.sendObject = self.sendObject, None
        sendObject.cancel()

    def sendValue(self):
        data = randint(2,20)
        self.sendString(str(data))
        print('send: {0}'.format(data))

        from twisted.internet import reactor
        self.sendObject = reactor.callLater(2, self.sendValue)

class MyServerFactory(ServerFactory):

    def __init__(self):
        self.protsa = []

    def buildProtocol(self, addr):
        return ServerProtocol(self)

    def setCallback(self, callback):
        self.callback = callback    

def serverMain():

    factory = MyServerFactory()
#    factory.setCallback(generateVal)

    from twisted.internet import reactor

    port = reactor.listenTCP(2345, factory, interface='127.0.0.1')     
    print 'Serving on %s.' % (port.getHost())

    reactor.run()


if __name__ == '__main__':
    serverMain()

from twisted.internet.protocol import ClientFactory
from twisted.protocols.basic import NetstringReceiver
from twisted.internet import defer


class ClientProtocol(NetstringReceiver):

    def stringReceived(self, string):
        print("recieved")
        self.factory.printValue(string)

    def connectionMade(self):
        print("Made Connection")

    def connetionLost(self):
        print("Connection Lost")

class MyClientFactory(ClientFactory):

    protocol = ClientProtocol

    def __init__(self, deferred):
        self.deferred = deferred

    def clientConnectionFailed(self, connector, reason):
        if self.deferred is not None:
            d, self.deferred = self.deferred, None
            d.errback(reason)

    def printValue(self, value):
        if self.deferred is not None:
            d, self.deferred = self.deferred, None
            d.callback(value)


def OutputValue(host, port):
    d = defer.Deferred()
    from twisted.internet import reactor
    factory = MyClientFactory(d)
    reactor.connectTCP(host, port, factory)
    return d

def clientMain():

    def writeError(err):
        print("Deferred Error!\n")
        print("Error: {0}".format(err.__str__))

    def writeValue(value):
        print("Value revieved: {0}".format(value))

    from twisted.internet import reactor

    d = OutputValue('127.0.0.1', 2345)
    d.addCallbacks(writeValue, writeError)

    reactor.run()

if __name__ == '__main__':
    clientMain()

我的客户看起来像这样：

from twisted.internet.protocol import ServerFactory
from twisted.protocols.basic import NetstringReceiver
from random import randint

class ServerProtocol(NetstringReceiver):
    def __init__(self, factory):
        self.factory = factory
        self.sendObject = None

    def connectionMade(self):        
        self.sendValue()

    def connectionLost(self, reason):
        sendObject, self.sendObject = self.sendObject, None
        sendObject.cancel()

    def sendValue(self):
        data = randint(2,20)
        self.sendString(str(data))
        print('send: {0}'.format(data))

        from twisted.internet import reactor
        self.sendObject = reactor.callLater(2, self.sendValue)

class MyServerFactory(ServerFactory):

    def __init__(self):
        self.protsa = []

    def buildProtocol(self, addr):
        return ServerProtocol(self)

    def setCallback(self, callback):
        self.callback = callback    

def serverMain():

    factory = MyServerFactory()
#    factory.setCallback(generateVal)

    from twisted.internet import reactor

    port = reactor.listenTCP(2345, factory, interface='127.0.0.1')     
    print 'Serving on %s.' % (port.getHost())

    reactor.run()


if __name__ == '__main__':
    serverMain()

from twisted.internet.protocol import ClientFactory
from twisted.protocols.basic import NetstringReceiver
from twisted.internet import defer


class ClientProtocol(NetstringReceiver):

    def stringReceived(self, string):
        print("recieved")
        self.factory.printValue(string)

    def connectionMade(self):
        print("Made Connection")

    def connetionLost(self):
        print("Connection Lost")

class MyClientFactory(ClientFactory):

    protocol = ClientProtocol

    def __init__(self, deferred):
        self.deferred = deferred

    def clientConnectionFailed(self, connector, reason):
        if self.deferred is not None:
            d, self.deferred = self.deferred, None
            d.errback(reason)

    def printValue(self, value):
        if self.deferred is not None:
            d, self.deferred = self.deferred, None
            d.callback(value)


def OutputValue(host, port):
    d = defer.Deferred()
    from twisted.internet import reactor
    factory = MyClientFactory(d)
    reactor.connectTCP(host, port, factory)
    return d

def clientMain():

    def writeError(err):
        print("Deferred Error!\n")
        print("Error: {0}".format(err.__str__))

    def writeValue(value):
        print("Value revieved: {0}".format(value))

    from twisted.internet import reactor

    d = OutputValue('127.0.0.1', 2345)
    d.addCallbacks(writeValue, writeError)

    reactor.run()

if __name__ == '__main__':
    clientMain()

输出：

Made Connection
recieved
Value revieved: 11
recieved
recieved
recieved

这是第一次一切正常。连接后，服务器发送一个值，客户端接收该值。客户按照自己的意愿延期付款。第二个值不由延迟处理程序处理。我也预料到了，因为延期付款只会被解雇一次。 现在，我希望有一种可能性，通过延迟处理每个接收到的值，这样我也可以进行错误处理

我看了一下：

但我找不到解决问题的办法。这不可能这么不寻常。

---

还是每次都要断开连接

延迟是一个对象，它表示您正在发出的特定请求的结果。但由于一个请求只能有一个相关的响应，就像一个函数只能返回一次一样，一个延迟的请求只能被触发一次

---

您已经有一个函数-

printValue

，该函数在收到值时运行，并且应该打印。为什么不立即打印该函数中的值，而不是查找调用者设置的延迟值呢？

我完全知道，我生成的代码只通过延迟值返回一个值。但我只是在学习twisted，并且在做这个：教程。我在那里得到的印象是，只有使用延迟才能在twisted中正确处理错误。所以我想在这种情况下也使用一个deferred。在这种情况下使用延期付款不会给你带来太多好处。