Flex对象与组件的数据 双向绑定

用于Flex中Entity对象与Display对象之间的数据双向动态绑定，支持TextInput、DateField、ComboBox。

  1 package controller.utils{
  2     import com.ericfeminella.collections.HashMap;
  3     import com.ericfeminella.collections.IMap;
  4     
  5     import flash.display.DisplayObject;
  6     import flash.utils.describeType;
  7     
  8     import mx.binding.utils.BindingUtils;
  9     import mx.binding.utils.ChangeWatcher;
 10     import mx.events.PropertyChangeEvent;
 11     import mx.utils.ObjectProxy;
 12     
 13     /**
 14      * @Description: BindingHelper
 15      * @author Lyon
 16      */
 17     public class BindingHelper{
 18         /**
 19          *  目前支持的绑定组件类型 
 20          */        
 21         private static const typeMap: Object = {    'mx.controls::TextInput' : 'text',
 22                                                                         'mx.controls::DateField' : 'selectedDate',
 23                                                                         'mx.controls::ComboBox': 'selectedItem'
 24                                                                         };        
 25         /**
 26          *  存储监控对象的句柄
 27          * key: entityObj
 28          * value: ChangeWatcher
 29          */        
 30         private static var handleList:IMap = new HashMap();
 31         
 32         /**  
 33          *  对象与组件的数据动态双向绑定  
 34          * @param entityObj   Entity Object
 35          * @param displayObj  MX控件
 36          * @param type                 控件类型，如：'mx.controls::TextInput'
 37          * @exclude                     需要排除的property
 38          * @bidirectional               是否做双向绑定（如果为false，那么只做entity到displayObject的绑定）
 39          * @param commitOnly
 40          */    
 41         public static function bidirectionalDataBind(
 42                                     entityObj:Object, 
 43                                     displayObj:DisplayObject,
 44                                     exclude:Array=null,
 45                                     bidirectional:Boolean=true,
 46                                     type:String='ALL',                                    
 47                                     commitOnly:Boolean = false):void{
 48             if(type == 'ALL'){
 49                 for (var typeTmp:String in typeMap){
 50                     bidirectionalDataBind(entityObj,displayObj,exclude,bidirectional,typeTmp,commitOnly);
 51                 }
 52             }else{
 53                 //通过反射机制取出当前MXML中的信息
 54                 var instanceInfo:XML=flash.utils.describeType(displayObj);
 55                 var properties:XMLList =instanceInfo..accessor.(@type==type);
 56                 var tmpObj:ObjectProxy;
 57     //            trace(instanceInfo..accessor.(@type==type));
 58     
 59                 var prop:String = BindingHelper.getSiteProp(type);
 60     
 61                 for each(var propertyInfo:XML in properties){
 62                     //此处取出的为textinput的id
 63                       var proName:String = propertyInfo.@name;
 64                       
 65                       // 需要排除的property
 66                       if(exclude != null && exclude.indexOf(proName) != -1){
 67                           continue;
 68                       }
 69                       
 70                       // 检查该property是否存在
 71                       if(BeanUtils.checkPropertyExist(entityObj,proName) == false){
 72                           continue;
 73                       }
 74                       
 75                       try{
 76                           // ComboBox
 77                           if(type == 'mx.controls::ComboBox'){
 78                               if(handleList.getValue(entityObj) == null){
 79                                   handleList.put(entityObj,new HandleObject(entityObj));
 80                               }
 81                               
 82                             var cw:ChangeWatcher = ChangeWatcher.watch(entityObj,proName,setData);
 83                             HandleObject(handleList.getValue(entityObj)).addChangeWatcher(proName,cw);
 84                             
 85                             BindingUtils.bindProperty(entityObj,proName,DisplayObject(displayObj[proName]),prop,commitOnly);
 86                           }else{
 87                               BindingUtils.bindProperty(DisplayObject(displayObj[proName]),prop,entityObj,proName,commitOnly);
 88                             if(bidirectional == true)
 89                                 BindingUtils.bindProperty(entityObj,proName,DisplayObject(displayObj[proName]),prop,commitOnly);
 90                           }
 91                      }catch(err:Error){
 92                           trace(err.message);
 93                       }
 94                 }
 95             }
 96         }
 97         
 98         /** 
 99          *  清空监控对象的句柄集合
          */        
         public static function clean():void{
             if(handleList != null){
                 for each(var ho:Object in handleList.getValues()){
                     HandleObject(ho).clean();
                 }
                 
                 handleList.clear();
             }
         }
         
         /**
          *  监听ComboBox事件的变化
          * @param obj
          */
         private static function setData(obj:PropertyChangeEvent):void{
             if(obj.newValue == null){
                 return;
             }
             var ho:HandleObject = handleList.getValue(obj.source);            
             var cw:ChangeWatcher = ho.getChangeWatcher(obj.property);
             
             if(obj.newValue is String){
                 cw.unwatch();
                 cw = ChangeWatcher.watch(obj.source,obj.property,setData);
                 ho.addChangeWatcher(obj.property,cw);
                 return;
             }else{    
                 var code:Object = obj.newValue.code;
                 obj.source[obj.property] = code;
             }
         }
         
         /**
          *  返回组件TYPE对应的需要填充的属性名称 
          * @param type
          * @return 
          */        
         private static function getSiteProp(type: String): String{
             for (var name:String in typeMap){
                 if(name == type){
                     return typeMap[name];
                 }
             }
             return null;
         }
     }
 }
 
 import mx.binding.utils.ChangeWatcher;
 import com.ericfeminella.collections.IMap;
 import com.ericfeminella.collections.HashMap;
 internal class HandleObject{
         private var entityObject:*;
         private var properityList:IMap;
         
         public function HandleObject(entityObject:*):void{
             this.entityObject = entityObject;
             properityList = new HashMap();
         }
         
         public function addChangeWatcher(propName:Object, cw:ChangeWatcher):void{
             properityList.put(propName,cw);
         }
         
         public function getChangeWatcher(propName:Object):ChangeWatcher{
             return properityList.getValue(propName);
         }
         
         public function clean():void{
             for each(var cw:Object in properityList.getValues()){
                 ChangeWatcher(cw).unwatch();
             }
             
             properityList.clear();
         }
     }
 

 

 1 package controller.utils{
 2     
 3     import com.adobe.serialization.json.JSON;
 4     
 5     import mx.collections.ArrayCollection;
 6     import mx.utils.ObjectUtil;
 7     import mx.utils.StringUtil;
 8 
 9     /**
      * @Description: Object Utils
      * @author Lyon
      */
     public class BeanUtils{        
         /**
          *  检查对象的property是否存在
          * @param obj
          * @param proName
          * @return 
          */        
         public static function checkPropertyExist(targetObj:*, proName:String):Boolean{
             if(targetObj as String 
                     || targetObj as int
                     || targetObj as Date
                     || targetObj as Number){
                 return false;
             }
             
             var objInfo:Object = ObjectUtil.getClassInfo(targetObj);
             for each(var name:String in objInfo.properties){
                 if(name == proName){
                     return true;
                 }
             }
             
             return false;
         }