设计模式之禅之设计模式-中介者模式

简介: 一:中介模式的定义        --->用一个中介对象封装一系列的对象交互,中介者使各对象不需要显示地相互作用,从而使其耦合松散,而且可以独立地改变它们之间的交互。        --->中介模式的组成部分:                ● Mediator 抽象中介者角色:抽象中介者角色定义统一的接口,用于各同事角色之间的通信。

一:中介模式的定义
        --->用一个中介对象封装一系列的对象交互,中介者使各对象不需要显示地相互作用,从而使其耦合松散,而且可以独立地改变它们之间的交互。
        --->中介模式的组成部分:
                ● Mediator 抽象中介者角色:抽象中介者角色定义统一的接口,用于各同事角色之间的通信。
                ● Concrete Mediator 具体中介者角色:具体中介者角色通过协调各同事角色实现协作行为,因此它必须依赖于各个同事角色。
                ● Colleague 同事角色:每一个同事角色都知道中介者角色,而且与其他的同事角色通信的时候,一定要通过中介者角色协作。每个同事类的行为分为两种:一种是同事本身的行为,比如改变对象本身的状态,处理自己的行为等,这种行为叫做自发行为(Self-Method),与其他的同事类或中介者没有任何的依赖;第二种是必须依赖中介者才能完成的行为,叫做依赖方法(Dep-Method)。
        --->迪米特法则认为“每个类只和朋友类交流”,这个朋友类并非越多越好,朋友类越多,耦合性越大,要想修改一个就得修改一片,这不是面向对象设计所期望的,况且这还是仅三个模块的情况,属于比较简单的一个小项目
        --->大家都学过网络的基本知识,网络拓扑有三种类型:总线型、环型、星型。
        --->星型网络拓扑如图14-4所示。
        --->在星型网络拓扑中,每个计算机通过交换机和其他计算机进行数据交换,各个计算机之间并没有直接出现交互的情况。这种结构简单,而且稳定,只要中间那个交换机不瘫痪,整个网络就不会发生大的故障。公司和网吧一般都采用星型网络。我们是不是可以把这种星型结构引入到我们的设计中呢?我们先画一个示意图,如图14-5所示

二:中介模式的应用

        --->中介者模式的优点
                中介者模式的优点就是减少类间的依赖,把原有的一对多的依赖变成了一对一的依赖,同事类只依赖中介者,减少了依赖,当然同时也降低了类间的耦合。
        --->中介者模式的缺点
                中介者模式的缺点就是中介者会膨胀得很大,而且逻辑复杂,原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系,同事类越多,中介者的逻辑就越复杂。
        --->中介者模式应用误区和如何应用
        中介者模式简单,但是简单不代表容易使用,很容易被误用。在面向对象的编程中,对象和对象之间必然会有依赖关系,如果某个类和其他类没有任何相互依赖的关系,那这个类就是一个“孤岛”,在项目中就没有存在的必要了!就像是某个人如果永远独立生活,与任何人都没有关系,那这个人基本上就算是野人了——排除在人类这个定义之外。类之间的依赖关系是必然存在的,一个类依赖多个类的情况也是存在的,存在即合理,那是否可以说只要有多个依赖关系就考虑使用中介者模式呢?答案是否定的。中介者模式未必能帮你把原本凌乱的逻辑整理得清清楚楚,而且中介者模式也是有缺点的,这个缺点在使用不当时会被放大,比如原本就简单的几个对象依赖关系,如果为了使用模式而加入了中介
者,必然导致中介者的逻辑复杂化,因此中介者模式的使用需要“量力而行”!中介者模式适用于多个对象之间紧密耦合的情况,紧密耦合的标准是:在类图中出现了蜘蛛网状结构。在这种情况下一定要考虑使用中介者模式,这有利于把蜘蛛网梳理为星型结构,使原本复杂混乱的关系变得清晰简单。
        --->大家可以在如下的情况下尝试使用中介者模式:
                ● N个对象之间产生了相互的依赖关系(N>2)。
                ● 多个对象有依赖关系,但是依赖的行为尚不确定或者有发生改变的可能,在这种情况下一般建议采用中介者模式,降低变更引起的风险扩散。
                ● 产品开发。一个明显的例子就是MVC框架,把中介者模式应用到产品中,可以提升产品的性能和扩展性,但是对于项目开发就未必,因为项目是以交付投产为目标,而产品则是以稳定、高效、扩展为宗旨。




三:中介模式的实际应用
        --->中介者模式也叫做调停者模式,是什么意思呢?一个对象要和N多个对象交流,就像对象间的战争,很混乱。这时,需要加入一个中心,所有的类都和中心交流,中心说怎么处理就怎么处理,我们举一些在开发和生活中经常会碰到的例子。
        ● 机场调度中心
                大家在每个机场都会看到有一个“××机场调度中心”,它就是具体的中介者,用来调度每一架要降落和起飞的飞机。比如,某架飞机(同事类)飞到机场上空了,就询问调度中心(中介者)“我是否可以降落”以及“降落到哪个跑道”,调度中心(中介者)查看其他飞机
(同事类)情况,然后通知飞机降落。如果没有机场调度中心,飞机飞到机场了,飞行员要先看看有没有飞机和自己一起降落的,有没有空跑道,停机位是否具备等情况,这种局面是难以想象的!
        ● MVC框架
                大家都应该使用过Struts,MVC框架,其中的C(Controller)就是一个中介者,叫做前端控制器(Front Controller),它的作用就是把M(Model,业务逻辑)和V(View,视图)隔离开,协调M和V协同工作,把M运行的结果和V代表的视图融合成一个前端可以展示的页面,减少M和V的依赖关系。MVC框架已经成为一个非常流行、成熟的开发框架,这也是中介者模式的优点的一个体现。
        ● 媒体网关
                媒体网关也是一个典型的中介者模式,比如使用MSN时,张三发消息给李四,其过程应该是这样的:张三发送消息,MSN服务器(中介者)接收到消息,查找李四,把消息发送到李四,同时通知张三,消息已经发送。在这里,MSN服务器就是一个中转站,负责协调两个客户端的信息交流,与此相反的就是IPMsg(也叫飞鸽),它没有使用中介者,而直接使用了UDP广播的方式,每个客户端既是客户端也是服务器端。
        ● 中介服务
                现在中介服务非常多,比如租房中介、出国中介,这些也都是中介模式的具体体现,比如你去租房子,如果没有房屋中介,你就必须一个一个小区去找,看看有没有空房子,有没有适合自己的房子,找到房子后还要和房东签合约,自己检查房屋的家具、水电煤等;有了中介后,你就省心多了,找中介,然后安排看房子,看中了,签合约,中介帮你检查房屋家具、水电煤等等。这也是中介模式的实际应用。




四:中介模式的最佳实践


        ●本章讲述的中介者模式很少用到接口或者抽象类,这与依赖倒置原则是冲突的,这是什么原因呢?首先,既然是同事类而不是兄弟类(有相同的血缘),那就说明这些类之间是协作关系,完成不同的任务,处理不同的业务,所以不能在抽象类或接口中严格定义同事类必须具有的方法(从这点也可以看出继承是高侵入性的)。这是不合适的,就像你我是同事,虽然我们大家都是朝九晚五地上班,但是你跟我干的活肯定不同,不可能抽象出一个父类统一定义同事所必须有的方法。当然,每个同事都要吃饭、上厕所,可以把这些最基本的信息封装到抽象中,但这些最基本的行为或属性是中介者模式要关心的吗?如果两个对象不能提炼出共性,那就不要刻意去追求两者的抽象,抽象只要定义出模式需要的角色即可。当然如
果严格遵守面向接口编程的话,则是需要抽象的,这就需要读者在实际开发中灵活掌握。其次,在一个项目中,中介者模式可能被多个模块采用,每个中介者所围绕的同事类各不相同,你能抽象出一个具有共性的中介者吗?不可能,一个中介者抽象类一般只有一个实现者,除非中介者逻辑非常复杂,代码量非常大,这时才会出现多个中介者的情况。所以,对于中介者来说,抽象已经没有太多的必要。

       ● 中介者模式是一个非常好的封装模式,也是一个很容易被滥用的模式,一个对象依赖几个对象是再正常不过的事情,但是纯理论家就会要求使用中介者模式来封装这种依赖关系,
这是非常危险的!使用中介模式就必然会带来中介者的膨胀问题,这在一个项目中是很不恰当的。



五:中介模式的案例(库房,采购,销售系统运行案例)

【1】中介者抽象类

 1 package com.yeepay.sxf.template9;
 2 /**
 3  * 抽象中介者
 4  * (1)抽象中介者,相当于一个调停者,他可以调停不同的事件,所以中介者可以有很多方法。
 5  * (2)中介者依赖所有的同事类,同事类只依赖一个中介者,中介者去调和他们之间的关系
 6  * @author sxf
 7  *
 8  */
 9 public abstract class AbStractMediator {
10     //采购管理
11     protected Purchase purchase;
12     //销售管理
13     protected Sale sale;
14     //库存管理
15     protected Stock stock;
16     
17     public AbStractMediator(){
18         purchase=new Purchase(this);
19         sale=new Sale(this);
20         stock=new Stock(this);
21     }
22     //中介者做的事情
23     public abstract void execute(String str,Object ...objects);
24     
25     /**
26      * 获取采购
27      * @return
28      */
29     public Purchase getPurchase() {
30         return purchase;
31     }
32     /**
33      * 获取销售
34      * @return
35      */
36     public Sale getSale() {
37         return sale;
38     }
39     /**
40      * 获取库房
41      * @return
42      */
43     public Stock getStock() {
44         return stock;
45     }
46     
47 }
View Code

【2】具体的中介者

 1 package com.yeepay.sxf.template9;
 2 /**
 3  * 具体的中介者
 4  * @author sxf
 5  *
 6  */
 7 public class Mediator extends AbStractMediator{
 8 
 9     
10     @Override
11     public void execute(String str, Object... objects) {
12         if(str.equals("purchase.buy")){ //采购电脑
13             this.buyComputer((Integer)objects[0]);
14             }else if(str.equals("sale.sell")){ //销售电脑
15             this.sellComputer((Integer)objects[0]);
16             }else if(str.equals("sale.offsell")){ //折价销售
17             this.offSell();
18             }else if(str.equals("stock.clear")){ //清仓处理
19             this.clearStock();
20             }
21     }
22     /**
23      * 采购电脑
24      * @param number
25      */
26     private void buyComputer(int number){
27         int saleStatus = super.sale.getSaleStatus();
28         if(saleStatus>80){ //销售情况良好
29             System.out.println("采购IBM电脑:"+number + "台");
30             super.stock.increase(number);
31         }else{ //销售情况不好
32             int buyNumber = number/2; //折半采购
33             System.out.println("采购IBM电脑:"+buyNumber+ "台");
34         }
35     }
36     
37     /**
38      * 销售电脑
39      * @param number
40      */
41     private void sellComputer(int number){
42         if(super.stock.getStockNum()<number){ //库存数量不够销售
43                 super.purchase.buyIBMcomputer(number);
44             }
45             super.stock.decrease(number);
46     }
47     
48     
49     /**
50      * 折价销售电脑
51      */
52     private void offSell(){
53         System.out.println("折价销售IBM电脑"+stock.getStockNum()+"台");
54     }
55     
56     
57     /**
58      * 清仓处理
59      */
60     private void clearStock(){
61         //要求清仓销售
62         super.sale.offSale();
63         //要求采购人员不要采购
64         super.purchase.refuseBuyIBM();
65     }
66     
67 }
View Code

【3】抽象的同事类(参与类)【可以有,可以没有,一般没有】

 1 package com.yeepay.sxf.template9;
 2 /**
 3  * 抽象同事类
 4  * 
 5  * (1)所有的同事类可以不需要共同的抽象类。
 6  * (2)每个同事类的行为不一样,所以不需要抽象类,存在也可以,是所有同事类的共同行为,可以抽象出来
 7  * @author sxf
 8  *
 9  */
10 public abstract class AbstractColleague {
11     protected AbStractMediator abStractMediator;
12     
13     public AbstractColleague(AbStractMediator abStractMediator){
14         this.abStractMediator=abStractMediator;
15     }
16 }
View Code

【4】采购

 1 package com.yeepay.sxf.template9;
 2 /**
 3  * 采购管理
 4  * @author sxf
 5  *
 6  */
 7 public class Purchase extends AbstractColleague{
 8     /**
 9      * 构造
10      * @param abStractMediator
11      */
12     public Purchase(AbStractMediator abStractMediator){
13         super(abStractMediator);
14     }
15     
16     /**
17      * 采购电脑
18      * @param number
19      */
20     public void buyIBMcomputer(int number){
21         super.abStractMediator.execute("purchase.buy", number);
22         System.out.println("Purchase.buyIBMcomputer()采购部要采购"+number+"台电脑");
23     }
24     /**
25      * 不在采购电脑
26      */
27     public void  refuseBuyIBM(){
28         System.out.println("Purchase.refuseBuyIBM()采购部不再采购电脑");
29     }
30 } 
View Code

【5】库房

 1 package com.yeepay.sxf.template9;
 2 /**
 3  * 库存管理
 4  * @author sxf
 5  *
 6  */
 7 public class Stock extends AbstractColleague{
 8     
 9     //初始化库存100台电脑
10     private static int COMPUTER_NUMBER=100;
11     
12     /**
13      * 构造函数
14      * @param abStractMediator
15      */
16     public Stock(AbStractMediator abStractMediator){
17         super(abStractMediator);
18     }
19     /**
20      * 库存增加
21      * @param number
22      */
23     public void increase(int number){
24         System.out.println("Stock.increase()库存原来【"+COMPUTER_NUMBER+"】台电脑");
25         COMPUTER_NUMBER=COMPUTER_NUMBER+number;
26         System.out.println("Stock.increase()库存增加【"+number+"】台电脑 现有库存【"+COMPUTER_NUMBER+"】台电脑");
27         
28     }
29     /**
30      * 库存出库
31      * @param number
32      */
33     public void decrease(int number){
34         System.out.println("Stock.decrease()库存原来【"+COMPUTER_NUMBER+"】台电脑 要出库【"+COMPUTER_NUMBER+"】台电脑");
35     }
36     
37     /**
38      * 获取库存
39      * @return
40      */
41     public int getStockNum(){
42         return COMPUTER_NUMBER;
43     }
44     /**
45      * 库存压力大了,就要通知才口人员清理库存
46      */
47     public void clearStock(){
48         System.out.println("Stock.clearStock()清理库存量为【"+COMPUTER_NUMBER+"】台电脑");
49         super.abStractMediator.execute("stock.clear");
50     }
51 }
View Code

【6】销售

 1 package com.yeepay.sxf.template9;
 2 
 3 import java.util.Random;
 4 
 5 /**
 6  * 销售管理
 7  * @author sxf
 8  *
 9  */
10 public class Sale extends AbstractColleague {
11 
12     /**
13      * 构造函数
14      * @param abStractMediator
15      */
16     public Sale(AbStractMediator abStractMediator){
17         super(abStractMediator);
18     }
19     /**
20      * 销售电脑
21      * @param number
22      */
23     public void sellIBMComputer(int number){
24         super.abStractMediator.execute("sale.sell", number);
25         System.out.println("Sale.sellIBMComputer()销售IBMcomputer电脑【"+number+"】台");
26     }
27     /**
28      * 反馈销售情况 0-100变化,0代表根本没有人买,100代表非常畅销,出一个卖一个
29      */
30     public int getSaleStatus(){
31         Random rand = new Random(System.currentTimeMillis());
32         int saleStatus = rand.nextInt(100);
33         System.out.println("IBM电脑的销售情况为:"+saleStatus);
34         return saleStatus;
35     }
36     
37     /**
38      * 折价处理
39      */
40     public void offSale(){
41         System.out.println("Sale.offSale()销售部门折价处理");
42         super.abStractMediator.execute("sale.offsell");
43     }
44 }
View Code

【7】客户端类

 1 package com.yeepay.sxf.template9;
 2 /**
 3  * 场景类
 4  * @author sxf
 5  *
 6  */
 7 public class Client {
 8 
 9     
10     public static void main(String[] args) {
11         AbStractMediator mediator = new Mediator();
12         //采购人员采购电脑
13         System.out.println("------采购人员采购电脑--------");
14         Purchase purchase = mediator.getPurchase();
15         purchase.buyIBMcomputer(100);
16         //销售人员销售电脑
17         System.out.println("\n------销售人员销售电脑--------");
18         Sale sale = mediator.getSale();
19         sale.sellIBMComputer(1);
20         //库房管理人员管理库存
21         System.out.println("\n------库房管理人员清库处理--------");
22         Stock stock = mediator.getStock();
23         stock.clearStock();
24     }
25 }
View Code

 

相关文章
|
8月前
|
设计模式 前端开发
设计模式21 - 中介者模式【【Mediator Pattern】
设计模式21 - 中介者模式【【Mediator Pattern】
30 0
|
8月前
|
设计模式 调度
行为型设计模式09-中介者模式
行为型设计模式09-中介者模式
25 0
|
8月前
|
设计模式 C++
设计模式之中介者模式(C++)
设计模式之中介者模式(C++)
|
4天前
|
设计模式
设计模式之中介者模式
设计模式之中介者模式
|
17天前
|
设计模式 前端开发 NoSQL
设计模式第八讲:观察者模式和中介者模式详解
 定义一个中介对象来封装一系列对象之间的交互,使原有对象之间的耦合松散,且可以独立地改变它们之间的交互。中介者模式又叫调停模式,它是迪米特法则的典型应用。
172 0
|
1月前
|
设计模式 Go
[设计模式 Go实现] 行为型~中介者模式
[设计模式 Go实现] 行为型~中介者模式
|
1月前
|
设计模式 Java
小谈设计模式(26)—中介者模式
小谈设计模式(26)—中介者模式
|
1月前
|
设计模式 Java
23种设计模式,中介者模式的概念优缺点以及JAVA代码举例
【4月更文挑战第8天】中介者模式是一种行为设计模式,它通过一个中介对象来封装一系列对象交互。中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。
48 8
|
1月前
|
设计模式 调度
【设计模式系列笔记】中介者模式
中介者模式(Mediator Pattern)是一种行为设计模式,它通过将对象之间的直接通信转移到一个中介对象中,来减少对象之间的耦合度。这种模式被用来处理一个对象与其他对象之间的交互,使得各对象之间不需要直接相互了解。
27 0
|
1月前
|
设计模式 Java 数据库连接
聊聊Java设计模式-中介者模式
中介者(Mediator)模式指定义了一个单独的中介对象,来封装一组对象之间的交互。即将这组对象之间的交互委派给中介对象,从而来避免对象之间的直接交互。
56 1

热门文章

最新文章