2. 增加Locale，错误信息的国际化的处理。
添加了一个Properties文件，
添加了com.adobe.cairngorm.CairngormMessageCodes和com.adobe.cairngorm.CairngormError两个类，其中CairngormMessageCodes用于定义Properties文件中的键值，而CairngormError封装了Error，在应用执行的过程不再直接抛出Error，而抛出一个CairngormError，其中带一个参数就是MessageCode，根据MessageCode到Properties文件中取出相应的消息。

3. 在business中，添加了一个IServiceLocator的接口
ServiceLocator实现IServiceLocator接口，相比以前增加了以下几个方法：
a、public function getRemoteObject( serviceId : String ) : RemoteObject // Return the RemoteObject for the given service id.
b、public function getHTTPService( serviceId : String ) : HTTPService // Return the HTTPService for the given service id.
c、public function getWebService( serviceId : String ) : WebService // Return the WebService for the given service id.
d、public function getConsumer( serviceId : String ) : Consumer  // Return the message Consumer for the given service id.
e、public function getProducer( serviceId : String ) : Producer // Return the message Produce for the given service id.
f、public function getDataService( serviceId : String ) : DataService // Return the DataService for the given service id.
g、public function setCredentials( username : String, password : String ) : void // Set the credentials for all registered services. Note that services that use a proxy or a third-party adapter to a remote endpoint will

原来的getService和getInvokerService方法已经废弃，改为了getRemoteObject

4. 在Command中，增加了ICommand接口，原来的Command接口继承ICommand

5. 在VO中，增加了IValueObject接口，原来的ValueObject继承IValueObject接口

上面添加的几个接口，除了IServiceLocator相较2.0版本有了较大的变化，增加了一些方法，其他的几个接口，依我所见，纯粹是换了名字而已。

Cairngen是一个Caringorm的代码生成器, 它使得开发者可以很方便地生成Cairngorm项目的结构框架, 包括: Cairngorm项目的目录结构, 一个缺省的ModelLocator, Controller, ServiceLocator. Cairngen也可以生成Event, Command, Delegate类.

Cairngen使用Flex2和PHP5.2.0开发, 利用了AMFPHP. 安装过程十分方便. 你可以在Flex Builder的浏览器中直接运行Cairngen来快速方便地生成Cairngorm的类.

Cairngen使用'步骤(Sequence)'来描述Event, Command, Delegate类之间的关系.
在Cairngen中只要命名一个'步骤',点击一下生成按钮就可以生成一个'步骤'. 然后刷新一下Flex项目, 生成的类就OK了. 在一些特殊的情况下, 你不希望添加Delegate类, 那么你可以选择排除Delegate类的生成, 这样的话, Cairngen只生成Event和Command.
生成的Command类实现Cairngorm的Command接口, 但不实现IResponder接口. Cairngen还能够正确地将事件强制性转化(casting)为Coand中的类型, 并import所有相关的类.

系统需求:
1. 了解AMFPHP, Apache2.0.59和PHP5.2.0, 在使用Cairngen之前要求先安装AMFPHP, 而且gateway.php的访问虚拟目录应该如下设置: http://localhost/amfphp/gateway.php. 在1.0版正式发布后, 这个URL可以自由配置.
2. 还需要安装Flex2, PHP, 你可以用WAMP5来集成安装Apache5.5和PHP. 安装好PHP和AMFPHP后, 就可以解压缩Cairngen Alpha 1. 把services目录复制到amfphp的根目录下. 然后复制cairgen-ui目录到apache的www根目录下.

使用:
安装好PHP和AMFPHP后, 就可以开始使用Cairngen了. 打开浏览器输入http://localhost/cairngen-ui/Cairngen.html打开生成器的图形界面. 创建Cairgen项目:
点击 begin
给你的Cairngen项目命名. 这个名称与Flex项目的名称相同, 选择你的Cairngorm的版本, 选择Flex项目的路径. 设置项目中包路径(比如: com.domain.projectname). 最后, 检验一下输入内容, 点击"Create Project". 刷新Flex项目查看缺省的Cairngorm项目结构, ModelLocator, Service和Controller类.

创建"步骤":

首先是给步骤命名, 然后选择是否要生成Delegate类, 点击生成, 并刷新Flex项目. 可以发现需要的类已经生成完毕了. 现在需要把它们添加到Controller中.
接下来编辑模板文件: 你可以修改模板文件(.tpl)来实现你的特定的Cairngorm需求; 模板文件在 amfphp\services\com\ericfeminella\cairngen\templates目录下.

生成器下载地址: http://code.ericfeminella.com/cairngen/Cairngen%20Alpha%201%20PreRelease.zip

3) 也不要用*类型。

4) 不要将ActionScript的类声明为动态。

5) 注意Application.application (和其他的无类型的框架属性). 这个属性有一些古怪.  他应该是Applicaton类型的，因为他指向的实例必须是Application的子类. 但实际上他的类型是'Object', 无法应用编译时的检查。如果你一定要用，最好也进行类型的强制性转换。:

MyApplication( Application.application ).functionCall();

6) 封装你的Xml。使用Xml与Server进行数据的交互非常方便，但是尽量避免使用Xml作为核心数据模型。从服务器收到数据后，尽量把Xml转换为强类型的对象模型。在Flex应用内部使用Xml是绕开编译器的作法。

7) 不要使用DynamicEvent.

8) 不要使用mx:Model。如上所述，请尽量使用自定义的强类型的类.

9) 不要使用Cairngorm中的data属性，而应该继承扩展CairngormEvent来传递数据。

10) 不要把编译器的严格模式关掉

在Flex的开发过程中，尤其是在使用Cairngorm的时候，总会遇到需要在Model的属性值改变后，需要调用一个指定的函数。传统的解决方法是使用一个Setter方法，在这个方法中首先对属性赋值，然后调用指定的函数，比如：

---------------------------
[ChangeEvent("deleteEnabledChange")]
public function get deleteEnabled() : Boolean {
return _deleteButtonVisible;
}

public function set deleteEnabled(value : Boolean) : Void {
_deleteButtonVisible = value;
SimpleButton(deleteButton)._visible = false;
dispatchEvent(new Event("deleteEnabledChange", this));
}
--------------

但是现在我们有一个更简洁的解决之道
首先添加这样一个类
package com.adobe.ac.util
{
   public class Observe
   {
      public var handler : Function;
 
      public function set source( source : * ) : void
      {
         handler.call();
      }
   }
}
然后就可以使用这个作为标签了。
<util:Observe source="{ model.myProperty }"
              handler="{ this.myFunction }"/>
使用了这样的一个标签后，今后嘦是对model.myProperty进行赋值，就会调用myFunction
这个号称世上最小的标签是不是很好用啊？

[Bindable]
public  var isPending : Boolean;

增加验证
我们现在添加对股票报价的验证功能，对于这一点，我们可以使用mx.validators.StringValidator来完成这一功能。应用中这两个参数共同控制按钮的有效性。这样可以在Model对象中设置一个isValid属性，用于组合这两参数。

private  function validate() :  void
{
    isValid  =  ( isSymbolValid  &&   ! isPending );
}

isSymbolValid是一个属性，存放StringValidator的结果。
在StockMarketPod.mxml中添加mx:StringValidator这个Tag

< mx:StringValidator 
     minLength ="2"  triggerEvent ="change"  
    source ="{ symbolTextInput }"  property ="text"
    valid ="stockQuote.validateSymbol( true );"  
    invalid ="stockQuote.validateSymbol( false );" />

从视图中直接调用Model对象不符合MVC原则，因为视图原则上只能派发事件。但在这个例子中，这样已经足够好了。

增加格式化
我们将股票报价以金额的方式进行展示，在StockMarketPod.mxml中增加一个formatter

< mx:CurrencyFormatter 
     id ="standardEuroFormatter"   
    currencySymbol ="$"  precision ="2" />
将formatter的结果进行绑定
< mx:Label  text ="{ standardEuroFormatter.format( stockQuote.lastStockQuote ) }" />

现在看一下完整的StockQuote类

package  com.adobe.cairngorm.samples.dashboard.model
{
     public   class  StockQuote
     {
        [Bindable]
         public  var lastStockQuote : Number;
        [Bindable]
         public  var isValid : Boolean;
        [Bindable]
         public  var statusMessage : String;
                
         private  var _isPending : Boolean;
         private  var isSymbolValid : Boolean;
                
        [Bindable]
         public  function get isPending() : Boolean
         {
             return  _isPending;
        }
        
         public  function set isPending( value : Boolean ) :  void
         {
            _isPending  =  value;
            validate();
        }
            
         public  function validateSymbol( isValid : Boolean ) :  void
         {
            isSymbolValid  =  isValid;
            validate();
        }
        
         private  function validate() :  void
         {
            isValid  =  ( isSymbolValid  &&   ! isPending );
        }         
    }
}

其中isPending属性的值由GetStockQuoteCommand控制

private  var model : ModelLocator  =  ModelLocator.getInstance();
private  var stockQuote : StockQuote  =  model.stockQuote;
         
public  function execute( event : CairngormEvent ) :  void
{
    stockQuote.isPending  =   true ;
             
    var stockQuoteEvent : GetStockQuoteEvent  =  GetStockQuoteEvent( event );          
    var symbol : String  =  stockQuoteEvent.symbol;
    var delegate : StockMarketDelegate  =   new  StockMarketDelegate(  this  );
    delegate.getQuoteForSymbol( symbol );    
}
        
public  function onResult( event :  *   =   null  ) :  void
{
     // for demo purpose: event would normally be an event object of remote service result.            
    stockQuote.lastStockQuote  =  event as Number;            
    stockQuote.isPending  =   false ;
    stockQuote.statusMessage  =   "" ;
}
        
public  function onFault( event :  *   =   null  ) :  void
{
    stockQuote.lastStockQuote  =  NaN;
    stockQuote.statusMessage  =   " Quote retrieval error. " ;
    stockQuote.isPending  =   false ;
}

最后看一下StockMarketPod.mxml的全部代码

<? xml version="1.0" encoding="utf-8" ?>
< mx:Panel 
     xmlns:mx ="http://www.adobe.com/2006/mxml"
    xmlns:util ="com.adobe.cairngorm.samples.dashboard.util.*" >
        
     < mx:Script >
         <![CDATA[
            import com.adobe.cairngorm.control.CairngormEventDispatcher;
            import com.adobe.cairngorm.samples.dashboard.model.StockQuote;
            import com.adobe.cairngorm.samples.dashboard.events.GetStockQuoteEvent;    
            
            [Bindable]
            public var stockQuote : StockQuote;
            
            private function getQuoteForSymbol() : void
            {
                var event : GetStockQuoteEvent = new GetStockQuoteEvent( symbolTextInput.text );
                CairngormEventDispatcher.getInstance().dispatchEvent( event );
            }
         ]]>
     </ mx:Script >
    
     < mx:CurrencyFormatter 
                 id ="standardEuroFormatter"   
        currencySymbol ="$"  precision ="2" />
        
     < mx:StringValidator 
         minLength ="2"  triggerEvent ="change"  
        source ="{ symbolTextInput }"  property ="text"
        valid ="stockQuote.validateSymbol( true );"  
        invalid ="stockQuote.validateSymbol( false );" />
    
     < mx:Form >
    
         < mx:FormItem  label ="Symbol" >
             < mx:TextInput 
                 id ="symbolTextInput" />
             < mx:Button 
                 label ="Get Quote"  
                enabled ="{ stockQuote.isValid }"  
                click ="getQuoteForSymbol();" />
         </ mx:FormItem >
                
         < mx:FormItem  label ="Price Quote" >
             < mx:Label  text ="{ standardEuroFormatter.format( stockQuote.lastStockQuote ) }" />
             < mx:Label  text ="{ stockQuote.statusMessage }" />
         </ mx:FormItem >
        
     </ mx:Form >     
</ mx:Panel >

此视图中我们不需要使用ModelLocator，而是使用StockQuote作为参数传入StockMarketPod.mxml
引用视图的代码

< mx:Script >
     <![CDATA[
        import com.adobe.cairngorm.samples.dashboard.model.ModelLocator;
        import com.adobe.cairngorm.samples.dashboard.model.StockQuote;
                                    
        [Bindable]
        private var model : ModelLocator = ModelLocator.getInstance();
        [Bindable]
        private var stockQuote : StockQuote = model.stockQuote;    
     ]]>
</ mx:Script >
 
< view:StockMarketPod 
     stockQuote ="{ stockQuote }"  
    title ="Stockmarket Pod" />

只传递需要的信息给视图是一个比较好的做法，而尽量少使用ModelLocator这样的全局变量，这样也使用视图重用性更高。

< view:StockMarketPod 
     quoteId ="quote1"  
    title ="Stockmarket first pod" />
< view:StockMarketPod 
     quoteId ="quote2"  
    title ="Stockmarket second pod" />
< view:StockMarketPod 
     quoteId ="quote3"  
    title ="Stockmarket third pod" />
< view:StockMarketPod 
     quoteId ="quote4"  
    title ="Stockmarket fourth pod" />

注意：视图需要传递一些唯一的标识，我们将这些标识添加到StockQuote类。

package  org.nevis.cairngorm.samples.dashboard.model
{
     public   class  StockQuote
     {
        [Bindable]
         public  var lastStockQuote : Number;
        [Bindable]
         public  var stockQuoteError : String;        
    }
}

管理对象StockQuoteManager，在ModelLocator实例中初始化。但是StockQuoteManager会是一个怎样的对象呢？
通常我使用Hashmap来实现，其键值就是视图中的唯一标识符。在构造函数中我们可以初始化这个Hashmap，Flex2中我们使用flash.utils.Dictionary

public  function StockQuoteManager() 
{
    stockQuotes  =   new  Dictionary();
}

getStockQuote方法返回一个stockQuote对象

public  function getStockQuote( quoteId : String ) : StockQuote
{
    var key : String  =  quoteId;
     if ( stockQuotes[ key ]  ==   null  )
     {
        var stockQuote : StockQuote  =   new  StockQuote();
        stockQuotes[ key ]  =  stockQuote;
    }
     return  StockQuote( stockQuotes[ key ] );
}

StockMarketPod.mxml几乎没有什么改动。只需要将那个唯一的标识符发送给命令，因为命令需要从管理对象处取得StockQuote对象。所以GetStockQuoteEvent类多了一个quoteId属性。
在GetStockQuoteCommand中，需要将唯一标识符保存在一个成员变量中

private  var model : ModelLocator  =  ModelLocator.getInstance();
private  var quoteId : String;
         
public  function execute( event : CairngormEvent ) :  void
{
    var stockQuoteEvent : GetStockQuoteEvent  =  GetStockQuoteEvent( event );             
    var symbol : String  =  stockQuoteEvent.symbol;
    quoteId  =  stockQuoteEvent.quoteId;
    var delegate : StockMarketDelegate  =   new  StockMarketDelegate(  this  );
    delegate.getQuoteForSymbol( symbol );
}
        
public  function onResult( event : ResultEvent  =   null  ) :  void
{
     // simulate a result from service
    var lastStockQuote : Number  =  Math.random()  *   50   +   5 ;
    var stockQuote : StockQuote  =  model.stockQuoteManager.getStockQuote( quoteId );
    stockQuote.lastStockQuote  =  lastStockQuote;
    stockQuote.stockQuoteError  =   "" ;
}
        
public  function onFault( event : FaultEvent  =   null  ) :  void
{
    var stockQuote : StockQuote  =  model.stockQuoteManager.getStockQuote( quoteId );
    stockQuote.lastStockQuote  =  NaN;
    stockQuote.stockQuoteError  =   " An error occured. " ;
}

注意一下，在上面的代码中我们使用的是无状态命令，在Cairngorm的说明中，无状态命令是每次Cairngorm事件的响应都创建一个新的命令实例的方式。因此，在这种方式中我们可以放心地把变量存储在成员变量中，而不用担心被其他人改变。

< mx:Button  label ="Get Quote"  click ="getQuoteForSymbol();" />

相应的脚本代码：

import org.nevis.cairngorm.samples.dashboard.events.GetStockQuoteEvent;                                    
private function getQuoteForSymbol() : void
{
    var event : GetStockQuoteEvent = new GetStockQuoteEvent( symbolTextInput.text );
    dispatchEvent( event );
}

GetStockQuoteCommand响应并处理这个Cairngorm事件，请求一个业务代理类来报价。

public function execute( event : CairngormEvent ) : void
{
    var symbol : String = GetStockQuoteEvent( event ).symbol;
    var delegate : StockMarketDelegate = new StockMarketDelegate( this );
    delegate.getQuoteForSymbol( symbol );
}

在实际情况中，需要进行一个远程的服务器端的调用，在Demo中，为简化起见，我注释掉了远程调用的相关代码。这里StockMarketDelegate.as只是对命令进行回调。

public function StockMarketDelegate( responder : Responder )
{
    //disabled for demo
    //this.service = ServiceLocator.getInstance().getService( "stockMarketDelegate" );
    this.responder = responder;
}
        
public function getQuoteForSymbol( symbol : String ) : void
{
    //disabled for demo
    //var call : AsyncToken = service.getQuoteForSymbol( symbol );
    //call.resultHandler = responder.onResult;
    //call.faultHandler = responder.onFault;
    if( symbol == "fail" )
    {
        responder.onFault();
    }
    else
    {
        responder.onResult();
    }
}

我们的StockMarketPod视图只需要两条消息，
1. 股票的报价
2. 错误消息
因为现在是第一次迭代过程中，处理比较简单，因此使用ModelLocator的成员来解决。

public var lastStockQuote : Number;
public var stockQuoteError : String;

在此Demo中，GetStockQuoteCommand命令模拟返回相应的结果。

public function onResult( event : ResultEvent = null ) : void
{
    //simulate a result from service
    var stockQuote : Number = Math.random() * 50 + 5;
    model.lastStockQuote = stockQuote;
    model.stockQuoteError = "";
 }
        
public function onFault( event : FaultEvent = null ) : void
{
    model.lastStockQuote = NaN;
    model.stockQuoteError = "An error occured.";
}

StockMarketPod视图绑定这些成员并进行一些格式化的处理。

<mx:FormItem label="Symbol">
    <mx:Label text="{ formatQuote( model.lastStockQuote ) }"/>
</mx:FormItem>
<mx:FormItem>
    <mx:Label text="{ model.stockQuoteError }"/>
</mx:FormItem>

格式化函数的脚本

private function formatQuote( quote : Number ) : String
{
    return ( isNaN( quote ) ) ? "" : String( quote );
}

现在我们来进行重构并将一些功能从视图中抽取出来到一个可以进行单元测试的工具类中。

第二次迭代，创建符合需求的业务逻辑
现在我们已经有一个可以运行的最简单的应用。当你的应用变得庞大后，将会有很多的限制。你会发现你的ModelLocator非常的臃肿，以致于有时候，你都找不到你所要的成员。甚至会有命名冲突的事情发生。
一个普通的重构方法是封装你的用例图中的成员成为一个业务对象。这个业务对象能够表达业务上下文中需要的视图信息。你可以把业务对象设计得最适合用例图的粒度。在一个大型的应用中，你可能会设计一系列的业务对象来表达你的用例。你的视图将会绑定这些对象或者这些对象的属性上。通过这种方法，ModelLocator与其目标之间的联系更容易，开发者更容易掌握业务逻辑所包含的内容。
在这个Demo中，我们可以把astStockQuote和stockQuoteError这两个成员封装到一个业务对象中。

package org.nevis.cairngorm.samples.dashboard.model
{
    public class StockQuote
    {
        [Bindable]
        public var lastStockQuote : Number;
        [Bindable]
        public var stockQuoteError : String;
    }
}

这样在ModelLocator中，我们只需要定义一个成员
public var stockQuote : StockQuote = new StockQuote ();
我们的视图也相应修改为：

<mx:FormItem label="Symbol">
    <mx:Label text="{ formatQuote( model.stockQuote.lastStockQuote ) }"/>
</mx:FormItem>
<mx:FormItem>
    <mx:Label text="{ model.stockQuote.stockQuoteError }"/>
</mx:FormItem>

我们看一个添加商品到购物车的例子. 当应用广播ShopController.EVENT_ADD_PRODUCT_TO_SHOPPING_CART命令时,
前台控制中下面这行代码保证AddProductToShoppingCartCommand的execute()方法被调用.
addCommand( ShopController.EVENT_ADD_PRODUCT_TO_SHOPPING_CART, new AddProductToShoppingCartCommand() );

ShopController继承了Cairngorm中的FrontController基类, 因此可以使用addCommand()来给事件注册相应的命令.
Cairngorm底层架构完成了剩余部分的工作. 应用中任意地方简单地广播适当的事件, Cairngorm确保相应的命令被触发.

另外需要做的是在Mxml的主入口点创建控制器. 在Cairngorm商店中, 是Main.mxml, 代码如下:
<control:ShopController id="controller" />

Macromedia Acquires iteration::two in creation of Macromedia Consulting Europe.

Macromedia acquires iteration::two, an industry-leading software consultancy,  to create a European Rich Internet Application consulting organisation based in Edinburgh , Scotland.
Cairngorm是Iteration::two的开源项目之一。下载和更新地址是http://www.iterationtwo.com/open_source_cairngorm.html


好，现在继续开始我的学习笔记：
1. 在Control中有Command.as定义了Command接口，笔记一中FrontController中addCommand的调用添加的Command都必须实现此接口。Command接口只定义一个唯一的需要实现的方法execute(); 这是一个典型的命令模式, 所有后续的命令都实现此接口, 对外统一提供一个单点入口execute(), 其他的人都可以进行调用,但不需要了解命令具体的实现方式.

2. 在Model中定义了ModelLocator接口，ModalLocator是所有数据绑定的接口，也就是说应用中所有需要进行绑定的数据都需要通过此接口进行定位。在实际的应用中需要实现此接口，并提供所有的绑定数据。

3. 在business中定义了两个类 ServiceLocator和Responder。
ServiceLocator这是伪单例类, 应用开发者用于定义并获得服务.
之所以是伪单例类, 是因为ServiceLocator是定义在mxml中的,
它需要一个无参数的Public构造函数. 使用中必须定义一个ServiceLocator的子类, 并在其中定义需要的服务.

代码示例:首先在Services.mxml中进行如下定义:

 * <cairngorm:ServiceLocator xmlns:mx="http://www.macromedia.com/2003/mxml"
 *                           xmlns:cairngorm="org.nevis.cairngorm.business.*" >
 *
 *   <mx:RemoteObject id="customerDelegate" source="org.nevis.cairngorm.samples.login.CustomerDelegate"
 *                    result="event.call.resultHandler( event )"
 *                    fault="event.call.faultHandler( event )">
 *   </mx:RemoteObject>
 *
 * </cairngorm:ServiceLocator>

在Flex主应用中添加一行：
 <business:Services id="services" />
其中business命名空间在应用头部进行申明
 xmlns:business="org.nevis.cairngorm.samples.store.business.*"
ServiceLocator使用方法：
在业务代理类(Delegate)中通过如下方式进行调用:
 *   var service = ServiceLocator.getInstance().getService( "customerDelegate" );


在View中，定义了两个类 ViewLocator和ViewHelper
ViewHelper:用于隔离Command命令类和View视图的具体实现.
为了执行业务功能, Command类需要查询并更改视图,
在执行业务逻辑前, 命令类需要从视图中获得用户输入的数据;
业务逻辑结束后又经常需要更改视图, 显示执行结果.
通过将查询和更改视图的操作封装到单独ViewHelper类中, 命令类完全不需要了解视图类的任何信息.
ViewHelper属于一种特殊的视图, 当ViewHelper创建后, 就被注册到指定的视图.
ViewHelper继承自MXMLObject, 在重写的初始化函数(initialized)中, 调用ViewLocator进行注册,
并指定unload方法的监听函数unregister, 在unload时, 调用unregister, 使用ViewLocator的取消注册.

ViewLocator是一个单例类, 用于获取ViewHelper操作视图.
命令类需要通过ViewHelper的方法来查询更改视图, 而ViewLocator即用于让命令类取得需要的ViewHelper.
命令类不需要知道ViewHelper的名称, ViewLocator会返回需要的ViewHelper实例.

现在Cairngorm的基础框架已经介绍完毕，将在以后继续介绍如何在实际应用中使用上面提及的基础框架。

我们从Control说起:
在Control中, 定义了3个基类: Event, EventBroadcaster, FrontController.
Event用于在应用不同的层之间传递事件, 并携带事件的数据. 包含type和data两个成员.
type存放一个区别不同事件的名称,将会在FrontController中进行注册.
而在命令(Command)类中, 会对事件进行响应.

EventBroadcaster是一个单例类(singleton), 用于广播用户动作对应的事件. 使用方法: EventBroadcaster.getInstance().broadcastEvent( ... )

FrontController稍微复杂一点点. 用于将特定的用户动作分发到指定的命令类.
FrontConroller是请求处理的核心类. 整个体系中遍布的EventBroadcaster.getInstance().broadcastEvent( ... )这样的调用,
都是用来通知监听控制器: 用户发出了请求. 在实际应用中, 开发者应该生成一个FrontContoller的子类,
并在构造函数中调用addCommand()注册预期事件的处理命令. FrontController的具体实现类应该创建一次而且只能创建一次.
通常的做法是这样的: 在主应用中, 将FrontController的子类作为一个Tag进行申明, 
 * <p>
 * <code>
 * <mx:Application  xmlns:control="com.domain.project.control.LoginController"        ... >
 *
 *        <control:LoginController id="controller" />
 *
 *  ...
 *
 * </code>
 * </p>
FrontController的处理实质上是这样的, 在调用addCommamd时, 将处理命令保存在数组中, 将与之对应的事件处理对象注册为FrontController本身,
在事件触发, 调用FrontController的handleEvent时, 调用executeCommand, 在executeCommand中, 先在数组查找出事件对应的命令,
调用命令的execute方法. 这就要求所有的命令都实现Command接口

(内容较多, 未完待续)