Java, Flex and JavaFX

import flash.utils.ByteArray;

    import mx.binding.utils.BindingUtils;
    import mx.logging.ILogger;
    import mx.logging.Log;
    import mx.logging.LogEventLevel;
    import mx.logging.targets.TraceTarget;

    /**
     * This class provides the binding capability between
     * 2 models. The binding is read from a XML file and
     * used in the binding process.
     *
     * @author http://nl.linkedin.com/in/marcdekwant
     */
    public class Binder {

        [Embed( source='/assets/bindings.xml', mimeType="application/octet-stream" )]
        private var _rawFile:Class

        // The from file read xml representation of the bindingfile
        private var _bindings:XML;
        // The original domain model
        private var _model:*;
        // The target model (DTO's related to the UI components)
        private var _dto:*;

        private var logger:ILogger  =  Log.getLogger( "Binder" );

        /**
         * Constructor
         *
         * @param dto the target domain model
         * @param model the source domain model
         */
        public function Binder( dto:*, model:* ) {
            this._dto  =  dto;
            this._model  =  model;
            var file:ByteArray  =  new _rawFile();
            var str:String  =  file.readUTFBytes( file.length );
            _bindings  =  new XML( str );
            initLogging();
            createBindings();
        }

        /**
         * Initialize the logging
         * TODO refactor to controller or application level
         */
        private function initLogging():void {
            var logTarget:TraceTarget  =  new TraceTarget();
            logTarget.level  =  LogEventLevel.ALL;
            logTarget.filters  =  [ "*", "nl.dialoog.binding.*" ];
            logTarget.includeCategory  =  true;
            logTarget.includeDate  =  true;
            logTarget.includeLevel  =  true;
            logTarget.includeTime  =  true;
            Log.addTarget( logTarget );
        }

        /**
         * This method retrieves a property from a
         * given object. THis method gives the binding
         * class the capability to chain objects.
         *
         * @param _objTarget The object
         * @param _innerObj the property of the targetObject
         * @return the innerObj from the targetobj
         */
        private function resolveNestedObject( _objTarget:*, _innerObj:String ):* {
            return _objTarget[ _innerObj ];
        }

        /**
         * This method resolves the property from an object chain to
         * be bound to another property from an object chain.
         *
         * @param _obj The baseObject (domain model root, or DTO root)
         * @param _xmlObj the target to be found in the root
         * @return the target object to be bound.
         */
        private function resolveSourceObject( _obj:*, _xmlObj:XML ):* {
            var _objArray:Array  =  _xmlObj.@object.split( "." );
            for ( var i:int  =  0; i < _objArray.length; i++ ) {
                if ( _xmlObj.@topLevelObject != _xmlObj.@object ) {
                    _obj  =  resolveNestedObject( _obj, _objArray[ i ]);
                }
            }
            return _obj;
        }

        /**
         *  Actual method that hold the logic in creating bindings
         *  based upon the binding xml file.
         */
        private function createBindings():void {
            logger.debug( "Start create bindings..." );
            var _objSource:*  =  null;
            var _objTarget:*  =  null;
           
            // Set the default namespace from the binding.xml, in order to process the
            // mapping file. "" relates to the xmlns="" attribute in the root element
            default xml namespace = _bindings.namespace("");
           
            // traverse over all <binding> elements
            for each ( var xmlBinding:XML in _bindings.binding ) {
                logger.debug( "Create binding for " + xmlBinding.@id + " bi-directional:" + xmlBinding.@bidirectional );
                var sourceBinding:XML  =  xmlBinding.sourceBinding[ 0 ];
                _objSource  =  resolveSourceObject( this._model, sourceBinding );
                logger.debug( "Collection binding..." );
                // traverse over all <targetBinding> elements
                for each ( var xmlTargetBinding:XML in xmlBinding.targets.targetBinding ) {
                    logger.debug( "Construction of bindings from " + sourceBinding.@object + "." + sourceBinding.@field + " to " + xmlTargetBinding.@object + "." + xmlTargetBinding.@field );
                    _objTarget  =  resolveSourceObject( this._dto, xmlTargetBinding );
                    // A collection requires a slightly different binding then properties
                    // because the ArrayCollection contains binding mechanism in its own class.
                    if ( sourceBinding.@isCollection == "true" ) {
                        logger.debug( "Collection binding..." );
                        _objTarget[ xmlTargetBinding.@field ][ "source" ]  =  _objSource[ sourceBinding.@field ][ "source" ];
                    } else {
                        logger.debug( "Property binding..." );
                        var _sourceStr:String  =  sourceBinding.@field;
                        var _targetStr:String  =  xmlTargetBinding.@field;
                        BindingUtils.bindProperty( _objSource, _sourceStr, _objTarget, _targetStr );
                        BindingUtils.bindProperty( _objTarget, _targetStr, _objSource, _sourceStr );
                    }
                }
            }
            logger.debug("Bindings created...");
        }

    }
}