Water and Bread: [PureMVC] 使用Pipes Util 實現Module間溝通

之前在Micro Architecture PureMVC一篇有介紹到多核版的PureMVC架構，所謂的多核，指的是同一專案能出現多個實做PureMVC的模塊，在Flex是以Module的方式實現，讓每個Module都有各自的Facade，功能獨立。但PureMVC本身未提供Module間彼此溝通的方法，雖然我們可以用Interface等方法來管理每個Module，但這會使程式的關聯太高，失去MVC的好處，所幸己有高手解決了這個問題，官方網站的Pipes Util就是用來處理Module的問題，他能在Module間再架一層溝通架構，能每個Module都能像送Notification的方式彼此溝通，下面寫個簡單的範例說明

程式為Shell跟Module互傳訊息，Shell是讀入Module的主程式，Module是獨立的PureMVC架構

PipeUtil主要是靠JunctionMediator跟其它Module溝通，由於JunctionMediator是繼承自Mediator，所以可再收發Notification，使Module間的訊息可走回原本的PureMVC架構

package idv.gd.hellopipes.shell.view
{
        import idv.gd.hellopipes.common.PipeAwareModule;
        import idv.gd.hellopipes.shell.ApplicationFacade;
        
        import org.puremvc.as3.multicore.interfaces.INotification;
        import org.puremvc.as3.multicore.utilities.pipes.interfaces.IPipeAware;
        import org.puremvc.as3.multicore.utilities.pipes.interfaces.IPipeMessage;
        import org.puremvc.as3.multicore.utilities.pipes.messages.Message;
        import org.puremvc.as3.multicore.utilities.pipes.plumbing.Junction;
        import org.puremvc.as3.multicore.utilities.pipes.plumbing.JunctionMediator;
        import org.puremvc.as3.multicore.utilities.pipes.plumbing.Pipe;
        import org.puremvc.as3.multicore.utilities.pipes.plumbing.TeeMerge;
        import org.puremvc.as3.multicore.utilities.pipes.plumbing.TeeSplit;
        
        /**
         * junction是實際拿來連結的實體，架構在原本的puremvc內（mediator）
         */
        public class ShellJunctionMediator extends JunctionMediator
        {
                public static const NAME:String = "AppJunctionMediator";
                
                public function ShellJunctionMediator()
                {
                        //Junction為不可見的連結實體，用來管理 shell跟module的關係
                        super(NAME, new Junction());
                }
                
                override public function listNotificationInterests():Array
                {
                        return [ApplicationFacade.MODULE_ADDED, ApplicationFacade.SEND_MESSAGE];
                }
                
                override public function handleNotification(note:INotification):void
                {
                        switch (note.getName())
                        {
                                case ApplicationFacade.MODULE_ADDED:
                                {
                                        var module:IPipeAware = IPipeAware(note.getBody());
                                        connectPipe(module);
                                        break;
                                }
                                case ApplicationFacade.SEND_MESSAGE:
                                {
                                        var message:Message = new Message(PipeAwareModule.SHELL_MESSAGE, null, note.getBody());
                                        junction.sendMessage(PipeAwareModule.SHELL_TO_MODULE, message);
                                        
                                        break;
                                }
                        }
                }
                
                /**
                 * 連結pipe跟接口
                 */
                private function connectPipe(module:IPipeAware):void
                {               
                        //註冊pipe及產生接口
                        junction.registerPipe(PipeAwareModule.SHELL_TO_MODULE, Junction.OUTPUT, new TeeSplit());
                        junction.registerPipe(PipeAwareModule.MODULE_TO_SHELL, Junction.INPUT, new TeeMerge());
                        
                        //監聽訊息
                        junction.addPipeListener(PipeAwareModule.MODULE_TO_SHELL, this, handlePipeMessage);
                        
                        //連結 module跟shell                    
                        var moduleToShell:Pipe = new Pipe();                    
                        module.acceptOutputPipe(PipeAwareModule.MODULE_TO_SHELL, moduleToShell);
                        
                        var shellInFitting:TeeMerge = junction.retrievePipe(PipeAwareModule.MODULE_TO_SHELL) as TeeMerge;
                        shellInFitting.connectInput(moduleToShell);
                        
                        //連結shell跟module
                        var shellToModule:Pipe = new Pipe();
                        module.acceptInputPipe(PipeAwareModule.SHELL_TO_MODULE, shellToModule);
                        
                        var shellOutFitting:TeeSplit = junction.retrievePipe(PipeAwareModule.SHELL_TO_MODULE) as TeeSplit;                      
                        shellOutFitting.connect(shellToModule);
                        trace("connected");
                }
                
                override public function handlePipeMessage(message:IPipeMessage):void
                {
                        switch (message.getType())
                        {
                                case PipeAwareModule.MODULE_MESSAGE:
                                {
                                        sendNotification(ApplicationFacade.GET_MESSAGE, message.getBody());
                                        break;
                                }
                        }
                }
                
        }
}