原文地址：http://blogs.adobe.com/kiwi/2006/06/an_asynchronous_cookbook_part_1.html
原文作者：Brian Riggs
译者：Dreamer

在上一篇文章中， 我列出了关于如何组织异步 ActionScript 代码的几种不同的解决方案。‘异步方法链’这个概念就是说在其中有可以对外部服务进行调用并且顺序执行的一系列方法， 如果开发者想要创建可以从多个 web service获取数据的应用程序，那么这个概念就很重要。

NoteTag是一个原始的例子：它向Blogger和/或 TypePad发送记录，并且在del.icio.us中储存记录和任务的引用。

但是现在假设在异步链中的一个方法需要链中一个较早的方法产生的一些数据。 你如何才能让事件状态对链中的多个方法都可用呢？

问题#4：异步方法链中的一个或多个方法需要访问链中另外一个地方生成的数据。例如，我们的 getFirstFeed方法需要返回 Atom服务文档中的第一个种子和 Atom服务文档。

方案#4a：把数据隐藏在呼叫对象中并把它沿着链传输（参考了 Sho的建议）。这种方式在简单的情况下工作的很好， 但是如果你有一个很长的方法链——可能只是链中的最后一个方
法需要传输的数据，而传输过程中经过的那些方法根本就不需要这些数据。

方案#4b：把数据作为私有数据成员存放在封闭的对象中。这可能是一个简单的解决方案，因为它使得数据对链中的任何方法都是可用的。 但是如果客户端方法在结束第一次的一系列异步调用之前被第二次调用，隐藏的数据就会被覆写！我们真正想要的方法是确保在异步方法链执行过程中产生的任何状态都被限定在一个单次方法调用的基础上……

方案#4c:：当客户端方法被呼叫的时候，通过把呼叫链的逻辑放到一个局部作用域的已实例化的委托类中，来定义类似单次方法调用的变量作用域。因为每次呼叫方法的时候一个新的委托类就会被实例化， 所以可以把数据存储在委托类中而不会有被覆写的危险。这种方法可以通过约定（通过强制客户端使用对每个操作都创建新的对象的工厂类）或显式地（通过在方法创建一个委托类，如下）实现。
public class FeedRetriever extends EventDispatcher {   private var protocol:AtomPublishingProtocol; // initialized  elsewhere   // Dispatches a GetFeedEvent after retrieving the first feed listed   // in the service document.   public function getFirstFeed(serviceURI:URI):void   {     var delegate:FeedRetrieverDelegate = new FeedRetrieverDelegate(this,protocol);     delegate.getFirstFeed(serviceURI);   } } // Internally-scoped delegate which is instantiated on every call to // FeedRetriever.getFirstFeed (and which can therefore safely storestate). internal class FeedRetrieverDelegate {   private var target:IEventDispatcher;   private var protocol:AtomPublishingProtocol;   // State that needs to be tracked (the service document).   private var service:IService;   public function FeedRetrieverDelegate(target:IEventDispatcher,protocol:AtomPublishingProtocol):void   {     this.target = target;     this.protocol = protocol;   }   public function getFirstFeed(serviceURI:URI):void   {     // Use a utility class to handle registration and unregistration     // of event listeners.     var responder:AsyncResponder = new AsyncResponder();     responder.setNextEventHandler(protocol,     onGetService, // result handler     "getService", // result event     onFault,      // fault handler     "atomFault"); // fault event     // Make the asynchronous call to retrieve the service document.     protocol.getService(serviceURI);   }   private function onGetService(event:GetServiceEvent):void   {     // Store the service document since the next method needs     // access to it.     this.service = event.service;     // Get the collection that represents the first feed.     var collection:ICollection = service.workspaces[0].collections[0];     // Use a utility class to handle registration and unregistration     // of event listeners.     var responder:AsyncResponder = new AsyncResponder();     responder.setNextEventHandler(protocol,     onGetFeed,    // result handler     "getFeed");   // result event     onFault,      // fault handler     "atomFault"); // fault event     // Make the asynchronous call to retrieve the first feed.     protocol.getFeed(collection);   }   private function onGetFeed(event:GetFeedEvent):void   {     // Dispatch a result event to the caller, using     // the passed-in target object.     var newEvent:GetFeedEvent = new GetFeedEvent();     newEvent.feed = event.feed;     newEvent.service = this.service;     target.dispatchEvent(newEvent);   }   private function onFault(event:AtomFaultEvent):void   {     // Do fault processing...   }   // ... }
但是从面向对象的角度看，把逻辑分散到两个类中并不是理想的解决方案。 有没有这样一种两全其美的方法， 可以让我们不用多个类就可以实现类似单次方法调用的变量作用域？当然有，我们最终的解决方案正是如此。

方案#4d:：把你的responder 代码放到一个或者多个闭包（closure）中。（一个闭包就是一个函数，在函数体中包含了另外一个函数，而且里面的函数在执行的时候有自己的一些本地变量。）在一个闭包中，你可以在外部的域中访问内部的变量—— 一个很大的好处。缺点？因为闭包需要在异步函数呼叫之前声明，所以代码中的控制流程可能有点混乱。
public class FeedRetriever extends EventDispatcher {   private var protocol:AtomPublishingProtocol; // initialized elsewhere   // Dispatches a GetFeedEvent that contains the first feed and   // the service document.   public function getFirstFeed(serviceURI:URI):void   {     // #1: The flow of control starts here...     // Declare a function closure that will be called later.     var onGetService:Function = function(event1:GetServiceEvent):void     {       // #3: After protocol.getService completes, control jumps       // to here...       // We set the service document into a local variable,       // which is accessible even from within the subsequent       // closure.       var serviceLocalVar:IService = event1.service;       // Get the first feed in the service document.       var collection:ICollection = serviceLocalVar.workspaces[0].collections[0];       // Declare another function closure to be called later.       var onGetFeed:Function = function(event2:GetFeedEvent):void       {         // #5: After protocol.getFeed completes, control         // jumps to here, and finishes by dispatching         // the client event.         // Dispatch a result event to the caller.         var newEvent:GetFeedEvent = new GetFeedEvent();         newEvent.feed = event2.feed         // Notice how we can access serviceLocalVar -         // this is one nice benefit of closures.         newEvent.service = serviceLocalVar;         dispatchEvent(newEvent);       }       // #4: ... and continues down to here...       // Use a utility class to handle registration and       // unregistration of event listeners.       var responder2:AsyncResponder = new AsyncResponder();       responder2.setNextEventHandler(protocol,       onGetFeed, // result handler       GetFeedEvent.GET_FEED, // result event       onFault, // fault handler       AtomFaultEvent.ATOM_FAULT); // fault event       // Make the asynchronous call to retrieve the first feed.       protocol.getFeed(collection);     }     // #2: ... and continues down to here...     // Use a utility class to handle registration and unregistration     // of event listeners.     var responder1:AsyncResponder = new AsyncResponder();     responder1.setNextEventHandler(protocol,     onGetService, // result handler     "getService", // result event     onFault,      // fault handler     "atomFault"); // fault event     // Make the asynchronous call.     protocol.getService();   }   private function onFault(event:AtomFaultEvent):void   {     // Do fault processing...   } }
在这里例子中跟踪控制流程有点像看别人玩溜溜球。Sho 对于如何提高大量使用闭包的代码的可读性有几个建议。

总结：在 ActionScript 中实现异步方法的时候，有很多方法供你选择。在很多情况下你可能只需要最简单的方法（创建一个事件监听器来响应事件）就够了，但是有一些特定的情况需要使用比较复杂的方法。在选择解决方案的时候，问自己以下问题：

我需要传输异步调用得到的结果吗？
1.在我使用了一个对象进行异步调用之后，这个对象还会被用到吗？
2.我需要进行多次的顺序异步调用吗？
3.在顺序异步调用链中，一个方法是否需要访问到链中另一个方法所生成的数据？

如果答案为“是的” ，就考虑使用下面一种或几种方法。
1.一个可以管理事件注册的辅助类（比如 AsyncResponder）
2.带有状态的对象
3.可以实现类似单次方法调用的变量作用域的委托类
4.闭包

出处：Dreamer's Blog
转载时必须以链接形式注明出处及本声明！

---

---