Flex 双向绑定 工具类

最近做Flex项目，碰到了双向绑定的问题，

查了下网上，有解决方法

 

简单说就是 2个单项绑定 + 简易的同步机制

 

看代码：

Java代码

1. /**实现双向绑定工具类*/  
2.     public class BindingUtil{   
3.            
4.            
5.         /**绑定方法*/  
6.         public static function bind(obj1:Object,prop1:String,obj2:Object,prop2:String):void{   
7.                
8.             /**是否在改变标志，类似 数据同步机制*/  
9.             var flag:Boolean = false;   
10.                
11.             ChangeWatcher.watch(obj1,prop1,function(event:Event):void{   
12.                 if(!flag){   
13.                     /**锁定对象*/  
14.                     flag = true;   
15.                     obj2[prop2] = obj1[prop1];   
16.                     /**解锁对象*/  
17.                     flag = false;   
18.                 }   
19.             });   
20.                
21.             ChangeWatcher.watch(obj2,prop2,function(event:Event):void{   
22.                 if(!flag){   
23.                     /**锁定对象*/  
24.                     flag = true;   
25.                     obj1[prop1] = obj2[prop2];   
26.                     /**解锁对象*/  
27.                     flag = false;   
28.                 }   
29.             });   
30.         }   
31.     }  

/**实现双向绑定工具类*/
	public class BindingUtil{
		
		
		/**绑定方法*/
		public static function bind(obj1:Object,prop1:String,obj2:Object,prop2:String):void{
			
			/**是否在改变标志，类似 数据同步机制*/
			var flag:Boolean = false;
			
			ChangeWatcher.watch(obj1,prop1,function(event:Event):void{
				if(!flag){
					/**锁定对象*/
					flag = true;
					obj2[prop2] = obj1[prop1];
					/**解锁对象*/
					flag = false;
				}
			});
			
			ChangeWatcher.watch(obj2,prop2,function(event:Event):void{
				if(!flag){
					/**锁定对象*/
					flag = true;
					obj1[prop1] = obj2[prop2];
					/**解锁对象*/
					flag = false;
				}
			});
		}
	}

 

可以看到

 

使用了ChangeWatcher注册了一个函数，并且使用了闭包的特性

使得 var flag:Boolean 变量可以 在匿名函数中使用

 

其实 flag的作用就是 类似 java的synchronized

 

放置时间争抢改变属性的作用

 

 

但是如果像这样写，那么不是很理想

 

我改了一下：

Java代码

1. /**实现双向绑定工具类*/  
2.     public class BindingUtil{   
3.            
4.         public var watchers:ArrayCollection = new ArrayCollection();   
5.            
6.         /**绑定方法*/  
7.         public function bind(   
8.             obj1:Object,prop1:String,   
9.             obj2:Object,prop2:String):void{   
10.                
11.             /**是否在改变标志，类似 数据同步机制*/  
12.             var flag:Boolean = false;   
13.                
14.             var tempwatcher1:ChangeWatcher = ChangeWatcher.watch(obj1,prop1,function(event:Event):void{   
15.                 if(!flag){   
16.                     /**锁定对象*/  
17.                     flag = true;   
18.                     obj2[prop2] = obj1[prop1];   
19.                     /**解锁对象*/  
20.                     flag = false;   
21.                 }   
22.             });   
23.                
24.             var tempwatcher2:ChangeWatcher = ChangeWatcher.watch(obj2,prop2,function(event:Event):void{   
25.                 if(!flag){   
26.                     /**锁定对象*/  
27.                     flag = true;   
28.                     obj1[prop1] = obj2[prop2];   
29.                     /**解锁对象*/  
30.                     flag = false;   
31.                 }   
32.             });   
33.                
34.             this.watchers.addItem(tempwatcher1);   
35.             this.watchers.addItem(tempwatcher2);   
36.         }   
37.            
38.         /**解除绑定*/  
39.         public function unbind():void{   
40.             for(var i:int = 0; i<this.watchers.length; i++){   
41.                 ChangeWatcher(this.watchers.getItemAt(i)).unwatch();   
42.             }   
43.         }   
44.     }  

/**实现双向绑定工具类*/
	public class BindingUtil{
		
		public var watchers:ArrayCollection = new ArrayCollection();
		
		/**绑定方法*/
		public function bind(
			obj1:Object,prop1:String,
			obj2:Object,prop2:String):void{
			
			/**是否在改变标志，类似 数据同步机制*/
			var flag:Boolean = false;
			
			var tempwatcher1:ChangeWatcher = ChangeWatcher.watch(obj1,prop1,function(event:Event):void{
				if(!flag){
					/**锁定对象*/
					flag = true;
					obj2[prop2] = obj1[prop1];
					/**解锁对象*/
					flag = false;
				}
			});
			
			var tempwatcher2:ChangeWatcher = ChangeWatcher.watch(obj2,prop2,function(event:Event):void{
				if(!flag){
					/**锁定对象*/
					flag = true;
					obj1[prop1] = obj2[prop2];
					/**解锁对象*/
					flag = false;
				}
			});
			
			this.watchers.addItem(tempwatcher1);
			this.watchers.addItem(tempwatcher2);
		}
		
		/**解除绑定*/
		public function unbind():void{
			for(var i:int = 0; i<this.watchers.length; i++){
				ChangeWatcher(this.watchers.getItemAt(i)).unwatch();
			}
		}
	}

 

 

加入了属性，保存了所有的绑定，

 

也提供了解除绑定的方法

 

这样的好处，不言而喻吧，当你同个视图想绑定不同对象的时候，那么就派上用场了!