Flex 框架PureMVC 源码解析之--View篇

/*
 PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
 Your reuse is governed by the Creative Commons Attribution 3.0 United States License
*/
package org.puremvc.as3.core
{

    import org.puremvc.as3.interfaces.*;
    import org.puremvc.as3.patterns.observer.Observer;

    // 中介名称-中介 列表
    protected var mediatorMap : Array;

    // 消息名称-观察者列表
    protected var observerMap   : Array;

    // 单例的view
    protected static var instance   : IView;

    // 出错消息
    protected const SINGLETON_MSG   : String = "View Singleton already constructed!";


    public class View implements IView
    {

        /**
         *  构造函数，并构造相应的map
         *
         *
         * @throws Error
         *
         */
        public function View( )
        {
            if (instance != null) throw Error(SINGLETON_MSG);
            instance = this;
            mediatorMap = new Array();
            observerMap = new Array();
            initializeView();
        }

        /**
         * 初始化view，由构造函数自动调用，
         * 在子类中可以通过此函数初始化view而不用覆盖构造函数
         *
         * @return void
         */
        protected function initializeView(  ) : void
        {
        }

        /**
         *  单例view的工厂方法
         *
         * @return 返回单例view
         */
        public static function getInstance() : IView
        {
            if ( instance == null ) instance = new View( );
            return instance;
        }

        /**
         *  作用：注册观察者
         *         //对一个消息可能存在多个观察者
         * @param notificationName 消息名称
         * @param observer 要注册的观察者
         */
        public function registerObserver ( notificationName:String, observer:IObserver ) : void
        {

            //得到该消息对应的所有观察者，如果不为空，就把这个观察者加进去，如若为空就初始化
            var observers:Array = observerMap[ notificationName ];
            if( observers ) {
                observers.push( observer );
            } else {
                observerMap[ notificationName ] = [ observer ];
            }
        }

        /**
         *
         * 作用：通知所有的观察者了
         *
         *
         * @param notification 要通知观察者的消息
         */
        public function notifyObservers( notification:INotification ) : void
        {
            if( observerMap[ notification.getName() ] != null ) {

                //获取该消息的所有对应观察者
                var observers_ref:Array = observerMap[ notification.getName() ] as Array;

                //这有点迷糊完全可以这样写,原因是因为在循环的时候observers可能发生变化
                /**
                 *
                 *      for(var i:Number = 0;i<observers_ref.length;i++)
                 *      {
                 *          observer = observers_ref[i] as IObserver;
                 *          observer.notifyObserver(notification);
                 *      }
                 *
                 *
                 * */

                var observers:Array = new Array();
                var observer:IObserver;
                for (var i:Number = 0; i < observers_ref.length; i++) {
                    observer = observers_ref[ i ] as IObserver;
                    observers.push( observer );
                }

                // Notify Observers from the working array
                for (i = 0; i < observers.length; i++) {
                    observer = observers[ i ] as IObserver;
                    observer.notifyObserver( notification );
                }
            }
        }

        /**
         *  作用：根据给定的消息名和对消息感兴趣的对象移除观察者
         *        //上面提到一个消息名称可能对于多个观察者，所以必须使用第二个参数进一步确定
         * @param notificationName  消息名称
         * @param notifyContext 对消息感兴趣的对象
         */
        public function removeObserver( notificationName:String, notifyContext:Object ):void
        {
            // the observer list for the notification under inspection
            var observers:Array = observerMap[ notificationName ] as Array;

            // find the observer for the notifyContext
            for ( var i:int=0; i<observers.length; i++ )
            {
                if ( Observer(observers[i]).compareNotifyContext( notifyContext ) == true ) {

                    observers.splice(i,1);
                    break;
                }
            }

            if ( observers.length == 0 ) {
                delete observerMap[ notificationName ];
            }
        }

        /**
         *  作用：注册中介
         * @param mediator 要注册的中介实例
         */
        public function registerMediator( mediator:IMediator ) : void
        {
            //保证以中介名称为key的对象在mediatorMap中唯一
            if ( mediatorMap[ mediator.getMediatorName() ] != null ) return;

            // 根据名称注册该Mediator
            mediatorMap[ mediator.getMediatorName() ] = mediator;

            // 得到所以该Mediator感兴趣的消息
            var interests:Array = mediator.listNotificationInterests();

            // 其实说白了是把Mediator感兴趣的消息都注册成观察者，以便得到通知
            if ( interests.length > 0 )
            {
                var observer:Observer = new Observer( mediator.handleNotification, mediator );

                for ( var i:Number=0;  i<interests.length; i++ ) {
                    registerObserver( interests[i],  observer );
                }
            }

            mediator.onRegister();

        }

        /**
         *  作用：根据中介名称获取中介
         *
         * @param mediatorName 要获取中介名称
         * @return
         */
        public function retrieveMediator( mediatorName:String ) : IMediator
        {
            return mediatorMap[ mediatorName ];
        }

        /**
         *  作用：从view中移除中介
         *
         * @param mediatorName 要移除的中介名称
         * @return
         */
        public function removeMediator( mediatorName:String ) : IMediator
        {
            // 先拿到该中介
            var mediator:IMediator = mediatorMap[ mediatorName ] as IMediator;

            if ( mediator )
            {
                // 根据感兴趣的消息移除观察者
                var interests:Array = mediator.listNotificationInterests();
                for ( var i:Number=0; i<interests.length; i++ )
                {

                    removeObserver( interests[i], mediator );
                }

                // 移除中介
                delete mediatorMap[ mediatorName ];

                // alert the mediator that it has been removed
                mediator.onRemove();
            }

            return mediator;
        }

        /**
         *  作用：根据名称判断是否存在该中介
         *
         * @param mediatorName 中介名称
         * @return
         */
        public function hasMediator( mediatorName:String ) : Boolean
        {
            return mediatorMap[ mediatorName ] != null;
        }


    }
}