模拟EventCenter，flash自带的事件机制的一个解耦框架,callback回调方式用于模块之间的通信

之前写了一个简化版的puremvc,mvc框架，

后来参考一个ARPG项目的架构，目前用于解耦的我所了解的两种方式都罗列下：

1.EventCenter模式：

package com.cw.war.module.guide
{
    
    import flash.events.EventDispatcher;

    /**
     * 用来解耦新手指引和各个模块
     * @author elvisjiang
     * @data 2012-9-25
     */    
    public class GuideEventCenter
    {
        private static var instance:GuideEventCenter;
        public static function getInstance () : GuideEventCenter
        {
            if (instance == null)
            {
                instance = new GuideEventCenter ();
            }
            return instance;
        }
        public static function get I():GuideEventCenter
        {
            if (instance == null)
            {
                instance = new GuideEventCenter ();
            }
            return instance;
        }
        public function GuideEventCenter()
        {
            ed = new EventDispatcher();
            if(instance != null) throw new Error ( "Singleton Error" );
        }
        
        private var ed:EventDispatcher;
        private var  _listener:Array;
        
        
        public function dispatchEvent(type:String,data:Object = null):void
        {
            ed.dispatchEvent(new GuideEvent(type,data));
        }
        public function addEventListener(type:String,fun:Function):void
        {
            if(!_listener)
            {
                _listener = [];
            }
            
            _listener.push({type:type,listener:fun});
            ed.addEventListener(type,fun);
        }
        public function removeEventListener(type:String,fun:Function):void
        {
            ed.removeEventListener(type,fun);
        }
        
        public function destroy():void
        {
            //移除监听
            while(_listener.length > 0)
            {
                var item:Object = _listener.shift();
                removeEventListener(item.type,item.listener);
            }
            _listener.length = 0;
            _listener = null;
            ed = null;
            instance = null;
        }
    }
}

上述的核心就是一个eventDispatcher用于转发，

比方说模块1 : proxy里面可以 这样写：

EventCenter.addEventListener("背包数据回包",_fun1);

服务器背包数据回包之后可以 EventCenter.dispatchEvent();

这有个缺点，整个游戏会监听很多事件，上个项目至少监听了500个，这个ed太任重道远了，

2.下面讲另一种解耦方式，函数回调的方式：

package 
{
    import flash.utils.Dictionary;
    
    import net.libra.core.Notification;
    import net.libra.core.interfaces.IController;
    import net.libra.core.interfaces.INotifier;
    import net.libra.log.Log;
    import net.libra.utils.HashMap;
    import net.libra.utils.StringUtils;

    /**
     * 事件转发器
     * @author elvisjiang
     * @data 2012-6-11
     */
    public class CallPool
    {
        private static var _instance:CallPool;
        
        public static function getInstance () : CallPool
        {
            if (_instance == null)
            {
                _instance = new CallPool (new PrivateClass());
            }
            return _instance;
        }
        public static function get I():CallPool
        {
            if (_instance == null)
            {
                _instance = new CallPool (new PrivateClass());
            }
            return _instance;
        }
        public static function get instance():CallPool
        {
            if (_instance == null)
            {
                _instance = new CallPool (new PrivateClass());
            }
            return _instance;
        }
        
        //---------------------------------------------------------------->
        private var _callbacks:Dictionary;
        
        public function CallPool(prv :PrivateClass)
        {
            _callbacks = new Dictionary(true);
        }
        //---------------------------------------------------------------------->
        /**
         * 注册消息回调 
         * 相当于addEventlistner;
         * @param noticationName 消息Type
         * @param fun 回调函数
         */        
        public function addCallBack(notificationName:String,callback:Function):void
        {
            if(_callbacks[notificationName] == null){
                _callbacks[notificationName] = [];
            }
            var index:int = findAt(notificationName,callback);
            if(index == -1){
                _callbacks[notificationName].push(callback);
            }
        }
        /**
         * 销毁消息回调 
         * @param notificationName
         * @param callback
         * 
         */        
        public function removeCallBack(notificationName:String,callback:Function):void
        {
            var index:int = findAt(notificationName,callback);
            if(index != -1){
                (_callbacks[notificationName] as Array).splice(index,1);
            }
        }
        private function findAt(notificationName:String,callback:Function):int
        {
            var calls:Array = _callbacks[notificationName];
            if(calls == null)
                return -1;
            var index:int = 0;
            for each(var call:Function in calls){
                if(call == callback)
                    return index;
                index++;
            }
            return -1;
        }

        /**
         * 向所有的注册的函数发消息
         */
        public function sendNotification(notificationName:String,body:Object = null):void
        {
            if(_callbacks[notificationName] != null)
            {
                var calls:Array = _callbacks[notificationName];
                if(calls == null || calls.length <= 0)
                    return ;
                var index:int = 0;
                for each(var call:Function in calls){
                    call.apply(null,[new Notification(notificationName,body)]);
                    index++;
                }
            }
        }

    }
}
class PrivateClass{}

模块1入口
package
{
    import net.libra.core.Notification;

    /**
     * 
     * @author elvisjiang
     * @data 2012-11-14
     */    
    public class Module1
    {
        public function Module1()
        {
            CallPool.I.addCallBack("123",_callback1);
            CallPool.I.addCallBack("456",_callback1);
            CallPool.I.removeCallBack("123",_callback1);
        }
        private function _callback1(notification:Notification):void
        {
            switch(notification.getName())
            {
                case "123":
                    trace("Module1收到123");
                    break;
                case "456":
                    trace("Module1收到456");
                    break;
            }
        }
    }
}

模块2入口
package
{
	import net.libra.core.Notification;

	/**
	 * 
	 * @author elvisjiang
	 * @data 2012-11-14
	 */	
	public class Module2
	{
		public function Module2()
		{
			CallPool.I.addCallBack("123",_callback1);
		}
		private function _callback1(notification:Notification):void
		{
			trace("Module2--123接收到",notification.getBody().name);
		}
	}
}

　测试类：

package
{
	import flash.display.Sprite;
	
	import net.libra.core.Notification;

	/**
	 * 
	 * @author elvisjiang
	 * @data 2012-11-14
	 */	
	public class TestCallPool extends Sprite
	{
		public function TestCallPool()
		{
			new Module1();
			//new Module2();
			CallPool.I.sendNotification("123",{name:"xxx123"});
			CallPool.I.sendNotification("456",{name:"xxx456"});
		}
	}
}

　消息体类

package net.libra.core
{
    import flash.events.Event;

    /**
     * 事件通知
     * @author elvisjiang
     */
    public class Notification
    {
        private var name:String;
        private var body : Object;
        private var type : String;

        /**
         * 创建一个通知对象
         * @param name    事件名称
         * @param body    事件携带的数据参数
         * @param type    事件类型
         */
        public function Notification(name : String, body : Object = null,type : String = "")
        {
            this.name = name;
            this.body = body;
            this.type = type;
        }

        /**
         * @inheritDoc
         */
        public function getName() : String
        {
            return this.name;
        }

        /**
         * @inheritDoc
         */
        public function setBody(body : Object) : void
        {
            this.body = body;
        }

        /**
         * @inheritDoc
         */
        public function getBody() : Object
        {
            return this.body;
        }

        /**
         * @inheritDoc
         */
        public function setType(type : String) : void
        {
            this.type = type;
        }

        /**
         * @inheritDoc
         */
        public function getType() : String
        {
            return this.type;
        }
    }
}

这种方式是基于函数回调的，就是一个字符串对应一个函数列表，当callPool.sendNotication的时候，函数列表会挨个执行。

两种方式各有优缺点，有的人说eventdispatcher是最高效率的，但是用内存换效率了，函数回调的方式弱化了a lot of 监听，但如果是高性能要求的可以用eventCenter的方式，有人说监听500到1000个函数根本不在话下，看个人了，如果你觉的太重了，就用下面那个，呵呵。