一天学习一个设计模式之中介者模式

中介者模式(Mediator),用一个中介对象来封装一系列对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。

代码如下:

 1 /**
 2  * 抽象中介者类
 3  */
 4 public abstract class Mediator {
 5     /**
 6      * 定义一个抽象的发送消息方法,得到同事对象和发送信息
 7      * @param message
 8      * @param colleague
 9      */
10     public abstract void Send(String message,Colleague colleague);
11 }
 1 /**
 2  * 抽象同事类
 3  */
 4 public abstract class Colleague {
 5     protected Mediator mediator;
 6 
 7     /**
 8      * 构造方法,传入中介者对象
 9      * @param mediator
10      */
11     public Colleague(Mediator mediator) {
12         this.mediator = mediator;
13     }
14 }
 1 /**
 2  * 具体同事类1
 3  */
 4 public class ConcreteColleague1 extends Colleague{
 5     /**
 6      * 构造方法,传入中介者对象
 7      *
 8      * @param mediator
 9      */
10     public ConcreteColleague1(Mediator mediator) {
11         super(mediator);
12     }
13 
14     /**
15      * 发送信息时通常是中介者发送的
16      * @param message
17      */
18     public void Send(String message){
19         mediator.Send(message,this);
20     }
21 
22     public void NotifyMessage(String message){
23         System.out.println("同事1得到信息:"+message);
24     }
25 }
 1 /**
 2  * 同事2
 3  */
 4 public class ConcreteColleague2 extends Colleague{
 5     /**
 6      * 构造方法,传入中介者对象
 7      *
 8      * @param mediator
 9      */
10     public ConcreteColleague2(Mediator mediator) {
11         super(mediator);
12     }
13 
14     public void Send(String message){
15         mediator.Send(message,this);
16     }
17 
18 
19     public void NotifyMessage(String message){
20         System.out.println("同事2得到信息:"+message);
21     }
22 }
 1 /**
 2  * 具体中介者类
 3  */
 4 public class ConcreteMediator extends Mediator {
 5 
 6     public ConcreteColleague1 getConcreteColleague1() {
 7         return concreteColleague1;
 8     }
 9 
10     public void setConcreteColleague1(ConcreteColleague1 concreteColleague1) {
11         this.concreteColleague1 = concreteColleague1;
12     }
13 
14     public ConcreteColleague2 getConcreteColleague2() {
15         return concreteColleague2;
16     }
17 
18     public void setConcreteColleague2(ConcreteColleague2 concreteColleague2) {
19         this.concreteColleague2 = concreteColleague2;
20     }
21 
22     private ConcreteColleague1 concreteColleague1;
23     private ConcreteColleague2 concreteColleague2;
24     @Override
25     public void Send(String message, Colleague colleague) {
26         if (colleague==concreteColleague1){
27             concreteColleague2.NotifyMessage(message);
28         }
29         else {
30             concreteColleague1.NotifyMessage(message);
31         }
32     }
33 }
 1 /**
 2  * 客户端
 3  */
 4 public class Client {
 5     public static void main(String[] args) {
 6         ConcreteMediator m=new ConcreteMediator();
 7         ConcreteColleague1 c1=new ConcreteColleague1(m);
 8         ConcreteColleague2 c2=new ConcreteColleague2(m);
 9         m.setConcreteColleague1(c1);
10         m.setConcreteColleague2(c2);
11         c1.Send("c2吃饭了吗");
12         c2.Send("没有呢,你打算请客?");
13     }
14 }

1、一对多的对象依赖转化为一对一依赖

  当一个软件结构中出现了多个对象之间相互依赖的关系,错综复杂的对象关系让我们很难理清,维护上更是无从下手,这个时候,我们需要将这种错综复杂的多个对象相互依赖的关系转化一下,通过增加中介者角色,将多个对象的一对多对象关系转化为一对一的关系,将多个对象之间的耦合度降低,使其都通过中介者角色来相互联系。从而,可以大大减少类间依赖,更有利于系统后期的扩展和维护。

2、集中控制提高类的利用性

  中介者角色的出现,将原本分散在多个类中的不同功能方法,都统一地集中在了中介者角色上,这样有利于程序功能的复用,也增强 了类的管理性,对于软件结构的扩展和修改的控制几乎都集中在了中介者角色上,便于集中写得。另外中介者模式的应用要慎重,因为随着依赖对象的增加而被放大。因此,使用中介模式时,一定要考虑实际情况,只有那种超级复杂的对象相互依赖关系,我们难以理清时,使用中介者模式会使原本混乱的关系变得清晰简单;而对于 那种一般性的对象之间的依赖关系,使用中介者模式反而会增加处理逻辑的复杂度。

原文地址:https://www.cnblogs.com/gousheng107/p/8184494.html