Twisted学习(三)---------------Deferred介绍

一件事, 然后另外一件, 再一件

这是前面的一个例子:

pprint(sorted(x.get_names()))

也可以写成下面这样:

names = x.get_names()
sorted_names = sorted(names)
pprint(sorted_names)

不管是get_names还是sorted，都依赖于在返回之前要操作完成。但是，如果它们都是异步操作该怎么办?

好吧, 在Twisted中，它们可以返回 Deferreds，所以我们可以写成下面这样:

d = x.get_names()
d.addCallback(sorted)
d.addCallback(pprint)

最终,不管get_names最终返回了什么都会调用 sorted.当sorted 执行完成后,pprint将会以其结果继续执行.

我们也可以写成下面这样:

x.get_names().addCallback(sorted).addCallback(pprint)

因为 d.addCallback返回值是d.

简单的错误处理

我们经常需要写下面这样的代码:

try:
    x.get_names()
except Exception, e:
    report_error(e)

使用 Deferreds我们又该如何写呢?

d = x.get_names()
d.addErrback(report_error)

errback是Twisted 用来命名接收执行错误的callback 的.

这段代码掩盖了一个重要的细节.不是得到一个异常对象 e,report_error得到的是一个Failure对象,它包含了所有e所包含的有用信息, 但是为使用 Deferreds进行了优化.

稍后我会更详细地讨论它, 我们先来讨论所有其它的异常组合.

处理一个错误，并在成功时做另外的操作

如果我们想在try代码块后执行另外一些操作该怎么做?像通常做的那样,我们会这样写:

try:
    y = f()
except Exception, e:
    g(e)
else:
    h(y)

我们重写这段代码使用 Deferreds:

d = f()
d.addCallbacks(h, g)

 addCallbacks 意味着同时添加一个callback和一个errback..h 是callback,g 是errback.

现在我们有 addCallbacks，同时还有addErrback和addCallback,我们可以用它们来匹配所有try,except,else,和finally的可能组合。.解释这些是如何工作的有些复杂， (尽管Deferred 参考 这篇文章中有很好的讲述), 但是当我们学过了下面的例子原理可能会更清楚一些.

处理一个错误，并继续运行

如果我们想在 try/except之后做一些操作,不管是否发生了异常?通常是像下面的代码这样:

try:
    y = f()
except Exception, e:
    y = g(e)
h(y)

使用 Deferreds:

d = f()
d.addErrback(g)
d.addCallback(h)

因为 addErrback 返回d, 所以我们可以像下面这样:

f().addErrback(g).addCallback(h)

 addErrback和addCallback的调用顺序是有影响的 .在下面的章节中, 我们将会看到如果调换顺序会发生什么.

为所有的操作进行错误处理

我们想为多个操作进行可能的错误处理?

try:
    y = f()
    z = h(y)
except Exception, e:
    g(e)

使用 Deferreds:

d = f()
d.addCallback(h)
d.addErrback(g)

或者，更简洁的写法:

d = f().addCallback(h).addErrback(g)

无论如何都要执行

考虑finally?我们想做些操作不管是否发生了异常?代码就像下面这样:

try:
    y = f()
finally:
    g()

大致上和下面一样:

d = f()
d.addBoth(g)

上面的操作添加了 g 同是作为callback和 errback.和下面的代码等价:

d.addCallbacks(g, g)

为什么说 “大致上”?因为如果 f抛出了异常,g将会被传递一个代表这个异常的Failure 对象.否则, 将会传递给g异步代码f的执行结果 (也就是.y).

Inline callbacks - 使用 ‘yield’

Twisted 有一个inlineCallbacks装饰器，它允许你使用Deferreds而不用编写callback函数.

这是通过把你的代码写成生成器来实现的, 也就是使用yield Deferreds 来代替关联一个callback函数.

考虑下面标准的Deferred 写法:

def getUsers():
   d = makeRequest("GET", "/users")
   d.addCallback(json.loads)
   return d

使用 inlineCallbacks, 我们可以写成下面这样:

from twisted.internet.defer import inlineCallbacks, returnValue

@inlineCallbacks
def getUsers(self):
    responseBody = yield makeRequest("GET", "/users")
    returnValue(json.loads(responseBody))

有2件事情会发生:

1. 代替了在返回的Deferred上调用addCallback , 我们yield Deferred.这将会使Twisted 给我们返回Deferred的结果.
2. 我们使用 returnValue来传递我们函数的最终结果。因为这个函数是一个生成器，所以我们不能使用return表达式，那样会导致一个语法错误。
   

下面2个版本的 getUsers 对它们的调用者来说，API都是一样的: 都返回了一个Deferred ，包含了请求的json body.尽管inlineCallbacks 的版本看起来像是同步代码,它会阻塞到直到request返回, 但是yield 表达式允许其它的代码运行，同时当yield的deferred完成会继续被执行。

inlineCallbacks会变得更加强大，尤其是在处理复杂的控制流或者错误处理时。

比如, 如果makeRequest因为一个连接错误而失败了?如果遇到了异常，我们想返回一个空的列表.

def getUsers():
   d = makeRequest("GET", "/users")

   def connectionError(failure):
       failure.trap(ConnectionError)
       log.failure("makeRequest failed due to connection error",
                   failure)
       return []

   d.addCallbacks(json.loads, connectionError)
   return d

使用 inlineCallbacks, 我们可以像下面这样重写:

@inlineCallbacks
def getUsers(self):
    try:
        responseBody = yield makeRequest("GET", "/users")
    except ConnectionError:
       log.failure("makeRequest failed due to connection error")
       returnValue([])

    returnValue(json.loads(responseBody))

我们的异常处理可以更加简单，因为我们可以使用 Python的 try /except 讲法来处理 ConnectionErrors.

协程使用 async/await

在 Python 3.5 和更高的版本中, the PEP 492 (“协程使用 async和 await 语法”) “await” 可以和Deferreds 一起使用，通过使用ensureDeferred.它和inlineCallbacks类似, 除了它使用await关键字而不是yield,使用return关键字来代替 returnValue, 同时它是一个函数而不是一个生成器.

调用一个协程 (这样的函数定义方式如： asyncdef funcname():) 使用ensureDeferred 将允许你在Deferreds上使用 “await” , 并且它返回一个标准的Deferred.你可以混合使用通常的 Deferreds,inlineCallbacks, 和ensureDeferred.

在一个Deferred上Awaiting,这个Deferred如果失败了将会在你的协程中抛出一个异常，就像通常的python代码中那样。如果你的协程抛出了一个异常, 它将会被转换成Deferred上的一个Failure,然后返回一个ensureDeferred.调用return将会使Deferred返回一个包含结果的ensureDeferred.

import json
from twisted.internet.defer import ensureDeferred
from twisted.logger import Logger
log = Logger()

async def getUsers():
    try:
        return json.loads(await makeRequest("GET", "/users"))
    except ConnectionError:
        log.failure("makeRequest failed due to connection error")
        return []

def do():
    d = ensureDeferred(getUsers())
    d.addCallback(print)
    return d

当你使用协程的时候, 你没有必要使用ensureDeferred .当你写的协程调用了其它在Deferreds上await的协程。你可以直接在上面await,如下所示:

async def foo():
    res = await someFunctionThatReturnsADeferred()
    return res

async def bar():
    baz = await someOtherDeferredFunction()
    fooResult = await foo()
    return baz + fooResult

def myDeferredReturningFunction():
    coro = bar()
    return ensureDeferred(coro)

尽管 Deferreds在所有的协程中使用, 只有bar需要被用ensureDeferred 装饰来返回一个 Deferred.