PureMVC - Pipes Util 实现 Module 之间消息通信

PureMVC MutilCore 版本。所谓多核，是指程序中有多个 PureMVC 实例；在 Flex 中以 Module 方式实现，其中每个 Module 都有其Facade，独立的功能。但 PureMVC 未提供 Module 之间通信的方法，虽然可以通过 Interface 等方法来管理每个 Module，但这样程序间耦合性太高，无法体现MVC优点；好在有官方的解决方法，推荐使用 Pipes Util 解决 Module 之间的通信，Pipes Util 在 Module 之间构建了一层通信框架，使每个 Module 通过普通 Notification 的方式进行消息通信。
下面举例说明：主程序 Shell 与 Module 相互通信，两者都是独立的 PureMVC 框架。
Pipe Util 主要通过 JunctionMediator 与其他 Module 通信；由于 JunctionMediator 继承自 Mediator，可转发Notification 通知消息，所以就使 Module 之间的消息通信可利用 PureMVC 本身的架构。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
package cn.xinsync.kmeeting.shell.view
{
        import cn.xinsync.kmeeting.common.PipeAwareModule;
        import cn.xinsync.kmeeting.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 可转发 Notification 通知消息。
         */
        public class ShellJunctionMediator extends JunctionMediator
        {
                public static const NAME:String = "AppJunctionMediator";
 
                public function ShellJunctionMediator()
                {
                        // Junction 是不可视的连结对象，只用于管理 Shell 主程序与 Module 之间通信联络
                        // 实际就是两者之间的逻辑关系: 如响应、监听 Notification 消息, 如何转发等
                        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())
                        { // 每个 Module 都必须进行 Pipe(管道)连结管理
                                case ApplicationFacade.MODULE_ADDED:
                                {       // 有新 Module 增加
                                        var module:IPipeAware = IPipeAware(note.getBody());
                                        connectPipe(module); // 每个 Module 都连结到管道
                                        break;
                                }
                                case ApplicationFacade.SEND_MESSAGE:
                                {       // 发送消息, 通过 junction 连结器裁决消息通过管道发送到指定的模块中。
                                        var message:Message = new Message(PipeAwareModule.SHELL_MESSAGE, null, note.getBody());
                                        junction.sendMessage(PipeAwareModule.SHELL_TO_MODULE, message);
 
                                        break;
                                }
                        }
                }
 
                /**
                 * 连结管道(Pipe)和接口(Interface)
                 */
                private function connectPipe(module:IPipeAware):void
                {
                        // 注册管道(Pipe)和管道接口(三通连结 TeeSplit(消息分离)/TeeMerge(消息聚合))
                        junction.registerPipe(PipeAwareModule.SHELL_TO_MODULE, Junction.OUTPUT, new TeeSplit());
                        junction.registerPipe(PipeAwareModule.MODULE_TO_SHELL, Junction.INPUT, new TeeMerge());
 
                        // 监听消息 - 处理 Module 发送的 Notification 消息
                        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())
                        { // 响应、监听处理 Module 通过管道发送的 Notification 通知消息
                                case PipeAwareModule.MODULE_MESSAGE:
                                {       // 使用 PureMVC 框架转发
                                        sendNotification(ApplicationFacade.GET_MESSAGE, message.getBody());
                                        break;
                                }
                        }
                }
 
        }
}

连接(Junction)通过管道(Pipe)监听消息，通常写起来比较的麻烦，但可有效限制 Module 之间通信以及监听的消息。
注：本程序模仿自 Water and Bread 的演示程序.
本文来源于 冰山上的播客 http://xinsync.xju.edu.cn , 原文地址：http://xinsync.xju.edu.cn/index.php/archives/4881