twisted的入门讲解

原文链接: http://blog.csdn.net/zhthl20091003/article/details/7699154
生硬、苦涩，劳神费劲。 

Twisted，恰如其名，不折不扣的“弯弯绕“。 

啃嚼过程，多半是体力活，不停地点击mouse，从API文档到源代码，跳来跳去，四处寻觅。 

真累。手酸、眼花、头晕、心烦，精神健康大致进入“亚”级状态了。呵呵。 

最大的痛苦是不知所云。这个framework够诡异的。 

但愿逐渐适应它的套路，尽早解开这个“弯弯绕“。 

Twisted应用的基本问题，可说是“一个中心，两个基本点”，即： 

以“事件”event为中心，以"建立连接"connect和“定义反馈“callback为基本点。 

在这些问题上，Twisted有一整套固定的路数，只能照章行事，没有自由发挥的余地。 



一、windows下的软件包里没有文档，还需下载unix下的软件包。两个包分别是： 
Twisted_NoDocs-2.1.0.win32-py2.4.exe 
Twisted-2.1.0.tar 

二、文档没有API的，只能上网抓 
我用teleport pro抓下它的API的全部在线文档，总共34MB，是软件包的17倍。 

三、文档做得粗糙，比java的差远了，只能将就用吧。 

四、它有个package叫internet，里面有个管理标准I/O的模块stdio.py，它import了fdesc.py，fdesc.py又import了fcnt1.py。缺了这个文件，无法使用stdio。 
这个fcnt1.py是属于python的，但是，windows下的python却没有fcnt1.py，致使有的例程无法运行。





啃嚼快一星期了，不再痛苦难受，逐渐尝出twisted的香甜美味、柔顺可口，开始适应twisted的套路。 

twisted的套路，有哪些显著特点呢？接下去说说我品尝出的滋味。 

前面把twisted的套路概括成一句话，“一个中心，两个基本点”，现在就从这个“中心”聊起。 

Twisted 官方说，“ Twisted is an event-driven networking framework ”。事实的确如此。从其运行机制上看，event 是 Twisted 运转的引擎，是发生各种动作的启动器，是牵一发而动全身的核心部件。从其架构组成上看，它是紧密围绕event设计的；它的具体应用 application，主要是定义、实现各式各样的event，由此完成不同网络协议的连接和输入输出任务，满足用户的实际需求；从其 application的文本形式上，可以直接看到，它的应用程序，基本上由一系列event构成。 

由此可见，说它以event为中心，符合实际情况。 

Twisted 对event 的管理机制，可划分为后台和前台两种形式。 

后台的管理，是Twisted 框架的内在机制，自动运行，对程序员透明无须干预，在程序文本中不见其踪迹。 

前台的管理，是Twisted 授权程序员，在程序文本中显式写码来实现。程序员的工作，主要是按照既定的方式，实现 event。我们所关心、所用到的，是这部分东西（API）。 

Twisted 众多的 event，分门别类、层次有序。前台管理中，有两个特别的 object，一个叫 reactor ，另一个叫defered。特别之处，在于它俩起着“事件管理器”的作用。下面，说说它俩。 

一、统领全局的 reactor 

在 Twisted 应用中，reactor 的任务是为程序运行建立必须的全局循环（event loop），所起的作用，相当于 Python 应用中的 MainLoop()。 

reactor 的用法很简单，一般只用两个：reactor.run() 启动全局循环，reactor.stop() 停止全局循环（程序终止）。 

如果程序中没有调用reactor.stop() 的语句，程序将处于死循环，可以按键 Ctrl-C 强制退出。 

下面是一个例子： 

from twisted.internet import reactor 

import time 

def printTime( ): 

print "Current time is", time.strftime("%H:%M:%S") 


def stopReactor( ): 

print "Stopping reactor" 

reactor.stop( ) 


reactor.callLater(1, printTime) 
#定时器，1秒钟后调用printTime() 

reactor.callLater(2, printTime) 

reactor.callLater(3, printTime) 

reactor.callLater(5, stopReactor) 
#定时器，5秒钟后调用stopReactor() 

print "Running the reactor..." 

reactor.run( ) 

print "Reactor stopped." 

二、提升效率的 defferred 

Twisted 官方称，“Twisted is event-based, asynchronous framework ”。这个“异步”功能的代表就是 defferred。 

defferred 的作用类似于“多线程”，负责保障多头连接、多项任务的异步执行。 

当然，defferred “异步”功能的实现，与多线程完全不同，具有以下特点： 

１、defferred 产生的 event，是函数调用返回的对象； 

２、defferred 代表一个连接任务，负责报告任务执行的延迟情况和最终结果； 

３、对defferred 的操作，通过预定的“事件响应器”（event handler）进行。 

有了defferred，即可对任务的执行进行管理控制。防止程序的运行，由于等待某项任务的完成而陷入阻塞停滞，提高整体运行的效率。 

请看下面的例子： 

建议只关注黑体字的语句，它们反映了defferred的用法。涉及的两个class，是Twisted建立网络连接的固定套路，后面会专门说它。 

# connectiontest.py 
from twisted.internet import reactor, defer, protocol 

class CallbackAndDisconnectProtocol(protocol.Protocol): 
# Twisted建立网络连接的固定套路 

def connectionMade(self): 

self.factory.deferred.callback("Connected!") 
# “事件响应器”handleSuccess对此事件作出处理 

self.transport.loseConnection( ) 


class ConnectionTestFactory(protocol.ClientFactory): 
# Twisted建立网络连接的固定套路 

protocol = CallbackAndDisconnectProtocol 

def __init__(self): 

self.deferred = defer.Deferred( ) 
# 报告发生了延迟事件，防止程序阻塞在这个任务上 

def clientConnectionFailed(self, connector, reason): 

self.deferred.errback(reason) 
# “事件响应器”handleFailure对此事件作出处理 

def testConnect(host, port): 

testFactory = ConnectionTestFactory( ) 

reactor.connectTCP(host, port, testFactory) 

return testFactory.deferred 
# 返回连接任务的deferred 


def handleSuccess(result, port): 
# deferred“事件响应器”：连接任务完成的处理 

print "Connected to port %i" % port 

reactor.stop( ) 


def handleFailure(failure, port): 
# deferred“事件响应器”：连接任务失败的处理 

print "Error connecting to port %i: %s" % ( 

port, failure.getErrorMessage( )) 

reactor.stop( ) 


if __name__ == "__main__": 

import sys 

if not len(sys.argv) == 3: 

print "Usage: connectiontest.py host port" 

sys.exit(1) 


host = sys.argv[1] 

port = int(sys.argv[2]) 

connecting = testConnect(host, port) 
# 调用函数，返回deferred 

connecting.addCallback(handleSuccess, port) 
# 建立deferred“事件响应器” 

connecting.addErrback(handleFailure, port) 
# 建立deferred“事件响应器” 

reactor.run( ) 

三、创建 client 的套路 

第二节说到的两个类，是ＴＣＰ协议客户端的创建套路（方式）。这个套路拆解如下： 

１、定义“工厂”和“协议”两个类： 

（１）“协议”类是 CallbackAndDisconnectProtocol，“工厂”类是 ConnectionTestFactory 

类的名字不重要，但必须正确说明所继承的父类： 

class CallbackAndDisconnectProtocol(protocol.Protocol) 

class ConnectionTestFactory(protocol.ClientFactory) 

（２）“协议”类是“工厂”类实例化的：protocol = CallbackAndDisconnectProtocol； 

（３）只在“工厂”类中有 __init__　函数，并在其中实例化一个deferred 对象： 

self.deferred = defer.Deferred( ) 

（４）在“工厂”类中，重设父类函数 clientConnectionFailed，通过deferred 引发事件，报告连接失败： 

self.deferred.errback(reason)　　　　　 

（５）在“协议”类中，重设父类函数 onnectionMade，由对象factory引用“工厂”类中的deferred，经其引发事件，报告连接正常： 

self.factory.deferred.callback("Connected!") 

并由对象transport引发事件，报告连接断开： 

self.transport.loseConnection( )； 

上述“对象”，都是从各自父类继承来的。 


２、在函数testConnect(host, port)中， 

（１）将“工厂”类实例化：testFactory = ConnectionTestFactory( ) 

（２）由全局循环“主持人”reactor建立以testFactory为“主演”的ＴＣＰ连接： 

reactor.connectTCP(host, port, testFactory) 

（３）返回deferred对象：return testFactory.deferred 


至此，一个以事件驱动为基础、异步执行任务的框架程序搭成了。 

上述三节的内容，据 Twisted 官方说，是“学习曲线最陡”的部分（They represent the steepest part of the 

Twisted learning curve.）。 

我的感受，造成“最陡”的原因，是由于套路新颖独特，初学乍练不易适应。 

１、框架对象众多，一时记不牢； 

２、对象之间的关系比较复杂，一时理不清； 

３、“事件驱动”这种模式，反映在程序文本中，有时见不到明显的函数调用，让人觉得程序的去向不明； 

另外，学习方法很重要。如果以学“语言”的习惯来学框架，遇上问题寻根究底，过分追求“水落石出”；或者，依赖教科书、畸重“理论”，忽视 examples 语句、结构和ＡＰＩ文档的分析研究，都不利于翻越这段陡坡。 

据我的体验，集中精力地啃嚼主干骨架，不纠緾于细枝末节，这段最陡的上坡路，顶多爬个十天八天的，就能越过去。