上述3种方法是Adobe官方文档提供的。但是这3种方法不能解决ViewStack子组件大小不一致，ViewStack不能自动调整的问题。
我最后是使用ActionScript动态解决的。
在更换ViewStack的active child之间，首先设置viewStack的大小。

<mx:ViewStack id="appStack">
        <mx:VBox id="v1"/>
        <mx:VBox id="v2"/>
</mx:ViewStack>

public function changeChild() : void {
        appStack.width = 200;
        appStack.height = 200;
        appStack.selectChild = v1;
}

我错了，使用ViewStack的resizeToContent是最好的解决办法。

新特性
1. 支持AMF3, 这一点无疑是激动人心的.
2. 支持JSON, 除了gateway.php外, 增加了json.php, 让你的服务能够使用JSON.
有两个例子:
http://5etdemi.com/amfphp2/samples/ajaxtables/
http://5etdemi.com/amfphp2/samples/spry/
3. 一个新的service browser
4. 在php端, 不再需要写 $this->methodTable 这个东东了. 在amfphp 1.9 中 所有的方法默认为可以远程访问，除非方法名是以下划线开始 或者 方法是 private 的（只有 php5 支持） 。

通常, Application对象创建时, 发生如下事件:
1. 实例化Application对象
2. 初始化Application.systemManager
3. Application在初始化过程之前, 派发预初始化事件.
4. 调用createChild(). 此时, 所有应用组件被创建, 所有组件的createChild()被调用.
5. Application派发初始化事件, 表明所有的组件初始化完毕.
6. 派发creationComplete事件
7. Application对象添加到显示列表中
8. 派发applicationComplete事件

大多数情况下, 我们使用<mx:Application>来创建application对象, 但如果使用ActionScript来创建的话, 那么建议不要在application的构造函数中创建组件, 推荐在crateChildren函数中, 主要是从性能方面考虑.

Flash包含的是一个时间线上的多个帧, 而Flex的SWF只包含2个帧. SystemManager, Preloader, DownloadProgressBar和少量工具类都在第一帧, 剩下的包括应用代码/ 内嵌资源全都在第二帧中. 当Flash Player下载下载SWF时, 只要接收到第一帧内足够的数据, 就会实例化SystemManager, 由它来创建Preloader, 然后创建DownloadProgressBar, 这两个对象会察看剩余字节的传输过程. 当第一帧的所有字节传输完毕后, SystemManager发送enterFrame到第二帧, 然后是其他事件. 最后Application对象派发applicationComplete事件.

应用中主要包含4个组件, 一个TextInput, 一个Tree, 一个DataGrid, 一个Label
1. 先看Tree, Tree使用_xmlData作为数据源, 定义一个change事件处理函数, 将当前节点存储到_xmlCur变量中.
2. TextInput的数据源就是_xmlCur的label属性, 也就是Tree当前节点的标签. 他也定义了一个change事件处理函数, 在TextInput中的文本改变时, 将新的文本赋值给Tree当前节点的标签, 也就是改变当前Tree节点的标签值. 值得注意的是赋值并不是直接给Tree中或者节点中的某个属性, 而是通过修改数据源Xml的值来改变的.
3. DataGrid的使用显示了如何在DataGrid中展示Xml的技巧.
4. 最后一个Label只是简单的显示当前节点的标签值, 与TextInput的文本保持同步

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

• FlexLib home page - http://code.google.com/p/flexlib/
• FlexLib discussion group - http://groups.google.com/group/flexlib
• FlexBox - http://flexbox.mrinalwadhwa.com/

现在有一个方便的做法来根据选择Enable/Disable控件。比如：有一个DataGrid和数个操作数据的按钮，当选中某行是激活其中一个按钮，选中另一行时，激活其中另一个按钮，等等。

通常的做法是写一大堆的if else语句，或者是设置一堆变量绑定到按钮上，然后在代码中设置这些变量的值，比如：

[Bindable] private var somethingSelected:Boolean = false;
<mx:Button label="Publish" click="publishItem()" enabled="{somethingSelected}" />

这是一个有益的尝试。所有的依赖于DataGrid状态的控件都绑定一个变量。改变变量的值就改变控件的enabled状态。但是你还需要确定改变变量值的时机。比如：

private function publishItem() : void {
     // get the selected item
     // publish it
     grid.selectedItem = -1; // clear the selection
     somethingSelected = false;
}

在复杂的情况下，假设有另一个按钮需要在选中某个特定值时被激活。那么你不仅需要考虑选中对应的那个变量，还需要考虑其他按钮的情况。也就是说，在publishItem函数中你还需要设置其他变量的值。

一个更方便的做法是这样的。现在我们Publish按钮和somethingSelected变量进行绑定。我们还需要做的是把somethingSelected变量与DataGrid的选中状态进行关联。对此，我们可以使用<mx:Binding>标签。

<mx:Binding source="grid.selectedIndex >= 0" destination="somethingSelected" />

这样somethingSelected的值与DataGrid的选中状态就紧密地联系起来了。当选中了DataGrid中的某条数据时，所有进行enabled="{somethingSelected}"绑定的按钮就被激活。<mx:Binding>标签的source属性不需要一定是一个变量，完全可以是一个表达式。

比如稍微复杂一点的一个例子：

<mx:Binding source="grid.selectedItem.code == 1" destination="codeOnePicked" />

这样，当DataGrid选中行的code字段的值为1时，变量codeOnePicked的值被设置为true。
mxml中可以如下定义：

<mx:CheckBox label="Code One?" selected="{codeOnePicked}" />
<mx:Button label="Publish" enabled="{somethingSelected && !codeOnePicked}" />

这样，当选中行的code字段值为1时，上面的复选框被激活，而下面的按钮无效。

http://www.adobe.com/livedocs/flex/201/html/wwhelp/wwhimpl/common/html/wwhelp.htm?context=LiveDocs_Book_Parts&file=ent_services_config_097_11.html
在Flex的序列化和反序列化过程中，只能传递public的，非静态的属性，如果要序列化此部分内容在Flex与Java间传递，必须使用externalization机制

从我们开始学习Flex时, 我们就需要了解事件流和MXML的实例化. 我非常困惑因为我实在难以理解什么样的事件会被触发或者事件什么时候会被触发. 关键是要理解事件的基础并亲自观察事件流的初始化.

我们来看一个简单的MXML的应用.

<?xml version="1.0" encoding="utf-8"?>
<mx:Application
    xmlns:mx="http://www.adobe.com/2006/mxml"
    layout="absolute"
    backgroundGradientColors="[#67cbff, #fcffff]"
    color="#000000"
    fontSize="12"   
    preinitialize="report( event , 'preinitialize' )"
    initialize="report( event , 'initialize' )"
    creationComplete="report( event , 'creationComplete' )"
    applicationComplete="report( event , 'applicationComplete' )"
    >
   
    <mx:Script>
        <![CDATA[   
                   
            [Bindable]
           
            public var outTextData:String="";
           
            public function report( event:Event , value:String ):void
            {
                outTextData += String( flash.utils.getTimer() ) + 'ms >> '
                + event.currentTarget + '.' + value + '\n';   
            }
           
        ]]>
    </mx:Script>
   
    <mx:TextArea
        id="outTextArea"
        text="{ outTextData }"
        right="10" left="10" top="50" bottom="10" alpha="0.5"
        wordWrap="false"
        initialize="report( event , 'initialize' )"
        creationComplete="report( event , 'creationComplete' )"
        />
   
    <mx:Button
        y="10" height="30" left="168" width="150"
        id="HelloButton"
        label="Say Hello"
        initialize="report( event , 'initialize' )"
        creationComplete="report( event , 'creationComplete' )"
        rollOver="report( event , 'rollOver' )"
        rollOut="report( event , 'rollOut' )"
        click="report( event , 'click > Hello!' )"
        />
       
    <mx:Button
        id="GoodByeButton"
        label="Say Goodbye"
        y="10" left="10" height="30" width="150" color="#000000"
        initialize="report( event , 'initialize' )"
        creationComplete="report( event , 'creationComplete' )"
        click="report( event , 'click > Goodbye!' )"
        />
       
    <mx:Button
        id="ClearButton"
        label="Clear"
        y="10" left="326" height="30" color="#000000" right="10"       
        initialize="report( event , 'initialize' )"
        creationComplete="report( event , 'creationComplete' )"
        click="outTextData='';report( event , 'click' )"
         />
   
</mx:Application>

这个应用运行时, 输出了实例流程和事件流. 这校我们就能够看到所有事件的触发顺序. 可以发现应用启动后, 事件的顺序是一定的. 下面是输出的内容:

167ms >> EventFlow0.preinitialize
183ms >> EventFlow0.outTextArea.initialize
187ms >> EventFlow0.HelloButton.initialize
188ms >> EventFlow0.GoodByeButton.initialize
189ms >> EventFlow0.ClearButton.initialize
189ms >> EventFlow0.initialize
243ms >> EventFlow0.outTextArea.creationComplete
243ms >> EventFlow0.HelloButton.creationComplete
243ms >> EventFlow0.GoodByeButton.creationComplete
244ms >> EventFlow0.ClearButton.creationComplete
244ms >> EventFlow0.creationComplete
246ms >> EventFlow0.applicationComplete

一旦applicationComplete事件触发后, 组件就会在鼠标事件派发后触发自己的事件.

1807ms >> EventFlow0.HelloButton.rollOver
2596ms >> EventFlow0.HelloButton.rollOut
2954ms >> EventFlow0.HelloButton.rollOver
3170ms >> EventFlow0.HelloButton.rollOut
3543ms >> EventFlow0.HelloButton.rollOver
4052ms >> EventFlow0.HelloButton.click > Hello!
4267ms >> EventFlow0.HelloButton.click > Hello!
4474ms >> EventFlow0.HelloButton.click > Hello!
4569ms >> EventFlow0.HelloButton.rollOut
4907ms >> EventFlow0.GoodByeButton.click > Goodbye!
5130ms >> EventFlow0.GoodByeButton.click > Goodbye!

在ActionScript 3中，你会发现在flash.utils包中有一系列函数提供了反射的功能。主要包含以下功能：

    * 确定对象的类
    * 获取类的成员、方法、构造函数、父类的信息
    * 确定接口声明的常数和方法
    * 在运行时根据类名创建类的实例
    * 在运行时根据成员名称获取或者设置对象成员的值
    * 在运行时根据方法名称，调用对象的方法

你可以使用类似于"describeType"之类的功能，它返回一个Xml对象。举一个例子：

package {
    import flash.display.Sprite;
    import flash.utils.describeType;
  
    public class DescribeTypeExample extends Sprite {
        public function DescribeTypeExample() {
            var child:Sprite = new Sprite();
            var description:XML = describeType(child);
            trace(description..accessor.@name.toXMLString());
        }
    }
}

如果你想进一步，根据类名创建对象的实例，我们可以使用"getDefinitionByName()"

package {
    import flash.display.DisplayObject;
    import flash.display.Sprite;
    import flash.utils.getDefinitionByName;

    public class GetDefinitionByNameExample extends Sprite {
        private var bgColor:uint = 0xFFCC00;
        private var size:uint = 80;

        public function GetDefinitionByNameExample() {
            var ClassReference:Class = getDefinitionByName(“flash.display.Sprite”) as Class;
            var instance:Object = new ClassReference();
            instance.graphics.beginFill(bgColor);
            instance.graphics.drawRect(0, 0, size, size);
            instance.graphics.endFill();
            addChild(DisplayObject(instance));
        }
    }
}

尽管这是一些非常方便的方法，但是在FlashPlayer中使用反射还是会有许多的限制，因为缺乏运行时的动态源码编译。上面的功能对于那些在内建的类，比如：Sprite类来说无疑是有用的，但是对于自定义类来说，我们会遇到很多麻烦。比如：

package {
    import com.customtypes.string; // Custom String Implementation Class
    import flash.utils.getDefinitionByName;

    public class GetDefinitionByNameExample {
        public function GetDefinitionByNameExample() {
            var ClassReference:Class = getDefinitionByName(“com.customtypes.string”) as Class;
            var instance:Object = new ClassReference();
            instance.customParameter = “my parameter”;
        }
    }
}

尽管我们使用了import语句，但是"getDefinitionByName()"还是会失败。原因上面已经说过了，在运行时编译源代码是不允许的。也许以后可以。在目前情况下，要实现上述功能，至少要在代码中初始化一个类的实例。也就是声明一个类的实例：

var customType : com.customtypes.string;

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
	<mx:Script>
		<![CDATA[
			public var foo:String = "bar";
		]]>
	</mx:Script>
</mx:Application>

在其它的地方就可以使用

Application.application.foo

来访问了. 如果需要, 也可以添加 Bindable 属性.
但是要注意到一个问题就是, 在使用的时候编译器不会进行类型的检查, 因此最好添加类型强制转换.

当然, 全局变量实现的另一种方法是使用单例模式.

由编译器自动选择一个非常好的打包方法是比较困难的。很可能需要在应用开发时进行一些设定，并不时地监控类的引用。能够统计出最优的分拆方法：应用应该分成几个SWF，哪些类应该放在哪个SWF中。但是这种方法听起来更象是一种研究范畴，实际操作起来非常困难。

让我们来看一些更具有操作性的方法。

很多应用分解后，包含两种类型的功能：“启动后立即填充”和“启动后稍后填充”。

有许许多多的应用是这种模式的。比如：游戏；你有一个游戏引擎和一些游戏场景。或者Portals和Porlets; 一些基础的共享功能和数据驱动的小应用。或者是一个大型的有着1500个页面的保险应用，运行特定功能是只会访问一小部分的页面。或者是充斥大量内容的应用，它可以独立的更新部分内容而不是强制用户每次浏览时都必须下载全部内容。

我称这些相对独立的可以延迟加载的功能为“模块”(Modules)，称加载模块的应用为“Shell”。

在这里，我们先不看如何做，先来看一些

shell需要能够与模块交互，同样模块也需要和Shell交互。如果shell引用了modules的一个类，那么它会把它链接进来。同样，如果模块类引用了shell类，它也会把它链接进来。应用能正常运行只有两个方法：或者引用是相同而且共享的(这样就不需要下载两次)，或者两者是不同的，而且没有任何关系(尽管两个类名字相同，但是它们被认为是无关的，而且不能交互)。

最好的解决办法是让模块和shell通过接口交互。这样，shell不需要引用模块，而是引用模块会实现的一些接口。同样，模块不实现shell的类，而是允许调用的API接口。

这样在shell变化的时候减少了重新编译模块的次数。具体实现的变化频率往往会比接口本身的变化高得多，而只要接口稳定，就不需要重新编译所有的东西。

注意：需要使用extern（或者extern-library-path)选项来创建模块，这样可以自动剔除shell的类，因为模块是被加载到shell的子应用域中的，将shell的类剔除是安全的。这样模块可以真正直接引用shell中的类。

记住SWC文件是一个包含SWF文件的二进制文件，而SWF文件包含运行时的定义和附属元数据。你可以用压缩工具比如WinZip来打开SWC文件。
在使用RSL之前，首先需要了解如何静态链接一个SWC文件。

在这个例子中，应用有一个app.mxml文件，使用ProductConfigurator.as和ProductView.as。文件目录如下：

project/src/app.mxml
project/libsrc/ProductConfigurator.as
project/libsrc/ProductView.as
project/lib/
project/bin/

编译这个应用时，可以使用source-path选项将/libsrc目录下的类链接进来，方法如下：

cd project/src
mxmlc -o=../bin/app.swf -source-path+=../libsrc app.mxml

这个命令添加ProductConfigurator和ProductView类到SWF文件中。

如果要创建库，可以用compc来创建SWC文件，用下面的命令：

cd project
compc -source-path+=libsrc -debug=false -o=lib/mylib.swc
ProductConfigurator ProductView

注意要将debug选项设置为false. 生成结果是project/lib/mylib.swc文件，包含ProductConfigurator和ProductView两个类。

现在可以使用新创建的库来重新编译应用，用library-path选项来指定库，方法如下：

cd project/src
mxmlc -o=../bin/app.swf -library-path+=../lib/mylib.swc app.mxml

创建库以后，你可以用RSL来重新编译生成应用。完整的步骤如下：

   1. 指示编译器不要将库链接到应用中。
   2. 准备RSL，以便于在运行时使用。
   3. 指示编译器生成附加元数据用于加载RSL。

第一步是指定编译生成应用时库中的哪些类需要排除在外。主要是使用external-library-path选项，如下面的例子所示：

cd project/src
mxmlc -o=../bin/app.swf -external-library-path+=../lib/mylib.swc app.mxml

如果你尝试运行app.swf，Flash Player会抛出一个运行时异常。因为ProductConfigurator和ProductView类还未定义。external-library-path配置选项告诉编译器编译这些库，但是忽略了定义。你也可以使用externs选项，但是一般来说，使用external-library-path更方便。

下一步是准备RSL以便于能在运行时找到它。首先从SWC文件中将library.swf解压出来。

下面是如何解压的例子：

cd project/lib
unzip mylib.swc library.swf
mv library.swf ../bin/myrsl.swf

此例子中将library.swf更名为myrsl.swf，并把它移动到应用SWF文件所在的目录。

最后一步是使用RSL重新编译应用。主要是使用runtime-shared-libraries选项，方法如下：

cd project/src
mxmlc -o=../bin/app.swf -external-library-path+=../lib/mylib.swc
-runtime-shared-libraries=myrsl.swf app.mxml

现在新的SWF文件会在运行应用前动态加载RSL了。

    * runtime-shared-libraries 提供运行运行时共享库的位置.
    * external-library-path|externs|load-externs 提供编译时库的位置. 编译器需要这个信息动态链接.

使用runtime-shared-libraries选项来指定SWF文件的位置, 这样应用能够在运行时加载RSL. 需要指定SWF与部署位置的相对路径. 比如: 如果把library.swf文件放在web_root/libraries目录下, 而应用在web_root目录下, 那么文件的指定方法是: libraries/library.swf
可以用这个选项指定多个库. 如果指定了多个库, 需要用逗号分隔.

使用external-library-path选项来指定library在编译时的SWC文件或者目录的位置. 编译器会在编译时根据这个选项进行链接的检查. 你还可以使用externs或者load-externs选项来指定其他单独的classes或者xml文件来定义库的内容.

下面是一个编译MyApp应用的命令行示例, 其中使用了2个库:

mxmlc -runtime-shared-libraries=
../libraries/CustomCellRenderer/library.swf,
../libraries/CustomDataGrid/library.swf
-external-library-path=../libraries/CustomCellRenderer,
../libraries/CustomDataGrid MyApp.mxml

库的顺序非常重要, 因为基础类必须先加载.

你先可以使用配置文件, 示例如下:

<compiler>
    <external-library-path>
        <path-element>../libraries/CustomCellRenderer</path-element>
        <path-element>../libraries/CustomDataGrid</path-element>
        <path-element>../libs/playerglobal.swc</path-element>
    </external-library-path>
</compiler>
<runtime-shared-libraries>
    <url>../libraries/CustomCellRenderer/library.swf</url>
    <url>../libraries/CustomDataGrid/library.swf</url>
</runtime-shared-libraries>

runtime-shared-libraries选项值是library.swf文件是相对部署目录的路径. external-library-path选项是编译时SWC文件的路径. 因此, 必须先知道库的部署路径.

示例中, 编译时文件结构如下:

c:/appfiles/MyApp.mxml
c:/libraries/CustomCellRenderer/CustomCellRenderer.swc
c:/libraries/CustomDataGrid/CustomDataGrid.swc

library.swf在编译进不是必需的. Flex编译器不验证SWF文件的存在与否, 但会把路径信息编译进行最后的应用代码中.

文件的部署结构如下:

web_root/MyApp.swf
web_root/libraries/CustomCellRenderer/library.swf
web_root/libraries/CustomDataGrid/library.swf

可以使用Flex Builder或者Compc命令行来创建库. 库可以是一个SWC文件, 或者是包含了library.swf和catalog.xml文件的目录. 一个库通常包含自定义组件和类. 然后就可以在RSL中使用这些库了.

在Flex Bulder中, 通过使用Flex Library Build Path对话框来添加资源到库中.

在命令行中, 使用include-classes和include-namespaces选项来添加文件到库中.

下面的命令行示例说明了如何创建一个名字叫CustomCellRenderer的库:

compc -source-path ../mycomponents/components/local
-include-classes CustomCellRendererComponent -directory=true -debug=false
-output ../libraries/CustomCellRenderer

所有包含的组件必须是静态链接的文件. 使用compc编译器创建库时, 不能使用include-file选项, 因为这个选项不是将library.swf文件静态链接到库中的.

可以使用directory选项指定输出到一个目录而不是到一个SWC文件中:

<?xml version="1.0">
<flex-config>
    <compiler>
        <source-path>
            <path-element>mycomponents/components/local</path-element>
        </source-path>
    </compiler>
    <output>libraries/CustomCellRenderer</output>
    <directory>true</directory>
    <debug>false</false>
    <include-classes>
        <class>CustomCellRendererComponent</class>
    </include-classes>
</flex-config>

输出会是一个目录,目录里包含两个文件
    * catalog.xml
    * library.swf

创建library.swf文件后, 你可以编译应用并且指定文件的位置.

Flex and Flash provide a complete, unlimited, flexible tool to build user experiences. From the standpoint of a programmer’s time investment, you can learn a single language for building UIs without worrying about running into problems or limitations later—issues like:

• Installation problems
• Constraints on what you can create
• Sudden steep climbs in the learning curve

原文链接:

http://www.artima.com/weblogs/viewpost.jsp?thread=193593

Computing Thoughts
Hybridizing Java
by Bruce Eckel
January 30, 2007

RSL也不是对于所有的应用都是有益的. 需要对应用RSL前后的下载时间和启动时间都测试过, 才能得到正确的结论.

RSL不能跨域共享. 如果客户在一个域中使用了RSL, 然后运行了另一个域的应用, 虽然这两个RSL是相同的, 但是需要下载两次.

RSL通常会增加应用的启动时间. 这是应用不管整个库实际如何使用, 只是简单地全部加载整个库. 就这一点来说, RSL越小越好. 这与静态链接库的使用是不同的. 当你编译一个Felx应用时, 编译器只解开需要的组件. 一般来说, 库的大小可以是任意的, 它只影响编译时间而不会影响下载的时间.

如果在好几个应用中使用相同的组件库, 那么可以考虑合并这些库, 形成一个RSL. 但是如果库合并后, 每个应用只会用到其中的一小部分, 那么还不如多加载几个小RSL更高效.

如果一些类重复打包在多个RSL中, 那么一定要注意同步更新的问题.

RSL不能应用在基类是Sprite或者MovieClip的纯ActionScript项目中. 因为RSL需要基类知道如何加载RSL, 比如: Application或者SimpleApplication.

关于 framework.swc文件

framework.swc是一个标准的SWC文件. 缺省地它不能用作RSL. 整个framwork.swc文件不被链接到任何一个应用中. Flex编译器只将那些应用用到的部分链接到生成最后的SWF文件. 比如: 如果一个应用只使用了Button, Panel和TextArea控件, 那么只有这几个控件和它们的依赖项被编译器链接.

几乎所有的应用都需要framework.swc文件的一部分, 但是它并不适合作为RSL. 原因如上据说, RSL是整个链接, 不管实际使用多少的. 如果RSL包含了很多类, 而应用只使用了其中的一小部分, 那么这样的加载方式并不是最合理的. 这样使用会造成应用的启动时间大大增加.


RSL的优点

下面的一个例子说明了将几个的共享组件做成RSL的优点. 在这个例子中, 组件库的大小是150K, 编译后的应用的大小是100K.
 

使用了RSL, RSL只被下载一次. 那么合计下载量是350K, 节约了30%. 如果再添加第3个, 第4个应用的话, 每次都能150K的下载量.

一般来说, 在一个域中使用同一个RSL的应用越多, 那么好处就越大.

当你使用静态链接时, 编译器将应用中所有引用的类和依赖生成到最终的SWF文件中, 这个文件会比较大, 下载也会比较慢, 但是下载完毕后, 运行会比较快, 因为SWF文件中已经包含了所有的代码.

如果你的应用中使用了类库, 那么你需要使用类路径或者是添加SWC文件. 如果是使用类路径, 编译器会将类路径中用到的那部分类打包生成到SWF文件中. 如果是使用SWC文件, 编译器会将整个SWC文件打包到SWF文件中.

动态链接是这样的: 一个应用要使用的一部分类存在于一个外部的文件中, 运行时动态加载. 这样的话, 主SWF文件可以小一些, 但是应用依赖于运行时加载的外部文件. RSL就是使用动态链接的.

如果想使用动态链接类, 需要把它们编译成库. 然后编译器将库中的内容从SWF文件剔除出去. 而且必须在编译时提供链接检查.

为指定哪些文件是动态链接的,需要使用外部库路径选项,外部选项或者外部加载编译选项. 这些选项告诉编译器从应用中去除此部分内容, 而预备在运行时调用. 外部选项为动态链接指定了单独的类. 外部加载选项指定了一个XML文件, 描述了动态链接的类.

指定SL的外部资源的顺序是非常关键的, 因为被其他类调用的基础类必须被首先加载.

你还要用runtime-shared-libraries选项来指定RSL的位置.

你可以使用link-report这个编译选项来查看应用的链接信息.

如果你有多个应用而且这些应用共享一些核心组件或者类, 那么作为RSL,用户只会唯一的一次加载这些资源. 只要应用在同一个域中, 这些应用共享同一个缓存的RSL, 这样应用文件的大小就减小了. 使用RSL的应用越多, 效果越好, 如果只有一个应用, 总的文件大小不但不减小,反而会增大.

你既可以使用Flex Builder通过项目选项来创建Flex的Library项目,也可以使用compc这样的命令行. 编译好RSL以后, 可以在编译应用时把Library的位置传递给编译器.

下面是适合使用RSL的典型用例:
    * 大型应用, 需要使用通用组件库加载多个小型应用. 最顶级的应用和下级应用可以共享存储在RSL中的组件.

    * 在一个服务器上的使用通用组件库的系列应用. 当用户操作第一个应用时, 用户下载应用的SWF文件和RSL. 当操作第二个应用时, 用户就只需要下载应用本身的SWF文件就行了.
    
    * 一个独立的应用使用RSL的意义在于: 如果这个应用本身会频繁的修改, 而有一部分组件是极少改动的. 在这种情况下, 使用RSL的好处是: 组件下载一次, 而应用可以多次下载.

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
这个号称世上最小的标签是不是很好用啊？