twisted的入门讲解（很不错）

生硬、苦涩，劳神费劲。

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 语句、结构和ＡＰＩ文档的分析研究，都不利于翻越这段陡坡。

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