<mx:Model id="myModel">
    {RO.listPerson.result}
</mx:Model>

<mx:DataGrid id="DG" with="100%" height="100%" dataProvider="{myModel}">
    <mx:columns>
        <mx:array>
            <mx:DataGridColumn headerText="Name" columnName="name"/>
            <mx:DataGridColumn headerText="Age"  columnName="age"/>
        </mx:array
    </mx:columns>
</mx:DataGrid>

public class Person
{
    String name;
    int age;
    //getters and setters here.
    //getters and setters are must for Flex to access the data in object of
    //this class
}

public List listPerson()
{
    List list = new ArrayList();
    Person p1 = new Person("seafront", 22);
    Person p2 = new Person("frontsea", 20);
    list.add(p1); list.add(p2);
    return list;
}

是 flex 与 java 交互主要还是要关心这两者之间的数据交互类型的转换。 ActionScript 与 java 的类型互换不是对称的，见下面的表：

由上面两表可以看到，一般的数据类型都可以很好的装换，但是对于用户自定义的类型的话，那么要不就是在 ActionScritp 中定义相关的数据类型，进行类型注册，但是这样两者就太紧耦合了，觉得不是很好。另外的话可以看到， java 可以返回 Collection 类型的集合类给 ActionScript ，而 AS 使用是一数组来处理，就像前面例子里的一样，虽然 Person 是自定义类，但是里面的成员都是基本 AS 可自动转换的类型的，而把 Person 对象放在 List 里返回，然后 AS 通过数组 的 [] 操作符来访问，直接操作 name 和 age 成员变量。

所以如果用 flex 作表现曾的话，那么对于 model 中的类，就可能要考虑这一点，有时候需要专门为 flex 编写与其兼容的 model 类。可见两种方法都需要额外的工作，根据不同情况来选择就好。

还有如果从 Flex 中提交一个 Array 到 Java 方法中， java 方法以 Collection 来接受，如果 Array 不是常规数组，就是说数组元素不是用 index 来访问，那么里面每个元素是一个 Map(HashMap), key 是这个数组访问变量，比要把上面 datagrid 的 dataProvider 提交大 java 方法中，那么 Map 的 key 就是 name 和 age ，使用 Map.get() 从而取出里面的数据。

原文地址：http://kuwamoto.org/2006/05/16/dealing-with-asynchronous-events-part-1/

原文作者： Sho Kuwamoto

译者： Dreamer (http://www.zhuoqun.net)

_______________________________________________________________________________

处理异步事件，第一部分

使用异步事件模型的一个困难就是很难写出易读的代码。 <}0{> 这对于 AJAX 以及 Flex 应用程序都是同样真实的道理。

过去几个月以来，我针对这个问题尝试了各种各样的方法。我认为这能帮助我漫步在曾经尝试的各种代码中，并以此说明不同的方法。

让我们以RPC service 调用为例。假设我正在使用一个http service来获得一个唱片的信息：

				public function getAlbumInfo(albumId: int) : void
		

				{
		

				
						
						myService.request = { type: "album", albumId: albumId };
		

				
						
						myService.send();
		

				
						
						// I'd like to do something with the results of
		

				
						
						// my request, but I can't!
		

				}
		

问题是结果并不是立刻就返回。代码在执行而结果可能在数百毫秒内无法返回。此外，Flash Player不提供一个阻滞的方法来等待结果就绪。为了相应最终返回的结果，你需要俘获一个事件。

				public function getAlbumInfo(albumId: int) : void
		

				{
		

				
						
						myService.addEventListener("result", getAlbumInfoResult);
		

				
						
						myService.request = { type: "album", albumId: albumId };
		

				
						
						myService.send();
		

				}
		

				public function getAlbumInfoResult(event: Event) : void
		

				{
		

				
						
						// Hundreds of milliseconds later, my results
		

				
						
						// have arrived, and I can add them to my list!
		

				
						
						myAlbumList.addAlbum(event.result.album);
		

				}
		

这并不太差劲，是吗？现在，想象一下现在我需要在结果函数中使用albumId，而恰好RPC send()方法就有一个叫做呼叫对象（call object）的特殊对象来让我们那样做。

使用呼叫对象来传递参数

呼叫对象是一个一旦结果事件（result event）触发就会被传送到结果处理程序的对象。

				public function getAlbumInfo(albumId: int) : void
		

				{
		

				
						
						myService.addEventListener("result", getAlbumInfoResult);
		

				
						
						myService.request = { type: "album", albumId: albumId };
		

				
						
						// Make the call, and save a value for later use.
		

				
						
						var call : Object = myService.send();
		

				
						
						call.albumId = albumId;
		

				}
		

				public function getAlbumInfoResult(event: Event) : void
		

				{
		

				
						
						// Use the albumId value that was passed to me from above
		

				
						
						// as part of the call object.
		

				
						
						myAlbumList.addAlbum(event.call.albumId, event.result.album);
		

				}
		

现在，假设我需要把这些呼叫串在一起。它会变得非常凌乱不堪。

				public function getAlbumInfo(albumId: int) : void
		

				{
		

				
						
						myService.addEventListener("result", getAlbumInfoResult);
		

				
						
						myService.request = { type: "album", albumId: albumId };
		

				
						
						// Save the albumId for use later!
		

				
						
						var call : Object = myService.send();
		

				
						
						call.albumId = albumId;
		

				}
		

				public function getAlbumInfoResult(event: Event) : void
		

				{
		

				
						
						var artistId: int = event.result.album.artistId;
		

				
						
						myAlbumList.addAlbum(event.call.albumId, event.result.album);
		

				
						
						myService.addEventListener("result", getArtistInfoResult);
		

				
						
						myService.request = { type: "artist", artistId : artistId };
		

				
						
						// Now, save the artistId for use later!
		

				
						
						var call = myService.send();
		

				
						
						call.artistId = artistId;
		

				}
		

				public function getArtistInfoResult(event: Event) : void
		

				{
		

				
						
						myArtistList.addArtist(event.call.artistId, event.result.artist);
		

				}
		

下面，让我们假设一种更复杂的情形：如果多个呼叫程序需要调用同一个HTTP service呢？你如何确保正确地处理返回结果？

多个呼叫的问题

让我们把上面的代码做点简单的改变来阐明这个问题。

				public function getAlbumInfo(albumId: int) : void
		

				{
		

				
						
						// Wire up my result handler.
		

				
						
						myService.addEventListener("result", getAlbumInfoResult);
		

				
						
						// Ask for the album info.
		

				
						
						myService.request = { type: "album", albumId: albumId };
		

				
						
						myService.send();
		

				
						
						// Also ask for the album art.
		

				
						
						myService.request = { type: "albumArt", albumId: albumId };
		

				
						
						myService.send();
		

				}
		

				public function getAlbumInfoResult(event: Event) : void
		

				{
		

				
						
						// At this point, I have no idea whether I should be
		

				
						
						// handling the album info or the album art.
		

				}
		

对这个问题的愚蠢的解决方法就是在第一个send之前绑定第一个函数，在第二个send之前绑定第二个函数：

				public function getAlbumInfo(albumId: int) : void
		

				{
		

				
						
						// Wire up my result handler.
		

				
						
						myService.addEventListener("result", getAlbumInfoResult);
		

				
						
						// Ask for the album info.
		

				
						
						myService.request = { type: "album", albumId: albumId };
		

				
						
						myService.send();
		

				
						
						// BUG!! This will not work!
		

				
						
						myService.removeEventListener("result", getAlbumInfoResult);
		

				
						
						myService.addEventListener("result", getAlbumArtResult);
		

				
						
						// Also ask for the album art.
		

				
						
						myService.request = { type: "albumArt", albumId: albumId };
		

				
						
						myService.send();
		

				}
		

如果你对异步编程很熟悉的话，你马上就会明白问题在哪里。对于那些不熟悉的人，这里列出了将会发生的事件的顺序：

<!--[if !supportLists]-->1.<!--[endif]-->一个“result”的监听器（listener）将会绑定到getAlbumInfoResult()。

<!--[if !supportLists]-->2.<!--[endif]-->建立album info请求。

<!--[if !supportLists]-->3.<!--[endif]-->先前的监听器被移除。

<!--[if !supportLists]-->4.<!--[endif]-->“result”的一个新的监听器被绑定到getAlbumArtResult()。

<!--[if !supportLists]-->5.<!--[endif]-->建立album art 请求。

<!--[if !supportLists]-->6.<!--[endif]-->等待一段时间。

<!--[if !supportLists]-->7.<!--[endif]-->由于网络没有任何规律，album info的结果返回或者是album art的结果返回。

<!--[if !supportLists]-->8.<!--[endif]-->不管哪个呼叫返回，它都会找到getAlbumArtResult()。因为这个时候它是唯一注册的监听器。

解决多个呼叫（mutiple call）的问题

解决多个呼叫问题的传统方法就是吧callback函数附加到呼叫对象上。这样可以正常工作，因为每次service被调用的时候一个唯一的呼叫对象就会被创建。

				public function doInit()
		

				{
		

				
						
						
						
						myService.addEventListener("result", handleResult);
		

				}
		

				public function getAlbumInfo(albumId: int) : void
		

				{
		

				
						
						var call : Object;
		

				
						
						// Ask for the album info.
		

				
						
						myService.request = { type: "album", albumId: albumId };
		

				
						
						call = myService.send();
		

				
						
						
						
						call.handler = getAlbumInfoResult;
		

				
						
						// Also ask for the album art.
		

				
						
						myService.request = { type: "albumArt", albumId: albumId };
		

				
						
						call = myService.send();
		

				
						
						call.handler = getAlbumArtResult;
		

				}
		

				public function handleResult(event: ResultEvent) : void
		

				{
		

				
						
						// Retrieve the call object from the event.
		

				
						
						var call : Object = event.call;
		

				
						
						// Get the handler.
		

				
						
						var handler : Function = call.handler;
		

				
						
						// Call the handler. We use handler.call(xxx) instead
		

				
						
						// of handler(xxx) to properly deal with the scope chain.
		

				
						
						handler.call(null, event);
		

				}
		

这在个新的代码中，两个对service的调用会呼叫同一个处理函数，但是实际上被呼叫的处理函数是隐藏在呼叫对象中的那个。在第一次呼叫的情况中，getAlbumInfoResult()将会被呼叫，而在第二种情况下，getAlbumArtResult()将会被呼叫。

class ButtonSound extends mx.effects.Effect
{
[Embed(mimeType="audio/mpeg",source="Button.mp3")]
//注意不要使用wav格式的声音
var soundSymbol:String;
var s:Sound;
public function playEffect():Void
{
super.playEffect();
s = new Sound();
s.attachSound(soundSymbol);
s.start();
}
public function endEffect():Void
{
s.stop();
}
}

ButtonSound.as同级目录下新建一个MXML文件，代码如下：

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.macromedia.com/2003/mxml" xmlns:local="*"
pageTitle="ButtonSound" >

<!-- 声明音效 -->
<mx:Effect>
<local:ButtonSound name="ButtonSoundEffect"/>
</mx:Effect>

<mx:Button label="RIACN" click="getURL('http://www.riacn.com','_blank');" mouseDownEffect="ButtonSoundEffect"/>

</mx:Application>

另外mxml文件的命名要注意，不要用sound作为mxml的名字，否则Flex会认为文件名和内置的Sound对象冲突。

<?xml version="1.0" encoding="gb2312"?>
<mx:Application xmlns:mx="http://www.macromedia.com/2003/mxml">
<mx:MediaDisplay id="mp1" contentPath="kissme02.mp3"/>
<mx:Canvas>
<mx:Button id="s2" label="ｅ路信峰 要 开Sound" click="mp1.play();s2.visible=false;s1.visible=true"
fontSize="18"/>
<mx:Button id="s1" label="ｅ路信峰 要 关Sound" click="mp1.stop();s1.visible=false;s2.visible=true"
fontSize="18"/>
</mx:Canvas>
</mx:Application>

   <mx:Script>
       <![CDATA[
                 var pageRecordes:Number;
                 var totalPages:Number = 0;
                 var totalRows:Number = 0;
                 var currentPage:Number = 1;
                 var pageStartRow:Number = 1;
                 var pageEndRow:Number = 0;
                 
           public var initDG:Array = [
               { Artist: a, Price: 1, Album: one},
                       { Artist: b, Price: 2, Album: two},
                       { Artist: c, Price: 3, Album: three},
                       { Artist: d, Price: 4, Album: four},
                       { Artist: e, Price: 5, Album: five},
                       { Artist: f, Price: 6, Album: six},
                       { Artist: g, Price: 7, Album: seven},
               { Artist: h, Price: 8, Album: eight} ];
                       
                 function initApp(){
                       txt.text = "Page " + currentPage;
                       pageRecordes = pageConfig.pageRecordes;
                       totalRows = initDG.length;
                       if(initDG.length > pageRecordes){
                             dg.dataProvider = initDG.slice(0,pageRecordes);
                             pPage.enabled = false;
                       }
                       
                       if ((totalRows % pageRecordes) == 0) {
                             totalPages = Math.floor(totalRows / pageRecordes);
                       } else {
                             totalPages = Math.floor(totalRows / pageRecordes + 1);
                       }
                       
                       if (totalRows <= pageRecordes) {
                             this.pageStartRow = 1;
                             this.pageEndRow = totalRows;
                       } else {
                             this.pageStartRow = 1;
                             this.pageEndRow = pageRecordes;
                       }
                       
                       if(totalPages == 1){
                             pPage.enabled = false;
                             nPage.enabled = false;
                       }
                 }
          
                 function showPreviousPage(){
                       currentPage = currentPage - 1;
                       txt.text = "Page " + currentPage;
                       if(currentPage == 1){
                             pPage.enabled = false;
                             nPage.enabled = true;
                       }else{
                             pPage.enabled = true;
                             nPage.enabled = true;
                       }
                       if (currentPage == totalPages) {
                             pageStartRow = (currentPage - 1) * pageRecordes + 1;
                             pageEndRow = totalRows;
                       } else {
                             pageStartRow = (currentPage - 1) * pageRecordes + 1;
                             pageEndRow = currentPage * pageRecordes;
                       }
                       dg.dataProvider = initDG.slice(pageStartRow - 1,pageEndRow);
                 }
                 
                 function showNextPage(){
                       currentPage = currentPage + 1;
                       txt.text = "Page " + currentPage;
                       if(currentPage == totalPages){
                             nPage.enabled = false;
                             pPage.enabled = true;
                       }else{
                             nPage.enabled = true;
                             pPage.enabled = true;
                       }
                       if (currentPage == totalPages) {
                             pageStartRow = (currentPage - 1) * pageRecordes + 1;
                             pageEndRow = totalRows;
                       } else {
                             pageStartRow = (currentPage - 1) * pageRecordes + 1;
                             pageEndRow = currentPage * pageRecordes;
                       }
                       dg.dataProvider = initDG.slice(pageStartRow - 1,pageEndRow);
                 }
                 
       ]]>
   </mx:Script>
     
     <mx:Model id="pageConfig" source="WEB-INF/classes/pageConfig.xml"/>
   <mx:Panel title="DataGrid Panel" marginTop="10" height="100%" width="100%">

       <mx:DataGrid id="dg" dataProvider="{initDG}" height="100%" width="100%" />
           <mx:HBox>
                 <mx:Button id="pPage" label="prevPage" click="showPreviousPage()"></mx:Button>
                 <mx:Text id="txt"></mx:Text>
                 <mx:Button id="nPage" label="nextPage" click="showNextPage()"></mx:Button>
           </mx:HBox>

   </mx:Panel>

</mx:Application>

还有一个配置的xml文件，路径是：...WEB-INF/classes/pageConfig.xml
该xml文件内容如下：
<?xml version="1.0" encoding="shift_jis"?>
<web-app>
     <pageRecordes>3</pageRecordes>
</web-app>

Flex既可以提供stateful或stateless的remote object, 另外还有session servlet让mxml获取/和储存session中的内容。这一切听上去都很完美，但是有一个问题，Flex Remote Object本身是无法获得任何有关Running Context的信息，也就是说，你无法从你的 Remote Object 中获得 HttpSession, HttpRequest 和 ServletContext。 所谓的 Flex Session servlet只是让MXML获得session的内容，而不是直接让Remote Object获得session。

Remote Object为什么需要获得HttpRequest, HttpSession?
既然Flex提供了stateful的remote object为什么还要让remote object获得Running Context呢？问题在于Flex中的stateful是基于应用服务器的http session，而且你无法控制AMFGateway建立remote object的过程。打个简单的比方，我们知道一般的应用服务器中，session的时限只有20分钟，而在很多系统的登陆过程中却有选择保持登陆几个月的选项。

其具体实现上就是利用cookie来储存id和password hash，通过控制cookie的存活时间来实现的。而在服务器端，一旦session过期了，则可以从cookie中获得id和password hash重新登陆一遍，从而达到自动认证用户的目的。

如果你的Remote Object无法获得 HttpServletRequest, HttpSession，你就无法实现上述的情况。另外，对于小型的应用来说，直接在Remote object中获得servlet context并利用它来储存/获得共享的资源，可以大大降低开发的复杂程度。

解决方案
要让Remote Object获得HttpSession,HttpRequest和ServletContext并不是一件容易的事情。这里提供了我的一种方法，供大家参考。希望能抛砖引玉，让大家提出更好，更有效的方案。

这个方法的基本思路是利用JAVA提供的 ThreadLocal Object。当服务器接收到一个HTTP请求后，这个请求的整个处理过程是运行在同一个线程中的。

每个HTTP请求的处理会都运行在各自独立的线程中。而在Flex中，所有AMF Remote Object 的请求都需要通过 AMF Gateway Servlet，而Remote Object 的建立和调用恰恰就是运行在这个HTTP请求的线程中。

有了这个原则，我们就可以建立一个Context Object,每当请求建立的时候，就可以把这个请求放入 Context 的 ThreadLocal 中，而当 Remote Object 被AMF Gateway Servlet调用的时候，就可以通过访问 Context 的ThreadLoca l来获得其所对应的那个请求。

而截获发送到AMF Gateway的请求则可以通过Servlet Filter来实现。废话不说了，看代码吧！

关于flex的中文问题，可算是老生常谈了，但是大家还有不少人总是在这方面犯错误，包括kenshin在内，也走了一些弯路，所以现在就把关于flex的中文参数问题在好好谢谢，如果有写的不对的地方，还请大家原谅

其实中文问题的解决，无外乎就是编码的一致性问题，举个例子，比如两个人进行交流，那他们的语言必须是一致的，这样双方才能听懂对方所说的话，这在现实的生活中是一个常识，在编程的时候，道理是一样的，要想使flex和jsp都“说同样的话”，首先要把他们的编码，也就是“语言”变成一致的，这就是根本的症结所在。首先要作的是把2种语言的编码设置方式给体现出来。

大家都知道flex的编码方式是utf-8的形式，<?xml version="1.0" encoding="utf-8"?> 这句话已经说的很清楚了

jsp中也有关于编码的设置<%@ page contentType="text/html; charset=utf-8"%> 这样也可以设置jsp的编码形式

经过以上的写法，这2种语言的字符、编码都保持一致，即都是utf-8形式的，这样就使这个2个语言能够建立起来“沟通”。

一般来说，最关键的一步咱们已经搞定了。关于flex中文的传递分成以下二种情况：

1. Flex→Jsp，在上述的基础上，在jsp里面加上request.getParameter("AAA").getBytes("ISO8859-1"), "utf-8")这样就使从flex传入的参数在jsp中能保持中文字符状态。
2. Jsp→Flex，也是在上述的基础上，只要保持双方的编码形式都是utf-8的形式，就能够使Flex中的得到的结果是中文字符。

Tags: Flex  Flex2  中文问题  编码  utf-8  
相关文章:

[Flex2]我的最新作品的截图-FXBlogV2  (2006-8-5 12:35:53)

[Flex]解决引入OSX.css后控件字体显示不出来的问题！  (2006-7-15 7:39:9)

[Flex]Flex Search Beta V1.0的开发日志，截图和文档(2006.07.10更新)  (2006-4-13 12:20:11)

[Flex]Flex Weather View Beta V2.0的开发日志和截图(2006.12.02更新)  (2006-4-5 17:1:47)

[Flex]又见Flex 2.0 Beta 2 Release Download  (2006-3-28 17:58:52)

[Flex]FXBlog系统流程图  (2006-3-28 13:11:16)

[归档]有关本章原创FXBlog的一些归档  (2006-3-26 17:20:53)

[Flex]本站原创FXBlog的开发文档  (2006-3-26 16:30:32)

[Flex]FXBlog的三层结构示意图  (2006-3-25 13:51:34)

[Flex]如何用Httpservice和Webservice来和Flex进行通讯  (2006-3-25

如何更改DataGrid中某一行的背景色是一个被经常问的问题。这个在Flex2.0中很简单，只需按照下面的步骤做：

1.创建一个扩展自 mx.controls.DataGrid 的类。这个类可以是MXML文件或者ActionScript文件，你可以根据自己的习惯创建。

2.覆写 protected 方法 drawRowBackground ：

程序代码

override protected function drawRowBackground(s:Sprite, rowIndex:int, y:Number, height:Number, color:uint, dataIndex:int):void
   {
         // 这里可以做一些对数据的判断，然后更改相应的颜色。比如color = 0xFF0000;
        // 调用super函数来执行更改。
        super.drawRowBackground(s,rowIndex,y,height,color,dataIndex);
    }

3.在你的程序中用你新建的类替代 <mx:DataGrid>。

在 drawRowBackground 方法中你可以对数据做一些判断。dataIndex 参数可以用来查看dataProvider 中某一行所显示的数据。例如：假设你想要将数值大于1000的行都显示为绿色：

程序代码

var item:Object = (dataProvider as ArrayCollection).getItemAt(dataIndex);
if( item.quantity > 1000 ) color = 0x00FF00;

在CFLEX上看到一则小经验，就是关于DataGrid控件的方法。如果你不想把DataGrid中的数据绑定到控件上的话，你还可以用触发事件的方式来处理。你可以使用Click事件，也可以使用Change事件，它们基本上没有分别，不过不同的是Click事件用的是event.currentTarget，而Change 则是 event.target。例如，现在我们有一个控件叫someControl，它有一个text属性，用来显示你在DataGrid中选中的信息。如果用click事件，这么写DataGrid：

引用内容

<mx:DataGrid id="DG1" click="clickHandler(event)"/>

然后加入脚本：

引用内容

<mx:Script>
  public function clickHandler(event:MouseEvent):void
  {
      someControl.text = event.currentTarge.selectedItem.someDataField;
  }
</mx:Script>

如果用change事件，这么写DataGrid和脚本：

引用内容

<mx:DataGrid id="DG2" change="changeHandler(event)"/>

引用内容

<mx:Script>
  public function changeHandler(event:Event):void
  {
      someControl.text = event.target.selectedItem.someDataField;
  }
</mx:Script>

   Flex中一个很普遍的应用就是用组合框（ComboBox）过滤显示在DataGrid中的数据。在这个技巧里，目的是把一个“作者” 数据库表里的数据显示到DataGrid里，表的结构如下：

    

程序代码

authorId : String;
    authorName : String;
    status : String;

  另外，用户可以选择ComboBox中包含的不同的作者状态的值来过滤DataGrid显示的作者信息。推荐你把从服务器请求获得的结果转换为ArrayCollection，然后把这个ArrayCollection作为DataGrid的dataProvider。这样做你会发现操作和过滤显示的数据会很变得容易。获取数据超出了现在这个技巧的范围，不过关于这个问题有很多的例子可以参考。



  首先，把结果转换为ArrayCollection。

    

程序代码

import mx.utils.ArrayUtil;

       import mx.collections.ArrayCollection;

       // event.result contains the data from the authors search.  

       public var authorsArray : Array = mx.utils.ArrayUtil.toArray(event.result);

       // Use authorsDataProvider as the dataProvider for the dataGrid.

       [Bindable]

       public var authorsDataProvider : ArrayCollection = new ArrayCollection(authorsArray);

下面是mxml写的代码：

    

程序代码

<mx:DataGrid id="dgAuthors"
                 dataProvider="{ authorsDataProvider }"/>

接下来，把搜索结果中的作者状态值动态加载到ComboBox中。在这里，数据库中可能的作家状态值是"Active", "Inactive" 和 "Deleted"。但是在进行之前，让我们来回顾一下用例。我们把搜索作者得到的结果通过DataGrid视图向用户显示出来，在看过之后，用户可能希望过滤这些数据让它只显示“Active”的作者。当然，ComboBox中的"Active", "Inactive" 和"Deleted"可以直接硬编码，但是如果那样做的话，当数据库中添加了一个新的状态值得时候我们必须修改程序。而且，ComboBox中的值应该只包含搜索结果中的作者状态，如果搜索结果只包含状态为"Active"和"Inactive"的作者，ComboBox应该只包含相应的值（没有”Delete”）。如果所有数据库中可能的作者状态值都在ComboBox中硬编码，用户就可以选择”Delete”这个值，然后就会看到一个没有任何数据的DataGrid。我们不想困扰用户，所以接下来的代码会动态加载作者状态值到一个数组，然后把这个数组作为ComboBox的dataProvider。

    

程序代码

// Use the authorsStatusArray as the dataProvider for the comboBox.

     [Bindable]
     public var authorsStatusArray : Array = populateAuthorsStatusArray(authorsArray);

    public function populateAuthorsStatusArray(authorsArray:Array):Array
     {
             var statusArrayHashMap : Object = new Object();
                            var statusArray : Array = new Array;
              
             var n:int = authorsArray.length;
             for (var i:int = 0; i < n; i++)
             {
                              if (statusArrayHashMap[authorsArray [i].status] == undefined)
                              {
                                        statusArrayHashMap[authorsArray [i].status] = new Object();
                                        statusArray.push(authorsArray [i].status);
                              }
              }
             statusArray.sort();
             statusArray.unshift("All");

// The "All" value is used programmatically to un-filter (reset) the result in the dataGrid.  
return statusArray;
     }

  最后，通过选中的ComboBox中的值来过滤DataGrid显示的结果。

      

程序代码

public function filterAuthorsGrid():void
       {  
               authorsDataProvider.filterFunction=authorsStatusFilter;
               authorsDataProvider.refresh();          
       }

       public function authorsStatusFilter(item:Object):Boolean
       {
               if (cboAuthorsStatusFilter.selectedItem != "All")
               {
                       return item.status == cboAuthorsStatusFilter.selectedItem;

               } else {

                        return true;
               }
       }

下面是mxml写的代码：

      

程序代码

<mx:ComboBox id="cboAuthorsStatusFilter"
               dataProvider="{ authorsStatusArray }"
               change=" filterAuthorsGrid();"/>

这就是全部的技巧。因为DataGrid的dataProvider利用了绑定（binding），所以当用户在ComboBox中选中了一个值的时候，DataGrid会动态显示过滤后的结果。请紧记，这只是一个小技巧而且可能有一些生涩的地方。但是你应该可以通过这些代码领会这种思想。

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) 不要把编译器的严格模式关掉

今天我们来看看AS3中新的XML处理方法：E4X，直到现在，ECMA脚本语言规范（ECMA-262）－－AscriptScript 3.0的核心基础，并没有提供任何的XML数据处理类或方法。AcriontScript之前的版本（从Flash 5中的ActionScript开始）有一些处理XML数据的类和方法，但是它们并不是基于ECMAScript标准的。

新的ECMA脚本语言规范第4版草稿中定义了一系列新的处理XML数据的类和方法。这些类和方法的集合并命名为E4X（"ECMAScript for XML"），ActionScript 3.0包括如下新的E4X类： XML、XMLList、 QName和Namespace。

E4X类的方法、属性和操作的开法基于以下的目标：

• 简单－－E4X尽可能的使得处理XML数据的代码容易编写并且易于理解。
• 一致性－－E4X的方法于Actionscript的其它部分协调一致。
• 友好－－实用非常好理解的操作符处理XML数据，如点号（.）。

注意：为避免与E4X中的新的XML类冲突，原来ActionScript 2.0中的XML类在ActionScript 3.0被重命名为XMLDocument，为了向前兼容，在ActionScript 3.0中遗留下来的类－－XML、XMLNode、XMLParser和XMLTag--被包含进了flash.xml包中。新的E4X类是核心类－－使用它们不需要import任何包。

初始化XML对象

XML对象可以代表一个XML元素、属性、注释、处理指令或文本元素。在ActionScript 3.0中我们可以直接将XML数据赋值给变量：

var myXML:XML =
   <order>
       <item id='1'>
           <menuName>burger</menuName>
           <price>3.95</price>
       </item>
       <item id='2'>
           <menuName>fries</menuName>
           <price>1.45</price>
       </item>
   </order>

你也可以使用new 构造器来从XML数据文本创建一个XML对象实例：

var myXML:XML = new XML("<order><item id='1'><menuName>burger</menuName><price>3.95</price></item></order>")

如果XML数据不是格式完好的（如少了结束标签），那么将会出现运行时错误。

注意，你也可以将变量实例传入XML数据中：

var tagname:String = "item";
var attributename:String = "id";
var attributevalue:String = 5;
var content:String = "Chicken";
var x:XML = <{tagname} {attributename}={attributevalue}>{content}</{tagname}>;
trace (x.toXMLString())
   // Output: <item id="5">Chicken</item>

通常，我们的应用是从外部源导入XML数据，如web service或RSS feed,以下是一个从远程URL导入XML数据的例子：

var myXML:XML = new XML();
var XML_URL:String = "http://www.example.com/Sample3.xml";
//创建URLRequest。
var myXMLURL:URLRequest = new URLRequest(XML_URL);
//使用URLLoader导入数据。
var myLoader:URLLoader = new URLLoader(myXMLURL);
//添加事件监听器，以在XML数据导入完成后处理XML数据。
myLoader.addEventListener("complete", xmlLoaded);
//导入完成后，创建使用导入的数据创建XML对象
function xmlLoaded(evtObj:Event) {
       var myXML:XML = XML(myLoader.data);
       trace("Data loaded.");

}

为了演示代码的清晰性，本文中的大部份示例都第1种直接使用文本的方法创建XML对象。

E4X包含一些直观的方法XML数据的操作符（如.和@:用于访问属性）：

//获取第1个item的menuName值
trace(myXML.item[0].menuName); // Output: burger
//获取第1个item的id属性值
trace(myXML.item[0].@id);//Output:1
//获取id属性为2的item的menuName值
trace(myXML.item.(@id==2).menuName); // Output: fries
//获取menuName为burger的item的price值
trace(myXML.item.(menuName=="burger").price); // Output: 3.95

你也可以使用appendChild()方法给XML添加新的子节点：

var newItem:XML =
   <item id="3">
       <menuName>medium cola</menuName>
       <price>1.25</price>
   </item>

myXML.appendChild(newItem);

当然你也可以使用@和.操作符来更新数据:

myXML.item[0].menuName="regular burger";
myXML.item[1].menuName="small fries";
myXML.item[2].menuName="medium cola";

myXML.item.(menuName=="regular burger").@quantity = "2";
myXML.item.(menuName=="small fries").@quantity = "2";
myXML.item.(menuName=="medium cola").@quantity = "2";

访问XML数据

你可以使用.（点号）和..操作符访问XML对象的子节点，使用@操作符访问某一节点的属性。考虑以下XML对象：

 
var x:XML =
      <book ISBN="0942407296">
           <title>Baking Extravagant Pastries with Kumquats</title>
           <author>
               <lastName>Contino</lastName>
               <firstName>Chuck</firstName>
           </author>
           <pageCount>238</pageCount>
       </book>
       <book ISBN="0865436401">
           <title>Emu Care and Breeding</title>
           <editor>
               <lastName>Case</lastName>
               <firstName>Justin</firstName>
           </editor>
           <pageCount>115</pageCount>
       </book>
   </order>

对象x.book表示一个包含所有名称为book的子节点的XMLList对象，该XMLList包含两个XML对象（两个book节点）。

对象x..lastName表示一个包含XML树结构下部所有的lastName属性的XMLList对象，该XMList包含两个XML对象（两个LastName属性）。

对象x.book.editor.lastName表示一个包含所有x对象的所有名称为book的子节点的所有名称为editor的子节点的所有lastName节点的XMLList对象，该XMLList只包含一个XML对象(值为"Case"的lastName属性)。

访问父节点和子节点

parent()方法返回XML对象的父节点。

你可以使用子节点列表的顺序索引值来访问特定的子节点，例如，假定某一XML对象x有两个名称为book的子节点，你可以如下访问它们：

//第1个book节点
x.book[0]
//第2个book节点
x.book[1]

要访问孙子节点，我们可以如下直接使用儿子和孙子节点的索引值来访问：

x.book[0].title[0]

不过如果x.book[0]只有一个名称为title的子节点的话，那么可以省略索引：

x.book[0].title

类似的，如果x对象只有一个book子节点，并且该book节点的子节点对象只有一个title对象，那么两个索引值都可以省略：

x.book.title

注意，你也可以使用child()方法，直接使用名称访问特定的子节点：

var x.XML =
       <order>
           <book>
               <title>Dictionary</title>
           </book>
       </order>

var childName:String = "book";
trace (x.child(childName).title) // Output: Dictionary

访问属性

我们使用使用@操作符访问XMLNode属性：

var myXML:XML =
   <order>
       <item id='1'>
           <menuName>burger</menuName>
           <price>3.95</price>
       </item>
       <item id='2'>
           <menuName>fries</menuName>
           <price>1.45</price>
       </item>
   </order>

//获取第1个item的id属性值
trace(myXML.item[0].@id);//Output:1

使用属性或元素值过滤XML数据

我们可以使用特定的元素名称和属性值来定位到特定的元素考虑以下XML对象：

var x:XML =
   <employeeList>
       <employee id="347">
           <lastName>Zmed</lastName>
           <firstName>Sue</firstName>
           <position>Data analyst</position>
       </employee>
       <employee id="348">
           <lastName>McGee</lastName>
           <firstName>Chuck</firstName>
           <position>Jr. data analyst</position>
       </employee>
   </employeeList>

以下是正确的访问方法：

//lastName为“McGee”的employee对象，第1个employee节点
x.employee.(lastName == "McGee") // The first employee node
//lastName为“McGee”的employee对象的firstName节点，第1个employee节点的节点
x.employee.(lastName == "McGee").firstName // The firstName property of that node
//lastName为“McGee”的id属性
x.employee.(lastName == "McGee").@id // The value of the id attribute
//所有id属性值为347的employee对象列表
x.employee.(@id == 347)
//id属性值为347的employee对象的lastName子节点
x.employee.(@id == 347).lastName
//所有id属性值大于347的employee对象列表
x.employee.(@id > 300) // An XML list with both employee properties
//所有position子节点值包含“analyst”的employee对象列表
x.employee.(position.toString().search("analyst") > -1)

使用for ... in和for each ... in 语句

ActionScript 3.0 包括了一个新用来遍历XMLList对象的的for ... in语句和for each ... in语句。例如，考虑以下XML对象，myXML和myXML..item XMLList对象（包含两个item XML对象节点的XML列表）：

var myXML:XML =
   <order>
       <item id='1' quantity='2'>
           <menuName>burger</menuName>
           <price>3.95</price>
       </item>
       <item id='2' quantity='2'>
           <menuName>fries</menuName>
           <price>1.45</price>
       </item>
   </order>

for ... in语句可以让我们遍历XMLList的所有属性名称,实际上就是个节点的索引值：

var total:Number = 0;
for (var pname:String in myXML..item)
{
    total += Number(myXML.item.@quantity[pname]) * Number(myXML.item.price[pname]);
}

for each ... in语句遍历XMLList的所有节点：

var total2:Number = 0;
for each (var item:XML in myXML..item)
{
  total2 += Number(item@quantity) * Number(item.price);
}

使用with语句

我们可以使用with语句，来指明后续的属性和节点值都是基于某一XML对象，前面的for each ... in示例代码，使用with语句的代码如下：

var total:Number = 0;
for each (var item in myXML..item)
{
   with (item)
    {
         //{内的属性和节点对象都是基于item XML对象的，所有不需要使用item.来访问。
         total += Number(@quantity) * Number(price);
     }

}
trace(total);

修改XML对象

我们可以使用prependChild()方法或者appendChild()方法在XML对象的子节点列表的前面或者最后面添加节点：

var x1:XML = <p>Paragraph 1</p>
var x2:XML = <p>Paragraph 2</p>
var x:XML = <body></body>
x = x.appendChild(x1);
x = x.appendChild(x2);
x = x.prependChild(<p>Paragraph 0</p>);

// x == <body><p>Paragraph 0</p><p>Paragraph 1</p><p>Paragraph 2</p></body>

使用insertChildBefore()方法或者insertChildAfter()方法在特定的节点前面活着回后面添加节点：

var x:XML =
   <body>
       <p>Paragraph 1</p> 
       <p>Paragraph 2</p>
   </body>

var newNode:XML = <p>Paragraph 1.5</p>
x = x.insertChildAfter(x.p[0], newNode)
x = x.insertChildBefore(x.p[2], <p>Paragraph 1.75</p>)

注意，我们也可以在构造XML对象的时候使用大括号（{和}）来引用变量：

var ids:Array = [121, 122, 123];
var names:Array = [["Murphy","Pat"],["Thibaut","Jean"], ["Smith","Vijay"]]
var x:XML = new XML("<employeeList></employeeList>");

for (var i:int = 0; i < 3; i++) {
          var newnode:XML = new XML(); 
           newnode =
               <employee id={ids[i]}>
                   <last>{names[i][0]}</last>
                   <first>{names[i][1]}</first>
               </employee>

           x = x.appendChild(newnode)

}

我们也可以使用=操作符来给XML对象节点赋值：

var x:XML =
   <employee>
       <lastname>Smith</lastname>
   </employee>

x.firstname = "Jean";
x.@id = "239";

以上代码将把XML对象X设置成如下：

<employee id="239">
   <lastname>Smith</lastname>
   <firstname>Jean</firstname>
   </employee>

我们也可以使用+和+=操作符来连结XMLList：

var x1:XML = <a>test1</a>
var x2:XML = <b>test2</b>
var xList:XMLList = x1 + x2;
xList += <c>test3</c>

删除XML对象

E4X规范中定义有delete和deleteByIndex方法用来删除特定的XML节点，但是在当前版本的ActionScript 3.0实现中，并没有实现这两个方法，所有我们不能直接使用这两个方法，不过我们可以使用遍历XML树，剔除特定的节点，重新构造新的XML对象的方法来删除某一特定节点，以下我们将删除employee的lastname子节点：

private function deleteByIndex(xmlNode:XML,index:Number):XML{
    var newStr:String='';
    newStr+='<'+xmlNode.localName();
    for each (var att:XML in xmlNode.attributes()){
        newStr+=' '+att.localName()+'="'+att.toString()+'"';
    }
    newStr+='>';
    var i:Number=0;
    for each(var node:XML in xmlNode.children()){
        if(i!=index)
            newStr+=node.toXMLString();
        i++;
    }
    newStr+='</'+xmlNode.localName()+'/>';
    return new XML(newStr);
}

var myXML:XML=
   <employee id="239">
           <lastname>Smith</lastname>
           <firstname>Jean</firstname>
           <address>
           	<city>shangrao</city>
           	<load>daihu</load>
           	<no>5</no>
           </address>
       </employee>

myXML=deleteByIndex(myXML,0);

以上的deleteByIndex函数有两个参数，第1的参数是被删除节点的父节点，第2的参数是被删除节点的在父节点的子节点列表中索引值。先遍历父节点的索引属性，然后遍历其所有的子节点，跳过我们要删除的节点，然后将它们组合成新的XML对象返回。

如果XML对象非常复杂，数据量必较大的话，以上删除节点的实现方法效率是非常好低，所有正确的选择还是使用E4X定义的删除方法，不过这个功能要等到ActionScript 3.0的下一个测试版本才能够实现。

XML类型转换

我们可以将XML对象和XMLList对象转换为字符串，同样的，我们也可以将字符串转换为XML对象和XMLList对象。顺便，请记住所有的XML属性值、名称和文本值都是字符串。

转换XML和XMLList对象为字符串

XML对象和XMLList对象都有有两个成员方法：toString()和toXMLString()方法。toXMLString()方法返回包含所有标签、属性、命名空间声明和XML对象内容的字符串，对与复杂的XML对象（包含有子元素），toString()方法的效果和toXMLString()方法的效果一样，但是对与简单的XML对象（只包含一个文本元素），toString()方法只返回元素的文本内容：

var myXML:XML =
  <order>
       <item id='1' quantity='2'>
           <menuName>burger</menuName>
           <price>3.95</price>
       </item>
   <order>

trace(myXML.item0.menuName.toXMLString())
    // Output: <menuName>burger</menuName>
trace(myXML.item0.menuName.toString())
    // Output: burger

将文本字符串转换为XML对象

我们可以使用new构造方法从字符串创建一个XML对象

var x:XML = new XML('<a>test<b>');

但是如果我们试图将一个非XML或者结构不完整的字符串转换为XML对象，那么将会报运行时错误：

var x:XML = new XML('<a>test'); // Throws an error

从Internet读取Rss Fead数据

以下代码将读取本站的rss fead数据：

<?xml version="1.0" encoding="utf-8"?>
  <mx:Application xmlns:mx="http://www.macromedia.com/2005/mxml" xmlns="*" creationComplete="doInit()">
  <mx:Script>
  <![CDATA[
    private function doInit():Void{
      getRssData("http://blog.eshangrao.com/rss.php",ta_view);
    }

    public function getRssData(url:String, outTxt:TextArea):Void
    {
      private var myXMLURL:URLRequest = new URLRequest(url);
      private var myLoader:URLLoader = new URLLoader(myXMLURL);
      myLoader.addEventListener("complete", xmlLoaded);
    }
    private function xmlLoaded(event:Event):Void{
      ta_view.text='load ok';
      var myLoader:URLLoader = URLLoader(event.target);
      XML.ignoreProcessingInstructions=false;
      var myXML:XML =new XML(myLoader.data);
      private var outStr:String = "";
      for each (var item:XML in myXML.children()) {
        if(item.localName()=='item'){
          outStr += "<p><b>" + item.children()0.toString() + ":</b></p><p>";
          outStr += item.children()6.toString() ;
          outStr += " <br/><a href='" + item.children()1.toString();
          outStr += "'><font color='#008000'>More...</font></a></p>";
        }
      }
      //ta_view.text=myXML.toString();
      ta_view.htmlText = outStr;
    }
  ]]>
  </mx:Script>
  <mx:Canvas width="100%" height="100%">
    <mx:TextArea id="ta_view">
      <mx:layoutConstraints>
        <mx:EdgeAnchor bottom="10" top="10" left="10" right="10"/>
      </mx:layoutConstraints>
    </mx:TextArea>
  </mx:Canvas>
</mx:Application>

运行示例(FlashPlayer8.5 required)

注意，我们没有直接使用节点名称访问节点（不知道为什么，如果使用item.title访问title节点的话，返回是空的，可能跟我的RSS XML的中rdf指令有关，如果有朋友知道解决的办法，请告诉我），而是使用了children()方法，该方法返回某一XML对象的所有子节点对象，

获取更多AS3中E4X类的使用信息，请查看Adobe在线文档，详细API参考：Adobe Flex 2 API文档

作者 feiy, 星期三 4 一月 2006 à 16:46 ::程序人生::#164::rss

<mx:Script>
    <![CDATA[
        ...
    ]]>
</mx:Script>
例如：
<?xml version="1.0"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml">

<mx:Script>
    <![CDATA[
        var z:Number;

        public function doSomething():void {
            z = z + 1;   // This must be in a function.
        }
    ]]>
</mx:Script>
...
</mx:Application>

在ActionScript使用特殊的字符

在AC脚本当中可以假如特殊的字符，例如“<”,">"等和标签相同的符号因为
    <![CDATA[
        ...
    ]]>

内容内的代码，不被XML进行解析，所以这些特殊字符理所当然的可以自由使用。这中方法也常在FLASH调用XML时候使用。

在ActionScript同FLEX组件关联

可以在ActionScript中获取FLEX的值，使ActionScript与FLEX进行交互，例如下面的例子
<?xml version="1.0"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" >
    <mx:TextArea id="ta1" text="Congratulations. You are a winner."/>
</mx:Application>

在ActionScript中调用FLEX组件的值，使用如下代码：
<mx:Script>
	<![CDATA[
		var str:String = ta1.text; 
	]]>
</mx:Script>

包含 ActionScript 代码，导入ActionScript类

<mx:Script source="filename"></mx:Script> 其中filename是文件名，文件名可以是*.as也可以是一般文件。
例如：
loadas.mxml代码如下：
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" width="500" height="500">
	<mx:Script source="loaded.as">
	</mx:Script>
	<mx:Panel title="loadAs" width="300" height="200" verticalAlign="middle" horizontalAlign="center">
		<mx:Label id="mylabel" width="100" height="100" fontSize="14"/>
		<mx:Button id="myButton"  label="click me!" click="clickHandler(event);"/>
	</mx:Panel>
</mx:Application>

loaded.as代码如下：

// ActionScript file
import flash.events.MouseEvent;

private function clickHandler(event:MouseEvent):void{
	mylabel.text = "Hello World!";
}



创建ActionScript 组件

创建一个MyButton.as文件代码如下：

// ActionScript file
package myControls
{
	import mx.controls.Button;

    public class MyButton extends Button {
        public function MyButton() {
        	this.label = "Click Me!";
        }
    }
}

在FLEX中调用实现自己定义的组件，代码如下：
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" 
xmlns:cmp="myControls.*" >

<cmp:MyButton />

</mx:Application>
}

setInterval 有两种用法：
1.  setInterval(functionName:Function, interval:Number [, param1:Object, param2, ...,paramN]) : Number
这种使用方法是让flash player 每隔interval (ms)时间调用functionName()这个函数，不关心这个方法是哪个对象的，后面跟传入的参数；一般来说这些参数值用来为函数提供数据，而不是从函数里取出数据。

2.  setInterval(obj:Object, methodName:Function, interval:Number [, param1:Object, param2, ...,paramN]) : Number
这种方法调用obj 对象中的成员方法methodName，在flex 应用中必须使用这样的方法来实现定时调用的效果。这样的方式就能够，在methodName中就能够访问当前flex application的 成员变量或函数了。举个例子：
<?xml version="1.0" encoding="utf-8"?>
<mx:Application  initialize="initFunc()" xmlns:mx="http://www.macromedia.com/2003/mxml">
 <mx:Script>
 <![CDATA[
  var count:Number;
  function initFunc()
  {
   count = 60;
   setInterval(this, "countDown", 1000);
  }
  
  function countDown()
  {
   showLabel.text = count.toString() + "second to go";
   count -= 1;
   if(count == 0)
    timeUp();
  }
  
  function timeUp()
  {
   alert("Time is up");
  }
 ]]>
 </mx:Script>
 <mx:Label id="showLabel"/>
</mx:Application>

如果这里使用第一种方法的话 就会出现 countDown 函数不能访问到count 和 showLabel 这两个变量，功能就没法实现，虽然可以通过传参数的方法来传入count 和 label：
setInterval(countDown, 1000, count:Number, showLabel:mx.controls.Label);
但是这样话 count-=1 并不起作用，所以根本不会count down。这个搞了我好久，开始没有看到第二种用法，大家要留意。

好看一点的例子：

 function init()
 {
  var spanSec:Number=60*60 //an hour to go
  var nf:mx.formatter.NumberFormatter = new mx.formatters.NumberFormatter();
  nf.precision = 0;
  nf.rounding = "down";
 }

 function timeCountDown()
 {
  var hr:Number =parseInt(nf.format(spanSec/3600));
  var min:Number = parseInt(nf.format((spanSec - hr*3600)/60));
  var sec:Number = parseInt(nf.format(spanSec - 60*min - hr*3600));
  spanSec = spanSec - 1;
  countDownLabel.text="Time left: "+hr+":"+min+":"+sec; 
  if(spanSec == 0)
  {
   submit();
  }
  
 }

 function submit()
 {
    //do whatever you want
 }


RIA application 是一组view，而每个view 又有很多component 组成，所以说我们要做的就是在不同view 之间平滑切换，根本不会像html 页面跳转那样重新刷新页面。当然可以通过flash 的getUrl（）方法来请求以他页面从而跳转。

  <mx:Loader id="loader" width="100%" height="100%"  contentPath="aaa.mxml.swf" complete="loader.content.width = loader.maxWidth;" maintainAspectRatio="false" scaleContent="false" showBusyCursor="true" />

就是在当前application 里再加载 aaa.mxml 到 这个tag 所在的容易内。mx:Loader 的几个属性比较重要，这样的设置能让 新加载的内容很好的显示出来，不会出现显示小了的现象。

另外可以在 aaa.mxml 里只用 mx.core.Application.application 来访问顶层flex application，parentApplication来访问上一层flex application.

千万要注意的是：如果要导入 swf 文件的话，不能使用任何 AS2.0 的类和 Flash 组件，否则就无法导入。
另外的方法是可以在脚本中使用 [Embed] 标记来添加。

添加事件响应
最常用的按钮事件响应是 Click 事件