大熊君说说JS与设计模式之------中介者模式Mediator

一,总体概要

1,笔者浅谈

我们从日常的生活中打个简单的比方,我们去房屋中介租房,房屋中介人在租房者和房东出租者之间形成一条中介。租房者并不关心他租谁的房。房东出租者也不关心他租给谁。因为有中介的存在,这场交易才变得如此方便。

在软件的开发过程中,势必会碰到这样一种情况,多个类或多个子系统相互交互,而且交互很繁琐,导致每个类都必须知道他需要交互的类,这样它们的耦合会显得异常厉害。牵一发而动全身,后果很严重,大熊很生气!~~~~(>_<)~~~~ 

好了,既然问题提出来了,那有请我们这期的主角------中介者模式出场吧

中介者的功能就是封装对象之间的交互。如果一个对象的操作会引起其他相关对象的变化,而这个对象又不希望自己来处理这些关系,那么就可以去找中介者,让它来处理这些麻烦的关系。看下面的小例子:

 1 var Participant = function(name) {
 2     this.name = name;
 3     this.chatroom = null;
 4 };
 5 Participant.prototype = {
 6     send: function(message, to) {
 7         this.chatroom.send(message, this, to);
 8     },
 9     receive: function(message, from) {
10         log.add(from.name + " to " + this.name + ": " + message);
11     }
12 };
13 var Chatroom = function() {
14     var participants = {};
15
16     return {
17
18         register: function(participant) {
19             participants[participant.name] = participant;
20             participant.chatroom = this;
21         },
22
23         send: function(message, from, to) {
24             if (to) {
25                 to.receive(message, from);
26             } else {
27                 for (key in participants) {
28                     if (participants[key] !== from) {
29                         participants[key].receive(message, from);
30                     }
31                 }
32             }
33         }
34     };
35 };
36 var log = (function() {
37     var log = "";
38
39     return {
40         add: function(msg) { log += msg + "\n"; },
41         show: function() { alert(log); log = ""; }
42     }
43 })();
44
45 function run() {
46     var yoko = new Participant("Yoko");
47     var john = new Participant("John");
48     var paul = new Participant("Paul");
49     var ringo = new Participant("Ringo");
50     var chatroom = new Chatroom();
51     chatroom.register(yoko);
52     chatroom.register(john);
53     chatroom.register(paul);
54     chatroom.register(ringo);
55     yoko.send("All you need is love.");
56     yoko.send("I love you John.");
57     john.send("Hey, no need to broadcast", yoko);
58     paul.send("Ha, I heard that!");
59     ringo.send("Paul, what do you think?", paul);
60     log.show();
61 }

在示例代码中我们有四个参与者,加入聊天会话通过注册一个聊天室(中介)。每个参与者的参与对象的代表。参与者相互发送消息和聊天室的处理路由。

这里的聊天室对象就起到了中介的作用,协调其他的对象,进行合理的组织,降低耦合。

二,源码案例参考

我们应该很熟悉MVC三层模型实体模型(Model)、视图表现层(View)还有控制层(Control/Mediator)。

控制层便是位于表现层与模型层之间的中介者。笼统地说MVC也算是中介者模式在框架设计中的一个应用。

三,案例引入

 1 function Player(name) {
 2     this.points = 0;
 3     this.name = name;
 4 }
 5 Player.prototype.play = function () {
 6     this.points += 1;
 7     mediator.played();
 8 };
 9 var scoreboard = {
10     element:document.getElementById(‘results‘),
11     update:function (score) {
12         var i, msg = ‘‘;
13         for (i in score) {
14             if (score.hasOwnProperty(i)) {
15                 msg += ‘<p><strong>‘ + i + ‘<\/strong>: ‘;
16                 msg += score[i];
17                 msg += ‘<\/p>‘;
18             }
19         }
20         this.element.innerHTML = msg;
21     }
22 };
23 var mediator = {
24     players:{},
25     setup:function () {
26         var players = this.players;
27         players.home = new Player(‘Home‘);
28         players.guest = new Player(‘Guest‘);
29     },
30     played:function () {
31         var players = this.players,
32                 score = {
33                     Home:players.home.points,
34                     Guest:players.guest.points
35                 };
36         scoreboard.update(score);
37     },
38     keypress:function (e) {
39         e = e || window.event;
40         if (e.which === 49) {
41             mediator.players.home.play();
42             return;
43         }
44         if (e.which === 48) {
45             mediator.players.guest.play();
46             return;
47         }
48     }
49 };
50 mediator.setup();
51 window.onkeypress = mediator.keypress;
52 setTimeout(function () {
53     window.onkeypress = null;
54     console.log(‘Game over!‘);
55 }, 30000);

四,总结一下

Why Mediator ?

各个对象之间的交互操作非常多,每个对象的行为操作都依赖彼此对方,修改一个对象的行为,同时会涉及到修改很多其他对象的行为,

如果使用Mediator模式,可以使各个对象间的耦合松散,只需关心和 Mediator的关系,使多对多的关系变成了一对多的关系,

可以降低系统的复杂性,提高可修改扩展性。

使用中介者模式的场合

1.一组定义良好的对象,现在要进行复杂的通信。

2.定制一个分布在多个类中的行为,而又不想生成太多的子类。

可以看出,中介对象主要是用来封装行为的,行为的参与者就是那些对象,但是通过中介者,这些对象不用相互知道。(迪米特法则的具体实现)

使用中介者模式的优点:

1.降低了系统对象之间的耦合性,使得对象易于独立的被复用。

2.提高系统的灵活性,使得系统易于扩展和维护。

使用中介者模式的缺点:

中介者模式的缺点是显而易见的,因为这个“中介“承担了较多的责任,所以一旦这个中介对象出现了问题,那么整个系统就会受到重大的影响。

                          哈哈哈,本篇结束,未完待续,希望和大家多多交流够沟通,共同进步。。。。。。呼呼呼……(*^__^*)            

时间: 2024-10-07 06:37:42

大熊君说说JS与设计模式之------中介者模式Mediator的相关文章

大熊君说说JS与设计模式之(门面模式Facade)迪米特法则的救赎篇------(监狱的故事)

一,总体概要 1,笔者浅谈 说起“门面”这个设计模式其实不论新老程序猿都是在无意中就已经运用到此模式了,就像我们美丽的JS程序员一样不经意就使用了闭包处理问题, 1 function Employee(name) { 2 var name = name; 3 this.say = function () { 4 console.log("I am employee " + name) ; 5 } ; 6 } 代码中“say”是一个function,Employee也是一个functio

设计模式之中介者模式(Mediator)摘录

23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化委托给另一个对象.创建型模式有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些具体的类的信息封装起来.第二,它们隐藏了这些类的实例是如何被创建和放在一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,以

大熊君说说JS与设计模式之------代理模式Proxy

一,总体概要 1,笔者浅谈 当我们浏览网页时,网页中的图片有时不会立即展示出来,这就是通过虚拟代理来替代了真实的图片,而代理存储了真实图片的路径和尺寸,这就是代理方式的一种. 代理模式是比较有用途的一种模式,而且变种较多(虚代理.远程代理.copy-on-write代理.保护代理.Cache代理.防火墙代理.同步代理.智能指引),应用场合覆盖从小结构到整个系统的大结构, 我们也许有代理服务器等概念,代理概念可以解释为:在出发点到目的地之间有一道中间层,意为代理. 代理对象角色内部含有对真实对象的

二十三种设计模式[17] - 中介者模式(Mediator Pattern)

前言 在开发软件的过程中,我们通常会将类设计的比较单纯,使其复用性更高.但类间的相互引用又使得类本身在没有其他类的支持下不能正常工作,导致其复用性降低.所以为了提高类的复用性我们需要尽可能的减少对其它类的引用,也就是说我们常说的解耦.中介者模式,顾名思义,就是存在一个类似中介的角色,类与类之间不直接交互而是通过中介进行间接的交互,也就意味着类与类之间不需要存在显示的引用,以达到松耦合的目的. 中介者模式,对象行为型模式的一种.在<设计模式 - 可复用的面向对象软件>一书中将之描述为"

设计模式 笔记 中介者模式 Mediator

//---------------------------15/04/27---------------------------- //Mediator 中介者模式----对象行为型模式 /* 1:意图: 用一个中介对象来封装一系列的对象交互.中介者使各对象不需要显式地相互引用,从而使其耦合松散, 而且可以独立地改变它们之间的交互. 2:动机: 3:适用性: 1>一组对象以定义良好但是复杂的方式进行通信.产生的相互依赖关系结构混乱且难以理解. 2>一个对象引用其他很多对象并且直接与这些对象通信

大熊君说说JS与设计模式之------单例模式Singleton()

一,总体概要 1,笔者浅谈 顾名思义单例模式并不难理解,是产生一个类的唯一实例,在我们实际开发中也会使用到这种模式,它属于创建模式的一种,基于JS语言本身的语法特征, 对象直接量“{}”,也可以作为单例模式的一种表现形式,如下代码参考 1 function Foo(){ 2 this.bar = "Hello Singleton !" ; 3 } ; 4 var Singleton = { 5 instance : null , 6 getInstance : function(){

大熊君说说JS与设计模式之------命令模式Command

一,总体概要 1,笔者浅谈 日常生活中,我们在看电视的时候,通过遥控器选择我们喜欢的频道时,此时我们就是客户端的角色,遥控器的按钮相当于客户请求,而具体执行的对象就是命令对象, 命令模式把一个请求或者操作封装到一个对象中.命令模式允许系统使用不同的请求把客户端参数化,对请求排队或者记录请求日志,可以提供命令的撤销和恢复功能. 先给个具体事例,如下: 1 function add(x, y) { return x + y; } ; 2 function sub(x, y) { return x -

大熊君说说JS与设计模式之------策略模式Strategy

一,总体概要 1,笔者浅谈 策略模式,又叫算法簇模式,就是定义了不同的算法,并且之间可以互相替换,此模式让算法的变化独立于使用算法的客户. 策略模式和工厂模式有一定的类似,策略模式相对简单容易理解,并且可以在运行时刻自由切换.工厂模式重点是用来创建对象. 策略模式应用比较广泛,比如:我们现在要定义数据交换格式,现有三种方案可选1,XML  2,JSON  3,CSV就可以使用策略模式实现. 这里我要强调的是------我们是针对不同数据源选择不同方案,针对的都是同一事物做相同意图的操作只是方案不

【设计模式】—— 中介者模式Mediator

前言:[模式总览]——————————by xingoo 模式意图 使用一个中介的对象,封装一组对象之间的交互,这样这些对象就可以不用彼此耦合. 这个中介者常常起着中间桥梁的作用,使其他的对象可以利用中介者完成某些行为活动,因此它必须对所有的参与活动的对象了如指掌! 应用场景 1 当一组对象要进行沟通或者业务上的交互,但是其关系却又很复杂混乱时,可以采用此模式. 2 当一个对象与其他的对象要进行紧密的交互,但又想服用该对象而不依赖其他的对象时. 3 想创造一个运行于多个类之间的对象,又不想生成新