flex数据绑定

1.关于数据绑定

    数据绑定是将一个对象中的数据同另一个对象中的数据联系在一起的过程。数据绑定为在
应用的不同层之间传递数据提供了便捷方法。数据绑定需要一个源属性，一个目的属性，以及
用于表明何时将数据从源属性拷贝到目的属性的触发事件。当源属性变化时，对象发出触发事
件。

    Adobe Flex 提供三种方法用于指定数据绑定：MXML 中的大括号({})语法，MXML 中的
<mx:Binding>标记，以及ActionScript 中的BindingUtils 的系列方法。

 

(1)下面的例子使用大括号({})语法来展示一个Text 控件，该控件的数据来自于TextInput 控件Text 属性：

<?xml version="1.0"?>
<!-- binding/BasicBinding.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml ">
<mx:TextInput id="myTI" text="Enter text here"/>
<mx:Text id="myText" text="{myTI.text}"/>
</mx:Application>

    数据绑定表达式中可以将ActionScript 代码以及E4X 表达式作为一部分包含进来，如下例
所示：
<?xml version="1.0"?>
<!-- binding/BasicBindingWithAS.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml ">
<mx:TextInput id="myTI"/>
<mx:Text id="myText" text="{myTI.text.toUpperCase()}"/>
</mx:Application>

 

(2)用<mx:Binding>标记 作为大括号语法的替代方法。在使用<mx:Binding>时，要为
<mx:Binding>标记提供一个源属性作为标记的source 属性以及提供一个目的属性作为标记的
destination 属性。下面的例子使用<mx:Binding>标记定义了一个从TextInput 控件到Text 控
件的数据绑定：

   <?xml version="1.0"?>
<!-- binding/BasicBindingMXML.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml ">
<mx:TextInput id="myTI"/>
<mx:Text id="myText"/>
<mx:Binding source="myTI.text" destination="myText.text"/>
</mx:Application>

 

   同大括号语法相比，用<mx:Binding>标记能够将视图（用户界面）同模型完全分离。
<mx:Binding>标记也能实现将多个源属性绑定到一个相同的目的属性，这是因为能够定义多个
具有相同的destination 属性的<mx:Binding>标记.

 大括号语法和<mx:Binding>标记都能在编译期定义数据绑定，而使用ActionScript 代码则
可以在运行期定义数据绑定，如下例所示：

<?xml version="1.0"?>
<!-- binding/BasicBindingAS.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml ">
<mx:Script>
<![CDATA[
import mx.binding.utils.*;
// Define data binding.
public function initBindingHandler():void {
BindingUtils.bindProperty(myText, "text", myTI, "text");
}
]]>
</mx:Script>
<mx:TextInput id="myTI"/>
<mx:Text id="myText" preinitialize="initBindingHandler();"/>
</mx:Application>

 

(3)创建用作数据绑定源的属性

   当创建一个用于绑定表达式源的属性，那么在源属性值发生变化时Flex 就能自动将值拷贝
到所有的目的属性。为了让Flex 执行拷贝，必须使用[Bindable]标记来向Flex 注册这个属性。
The [Bindable] 元数据标记有以下语法:
[Bindable]
[Bindable(event="eventname")]

   如果忽略了事件名称，Flex 自动地创建一个名为propertyChange 的事件，并且在属性发生
变化时，由Flex 发出这个事件以触发所有以这个属性作为源的数据绑定。

   下面的例子作了一个maxFontSize 属性和一个minFontSize 属性变量可用于数据绑定表达式的源：

 

<?xml version="1.0"?>
<!-- binding/FontPropertyBinding.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml ">
<mx:Script>
<![CDATA[
// Define public vars for tracking font size.
[Bindable]
public var maxFontSize:Number = 15;
[Bindable]
public var minFontSize:Number = 5;
]]>
</mx:Script>
<mx:Text text="{maxFontSize}"/>
<mx:Text text="{minFontSize}"/>
<mx:Button click="maxFontSize=20; minFontSize=10;"/>
</mx:Application>

2. 在ActionScript 中定义数据绑定
  通过使用mx.binding.utils.BindingUtils能够在ActionScript中定义绑定。这个类定义了
几个静态方法，通过使用bindProperty() 方法可以让我们创建一个到用变量实现的属性的数据
绑定，或者用bindSetter()方法创建一个到用方法实现的属性的数据绑定。
 
(1)在MXML 与在ActionScript 定义数据绑定的区别
编译期在MXML 中定义数据绑定与在运行期在ActionScript 中定义数据绑定有一些不同之
处：
不能在由bindProperty()或者bindSetter()方法定义绑定表达式中引入
ActionScript 代码。相反，使用bindSetter()方法可以指定一个在绑定发生时调用的
方法。
不能在由ActionScript 中定义的绑定表达式中引入E4X 表达式。
在由the bindProperty()或者bindSetter()方法定义的数据绑定表达式的属性链中
不能引入函数或者数组元素。更多信息见Working with bindable property chains.
同运行时使用bindProperty()或者bindSetter()定义的数据绑定相比，MXML 编译器
有更好的警告和错误检查支持。
 
(2)范例：在ActionScript 中定义数据绑定
下面的例子是用bindSetter()建立了一个数据绑定。bindSetter()方法的参数设置如下：
源（source） 对象
源（source） 属性名
当源（source）属性变化被调用的方法。
下面的范例中，当向TextInput 控件中输入文本时，文本会被转换为大写形式并拷贝给TextArea
控件：
<?xml version="1.0"?>
<!-- binding/BindSetterAS.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml">
<mx:Script>
<![CDATA[
import mx.binding.utils.*;
import mx.events.FlexEvent;
// Method called when myTI.text changes.
public function updateMyString(val:String):void {
myTA.text = val.toUpperCase();
}
<!-- Event listener to configure binding. -->
public function mySetterBinding(event:FlexEvent):void {
var watcherSetter:ChangeWatcher =
BindingUtils.bindSetter(updateMyString, myTI, "text");
}
]]>
</mx:Script>
<mx:Label text="Bind Setter using setter method"/>
<mx:TextInput id="myTI"
text="Hello Setter" />
<mx:TextArea id="myTA"
initialize="mySetterBinding(event);"/>
</mx:Application>
 
(3)定义绑定观察者 （watchers）
Flex 有个mx.binding.utils.ChangeWatcher 类，可以用这个类来定义一个数据绑定观察
者。通常，数据绑定观察者在绑定发生时激活一个事件监听器。可按照下面的范例使用
ChangeWatcher 的watch()即可建立一个数据绑定观察者：
<?xml version="1.0"?>
<!-- binding/DetectWatcher.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
initialize="initWatcher();">
<mx:Script>
<![CDATA[
import mx.binding.utils.*;
import mx.events.FlexEvent;
import mx.events.PropertyChangeEvent;
public var myWatcher:ChangeWatcher;
// Define binding watcher.
public function initWatcher():void {
// Define a watcher for the text binding.
ChangeWatcher.watch(textarea, "text", watcherListener);
}
// Event listener when binding occurs.
public function watcherListener(event:Event):void {
myTA1.text="binding occurred";
// Use myWatcher.unwatch() to remove the watcher.
}
]]>
</mx:Script>
<!-- Define a binding expression_r to watch. -->
<mx:TextInput id="textinput" text="Hello"/>
<mx:TextArea id="textarea" text="{textinput.text}"/>
<!-- Trigger a binding. -->
<mx:Button label="Submit" click="textinput.text='Goodbye';"/>
<mx:TextArea id="myTA1"/>
</mx:Application>
上面的范例中，为数据绑定观察者定义了事件监听器，在这个事件监听器中使用了单个参
数来包含事件对象。事件对象的数据类型由被观察的属性所决定。每个可绑定的属性会不同的
事件类型以及相关的事件对象。有关确定事件类型的更多信息见“使用Bindable 元数据标记”。

3. 绑定到函数、对象和数组

   (1)绑定函数以响应数据绑定事件

可以把使用“不可绑定的参数”的函数作为数据绑定表达式的源。但是，必须有一种办法
能够激活这个函数以更新数据绑定的目的属性。
在下面的例子中，使用了[Bindable]元数据标记来指定Felx 调用isEnabled()函数以响应
myFlagChanged 事件。当myFlag 的 setter 方法被调用时，它就发出了一个myFlagChanged 事
件，这个事件触发任何使用isEnabled()函数作为源的数据绑定。
<?xml version="1.0"?>
<!-- binding/ASFunction.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml ">
<mx:Script>
<![CDATA[
import flash.events.Event;
// Define a function that gets invoked
// in response to the myFlagChanged event.
[Bindable(event="myFlagChanged")]
private function isEnabled():String {
if (myFlag)
return 'true';
else
return 'false';
}
private var _myFlag:Boolean = false;
// Define a setter method that dispatches the
// myFlagChanged event to trigger the data binding.
public function set myFlag(value:Boolean):void {
_myFlag = value;
dispatchEvent(new Event("myFlagChanged"));
}
public function get myFlag():Boolean {
return _myFlag;
}
]]>
</mx:Script>
<!-- Use the function as the source of a data binding expression_r. -->
<mx:TextArea id="myTA" text="{isEnabled()}"/>
<!-- Modify the property, causing the setter method to
dispatch the myFlagChanged event to trigger data binding. -->
<mx:Button label="Clear MyFlag" click="myFlag=false;"/>
<mx:Button label="Set MyFlag" click="myFlag=true;"/>
</mx:Application>

 

(2)将对象用于数据绑定
当使用对象进行工作时，不得不考虑什么时候定义到这个对象的绑定？或者考虑什么时候
定义一个到这个对象属性的绑定？
绑定到对象
当使一个对象成为数据绑定表达式的源时，数据绑定发生在这个对象被更新之时，或者这
个对象的引用被更新之时，但不能发生在这个对象的单个（数据）域（feild）被更新之时。
下面的范例中，创建了Object 类的子类，这个子类带有两个属性，stringProp 和intProp，
但没有使这两个属性成为可绑定属性：
package myComponents
{
// binding/myComponents/NonBindableObject.as
// Make no class properties bindable.
public class NonBindableObject extends Object {
public function NonBindableObject() {
super();
}
public var stringProp:String = "String property";
public var intProp:int = 52;
}
}
因为这个类的两个属性不是可绑定属性，当它们被更新时Flex 不会发出事件去触发数据绑
定。接下来在Flex 应用中使用这个类，如下面的范例所示：
<?xml version="1.0"?>
<!-- binding/WholeObjectBinding.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml "
creationComplete="initObj();">
<mx:Script>
<![CDATA[
import myComponents.NonBindableObject;
[Bindable]
public var myObj:NonBindableObject = new NonBindableObject();
[Bindable]
public var anotherObj:NonBindableObject =
new NonBindableObject();
public function initObj():void {
anotherObj.stringProp = 'anotherObject';
anotherObj.intProp = 8;
}
]]>
</mx:Script>
<!-- Data binding updated at application startup. -->
<mx:Text id="text1" text="{myObj.stringProp}"/>
<!-- Data binding updated at application startup. -->
<mx:Text id="text2" text="{myObj.intProp}"/>
<!-- Data bindings to stringProp not updated. -->
<mx:Button label="Change myObj.stringProp"
click="myObj.stringProp = 'new string';"/>
<!-- Data bindings to intProp not updated. -->
<mx:Button label="Change myObj.intProp"
click="myObj.intProp = 10;"/>
<!-- Data bindings to myObj and to myObj properties updated. -->
<mx:Button label="Change myObj"
click="myObj = anotherObj;"/>
</mx:Application>
因为没有使NonBindableObject 类的单个数据域（fields）成为可绑定属性，所以应用在
两个Text 控件的绑定在应用启动时以及在myObj 被更新时才会被更新。在编译这个应用时，编
译器会输出警告信息，提示数据绑定机制不能检测stringProp 和intProp 属性的变化。

 

(3)绑定到对象的属性
为了使对象的属性可绑定，要创建新的类定义，如下面的范例所示：
package myComponents
{
// binding/myComponents/BindableObject.as
// Make all class properties bindable.
[Bindable]
public class BindableObject extends Object {
public function BindableObject() {
super();
}
public var stringProp:String = "String property";
public var intProp:int = 52;
}
}
通过在类定义之前放置[Bindable]元数据标记，就可以使得类中所有public 变量、以及所有
完全具备setter 及getter 的public 属性成为可绑定的属性。接下来就可以使用stringProp
和intProp 属性作为数据绑定的源，如下范例所示：
<?xml version="1.0"?>
<!-- binding/SimpleObjectBinding.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml "
creationComplete="initObj();">
<mx:Script>
<![CDATA[
import myComponents.BindableObject;
[Bindable]
public var myObj:BindableObject = new BindableObject();
[Bindable]
public var anotherObj:BindableObject =
new BindableObject();
public function initObj():void {
anotherObj.stringProp = 'anotherObject';
anotherObj.intProp = 8;
}
]]>
</mx:Script>
<!-- Data binding updated at application startup. -->
<mx:Text id="text1" text="{myObj.stringProp}"/>
<!-- Data binding updated at application startup. -->
<mx:Text id="text2" text="{myObj.intProp}"/>
<!-- Data bindings to stringProp updated. -->
<mx:Button label="Change myObj.stringProp"
click="myObj.stringProp = 'new string';"/>
<!-- Data bindings to intProp updated. -->
<mx:Button label="Change myObj.intProp"
click="myObj.intProp = 10;"/>
<!-- Data bindings to myObj and to myObj properties updated. -->
<mx:Button label="Change myObj"
click="myObj = anotherObj;"/>
</mx:Application>

(4)在绑定中使用数组
在使用数组进行工作时，比如Array 或者ArrayCollection 对象，可以把数组作为数据绑定
表达式的源或目的。
注意: 当使用数组作为绑定源时，应该使用ArrayCollection 类型的数组，因为
ArrayCollection 类在数组或数组元素发生变化时能够发出事件来触发数据绑定。比如，对
ArrayCollection.addItem(), ArrayCollection.addItemAt(),
ArrayCollection.removeItem(), 以及ArrayCollection.removeItemAt()方法的调用都会触发
数据绑定。
绑定到数组
通常将数组绑定给Flex 控件的dataProvider 属性，下面范例说明将数组绑定用于List 控
件：
<?xml version="1.0"?>
<!-- binding/ArrayBindingDP.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml ">
<mx:Script>
<![CDATA[
import mx.collections.ArrayCollection;
[Bindable]
public var myAC:ArrayCollection = new ArrayCollection([
"One", "Two", "Three", "Four"]);
[Bindable]
public var myAC2:ArrayCollection = new ArrayCollection([
"Uno", "Dos", "Tres", "Quatro"]);
]]>
</mx:Script>
<!-- Data binding updated at application startup,
when myAC is modified, and when an element of
myAC is modifed. -->
<mx:List dataProvider="{myAC}"/>
<!-- Data bindings to myAC updated. -->
<mx:Button
label="Change Element"
click="myAC[0]='mod One'"/>
<!-- Data bindings to myAC updated. -->
<mx:Button
label="Add Element"
click="myAC.addItem('new element');"/>
<!-- Data bindings to myAC updated. -->
<mx:Button
label="Remove Element 0"
click="myAC.removeItemAt(0);"/>
<!-- Data bindings to myAC updated. -->
<mx:Button
label="Change ArrayCollection"
click="myAC=myAC2"/>
</mx:Application>
这个例子定义了一个ArrayCollection 对象，然后将List 控件的dataProvider 属性设置
为对这个ArrayCollection 的数据绑定。当修改ArrayCollection 对象中的元素，或者修改对
ArrayCollection 对象的引用，都会触发数据绑定。
绑定到数组中的元素
可以使用数组中的单个元素作为数据绑定源，如下例所示：
<?xml version="1.0"?>
<!-- binding/ArrayBinding.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml ">
<mx:Script>
<![CDATA[
import mx.collections.ArrayCollection;
[Bindable]
public var myAC:ArrayCollection = new ArrayCollection([
"One", "Two", "Three", "Four"]);
[Bindable]
public var myAC2:ArrayCollection = new ArrayCollection([
"Uno", "Dos", "Tres", "Quatro"]);
]]>
</mx:Script>
<!-- Data binding updated at application startup
and when myAC modified. -->
<mx:Text id="text1" text="{myAC[0]}"/>
<!-- Data binding updated at application startup,
when myAC modified, and when myAC[0] modified. -->
<mx:Text id="text2" text="{myAC.getItemAt(0)}"/>
<mx:Button id="button1"
label="Change Element"
click="myAC[0]='new One'"/>
<mx:Button id="button2"
label="Change ArrayCollection"
click="myAC=myAC2"/>
</mx:Application>
如果通过方括号语法[]来指定数组元素作为数据绑定表达式的源，那么数据绑定只在应用
启动时触发，或者在数组或其引用被更新时触发。当这个数组元素被更新的时候不会触发数据
绑定。
但数据绑定表达式中的myAC.getItemAt(0)则会在该数组元素变化时被触发更新。因此，id
为 text2 的Text 控件在点击button1 时会被更新，而id 为text1 的Text 控件则不会被更新。
当使用数组中的元素作为数据绑定表示的源时，应当在绑定表达式中使用
ArrayCollection.getItemAt()方法。

点击button2 时将myAC2 拷贝给myAC，这会触发对数组元素的所有数据绑定而不论它们是如
何实现的。

4. 使用Bindable 元数据标记
当属性成为数据绑定表达式源时，Flex 在源属性发生变化时自动将源属性的值拷贝给目的
属性。为了告知Flex 去执行这个拷贝工作，必须用[Bindable]元数据标记将这个属性注册到
Flex 中，并且源属性必须发出一个事件。
[Bindable] 元数据标记语法如下：
[Bindable]
[Bindable(event="eventname")]
如果忽略事件名称，Flex 会自动创建一个名为propertyChange，类型为
PropertyChangeEvent 的事件。
可以在三个地方使用[Bindable]元数据标记：
1. 在public 类定义之前使用。
在这个地方使用[Bindable]元数据标记使得类中定义的全部public 变量以及同时具
有setter 和getter 方法的public 属性能成为数据绑定表达式的源。这种情况下，
[Bindable]不使用任何参数，如下例所示：
[Bindable]
public class TextAreaFontControl extends TextArea {}
Flex 编译器自动为所有public 属性生成名为propertyChange，类型为
PropertyChangeEvent 的事件，以使这些属性可以被用于数据绑定表达式的源。
如果对属性进行写操作的时候属性值保持不变，Flex 不会发出事件或者更新属
性，这里判断属性是否不同可以翻译为如下的检测语句：
(oldValue !== value)
这意味着，如果属性包含了一个对象引用，并且引用被更改为引用了一个不同但
是等价的对象，那么绑定也会被触发。如果属性没有被改变，而它所指向的对象在
内部发生了变化，那么绑定不会被触发。
注意:在public class 定义之前使用[Bindable]元数据标记只是将绑定作用于
public 属性，它不会作用于private 和protected 属性以及那些定义在其他
namespace 中的属性。必须在非public 属性前插入[Bindable]元数据标记，才能使
之成为数据绑定表达式的源。
2. 在public，protected 或者private 属性之前使用该标记可以将这个特定的属性定
义为支持数据绑定，标记可以有以下的形式：
[Bindable]
public var foo:String;
Flex 编译器自动为那个属性产生名为propertyChange，类型为PropertyChangeEvent
的事件，如果写入的属性值不变，Flex 不会发出事件或者更新属性。也可以在
[Bindable]元数据标记中指定事件名，如下的例子所示：
[Bindable(event="fooChanged")]
public var foo:String;
这种情况下，开发者要自己负责产生和发出事件，通常在类的其他方法中完成
这些工作。尽管在类的级别上指定了[Bindable]标记，如果想要为事件命名，仍然
可以在[Bindable]中包含指定名称的事件。
3. 在由getter 或者setter 方法所定义的public，protected 或者private 属性之前
使用该标记。这种情况下，要想使用[Bindable]标记必须为属性同时定义setter 和
getter 方法。如果只是定义了一个setter 方法，那么你就创建了一个“只写”属性，
这样的属性不能作为数据绑定表达式的源。如果只定义getter 方法，那么就创建了
一个“只读”属性，把只读属性当作数据绑定源而不插入[Bindable]标记，就如同
使用了一个用const 关键字定义的变量来作为数据绑定表达式的源。（这样的绑定
源只能在应用启动时触发绑定一次，以后就不会再触发）。
这个标记可以由下面的形式定义：
[Bindable]
public function set shortNames(val:Boolean):void {
...
}
public function get shortNames():Boolean {
...
}
Flex 编译器自动为这个属性产生一个名为propertyChange，类型为
PropertyChangeEvent 的事件。如果属性值在写入的时候保持不变，Flex 不会发出
事件或者更新属性。为了确定属性是否变化，Flex 调用getter 方法来获取属性的当
前值。
也可以为事件指定名称，如下例所示：
[Bindable(event="changeShortNames")]
public function set shortNames(val:Boolean):void {
...
// Create and dispatch event.
dispatchEvent(new Event("changeShortNames"));
}
// Get method.
public function get shortNames():Boolean {
...
}
这种情况下，开发者要负责生成和发出事件。通常是在setter 方法中完成这个工作。
并且Flex 不会检查旧值和新值是否不同。尽管在类的级别上指定了[Bindable]标记，如果
想要为事件命名，仍然可以在[Bindable]中包含指定名称的事件。
下面的代码使以变量形式定义的maxFontSize 和minFontSize 属性可以作为数据绑定的
源：
// Define public vars for tracking font size.
[Bindable]
public var maxFontSize:Number = 15;
[Bindable]
public var minFontSize:Number = 5;
在下面的例子中，使setter 和getter 方法形式定义的public 属性成为数据绑定的源。
[Bindable]元数据标记中引入了属性变化时由setter 方法发出的事件：
// Define private variable.
private var _maxFontSize:Number = 15;
[Bindable(event="maxFontSizeChanged")]
// Define public getter method.
public function get maxFontSize():Number {
return _maxFontSize;
}
// Define public setter method.
public function set maxFontSize(value:Number):void {
if (value <= 30) {
_maxFontSize = value;
} else _maxFontSize = 30;
// Create event object.
var eventObj:Event = new Event("maxFontSizeChanged");
dispatchEvent(eventObj);
}
在这个例子中，setter 更新了属性的值，然后创建并发出了一个事件来激发对数据绑定目的
属性的更新。
在MXML 文件中，通过在<mx:Metadata>块中引入[Bindable]元数据标记，就可以将所有以变量
形式定义的public 属性成为数据绑定的源，例子如下：
<mx:Metadata>
[Bindable]
</mx:Metadata>
在<mx:Script>块中也可以在使用[Bindable]元数据标记使单个的变量形式定义的属性成
为数据绑定表达式的源。另外，也可以对setter 及getter 方法定义的属性使用[Bindable]元
数据标记，使之成为数据绑定表达式的源。
将只读属性作为数据绑定的源
使用getter 方法而没有setter 就可以自动定义一个只读属性作为数据绑定表达式的源。
Flex 只在应用启动时执行一次数据绑定。因为来自于只读属性的数据绑定只在应用启动时发生
一次，所以可以对只读属性省略[Bindable]元数据标记。
用静态属性作为数据绑定源
可以将静态属性作为数据绑定表达式的源，Flex 在应用启动时执行一次数据绑定，然后在
静态属性发生变化的时候再执行数据绑定。
可以将静态常量自动作为数据绑定表达式的源，Flex 只在应用启动时执行一次数据绑定。因
为数据绑定只在应用启东时发生一次，所以可以对静态常量省略[Bindable]元数据标记。下面
例子使用静态常量作为数据绑定表达式的源。
<?xml version="1.0"?>
<!-- binding/StaticBinding.mxml -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml ">
<mx:Script>
<![CDATA[
// This syntax casues a compiler error.
// [Bindable]
// public static var varString:String="A static var.";
public static const constString:String="A static const.";
]]>
</mx:Script>
<!-- This binding occurs once at application startup. -->
<mx:Button label="{constString}"/>
</mx:Application>
使用可绑定属性链进行工作
当指定一个属性作为数据绑定表达式的源时，Flex 不仅监控这个属性的变化，也会监控这
个由这个属性作为开始点的属性链的变化。整个属性链，包括源属性，被称为“可绑定的属性
链”。在下面的例子中，firstName.text 是一个可绑定的属性链：
<mx:Text id="myText" text="{firstName.text}"/>
开发者可以使用很长的属性链，如下例所示：
<mx:Text id="myText" text="{user.name.firstName.text}"/>
只有当text 属性是可绑定的，数据绑定机制才能检查text 属性的变化。但是，如果在运
行时，想要向属性链中的部分属性赋予新值，那么属性链中的每个属性都必须是可绑定的，才
能使数据绑定机制起作用。否则，在运行时更改user，name 或者firstName 属性会导致数据绑
定机制无法检查text 属性的变化。
在使用BindingUtils.bindProperty()或者BindingUtils.bindSetter()方法时，可以将可
绑定的属性链作为方法的参数，例如，bindProperty()方法有以下的声明：
public static function bindProperty(site:Object, prop:String, host:Object,
chain:Object, commitOnly:Boolean = false):ChangeWatcher
Host 和chain 属性指定了数据绑定表达式的源。使用bindProperty()方法可以定义一个
数据绑定表达式,如下：
bindProperty(myText, 'text', user, ["name","firstName","text"]);
这个例子中，["name","firstName","text"]定义了相对于user 对象的可绑定属性链。注
意，在本例中，user 不是可绑定属性链的一部分。
在MXML 数据绑定表达式中，可绑定属性连总是相对于this。因此，要想定义一个同上面的
MXML 等价的数据绑定表达式，应按如下例子使用bindProperty()方法：
bindProperty(myText, 'text', this, ["user", "name","firstName","text"]);

http://blog.sina.com.cn/s/blog_5c4558600100d33j.html~type=v5_one&label=rela_prevarticle