中介者设计模式（Mediator Design Pattern）[论点:概念、组成角色、相关图示、示例代码、适用场景]

雨点打透心脏的1/2处 2024-04-22 07:14 45阅读 0赞

#### 文章目录 ####

*  概念
 *  组成角色
 *  相关图示
 *  示例代码
 *  适用场景

## 概念 ##

中介者设计模式是一种行为型设计模式，它通过引入一个中介对象来封装一组对象之间的交互，使得对象之间不需要显式地相互引用，从而降低它们之间的耦合。通过将对象间的通信封装到中介者对象中，可以更容易地对这些对象的交互进行维护和修改。

## 组成角色 ##

1.  抽象中介者（Mediator）：定义了一个接口，用于与各同事（Colleague）对象之间的通信。
2.  具体中介者（ConcreteMediator）：实现抽象中介者接口，协调各同事对象的交互关系。它需要了解并维护各同事对象。
3.  抽象同事（Colleague）：定义各个同事对象的接口。各同事对象应该知道中介者对象，即可以与中介者对象通信。同事对象与其他同事对象的通信都通过中介者来完成。
4.  具体同事（ConcreteColleague）：实现抽象同事接口，具体的同事对象。每个具体同事对象只需要知道自己与中介者的交互，不需要了解其他同事。

## 相关图示 ##

![在这里插入图片描述][ddae50bee4ae49ada53a6dc54c3be8c4.png]

## 示例代码 ##

// 抽象中介者
    interface Mediator {
        
        void sendMessage(String message, Colleague colleague);
    }
    
    // 具体中介者
    class ConcreteMediator implements Mediator {
        
        private ColleagueA colleagueA;
        private ColleagueB colleagueB;
    
        public void setColleagueA(ColleagueA colleagueA) {
        
            this.colleagueA = colleagueA;
        }
    
        public void setColleagueB(ColleagueB colleagueB) {
        
            this.colleagueB = colleagueB;
        }
    
        @Override
        public void sendMessage(String message, Colleague colleague) {
        
            if (colleague == colleagueA) {
        
                colleagueB.receiveMessage(message);
            } else {
        
                colleagueA.receiveMessage(message);
            }
        }
    }
    
    // 抽象同事
    abstract class Colleague {
        
        protected Mediator mediator;
    
        public Colleague(Mediator mediator) {
        
            this.mediator = mediator;
        }
    }
    
    // 具体同事A
    class ColleagueA extends Colleague {
        
        public ColleagueA(Mediator mediator) {
        
            super(mediator);
        }
    
        public void send(String message) {
        
            mediator.sendMessage(message, this);
        }
    
        public void receiveMessage(String message) {
        
            System.out.println("同事A收到信息：" + message);
        }
    }
    
    // 具体同事B
    class ColleagueB extends Colleague {
        
        public ColleagueB(Mediator mediator) {
        
            super(mediator);
        }
    
        public void send(String message) {
        
            mediator.sendMessage(message, this);
        }
    
        public void receiveMessage(String message) {
        
            System.out.println("同事B收到信息：" + message);
        }
    }
    
    // 客户端代码
    public class MediatorDemo {
        
        public static void main(String[] args) {
        
            ConcreteMediator mediator = new ConcreteMediator();
    
            ColleagueA colleagueA = new ColleagueA(mediator);
            ColleagueB colleagueB = new ColleagueB(mediator);
    
            mediator.setColleagueA(colleagueA);
            mediator.setColleagueB(colleagueB);
    
            colleagueA.send("你好，同事B！");
            colleagueB.send("你好，同事A！");
        }
    }

## 适用场景 ##

1.  大量对象交互：在一个系统中，有许多对象需要相互交流和协作。通过引入中介者，可以将复杂的对象关系简化，减少直接依赖。
2.  易扩展：当需要添加新的对象时，无需修改原有对象之间的交互逻辑，只需在中介者中添加新对象的交互逻辑，降低了维护成本。
3.  解耦：中介者将对象之间的交互行为封装起来，使得各对象之间的耦合度降低，有利于代码重用和模块化。
4.  需要改变对象交互方式：当需要改变对象之间的交互方式时，无需修改对象本身，只需修改中介者，这有助于提高系统的灵活性。

**以下是一些中介者设计模式可能适用的实际场景：**

1.  聊天室应用：聊天室中的用户通过中介者对象（聊天室服务器）发送和接收消息，而无需直接与其他用户通信。
2.  交通信号控制系统：多个交通信号灯通过中介者（信号控制器）进行协调，避免直接引用和相互影响。
3.  用户界面(UI)组件协调：在复杂的用户界面中，多个UI组件之间的交互和状态变化可以通过中介者对象进行统一管理，降低组件之间的耦合程度。
4.  机场调度系统：通过中介者（调度中心）来协调飞机、跑道、航班等资源的调度，降低各部分之间的依赖。

**在多个对象之间需要进行协调、交互或者依赖的场景下，可以考虑使用中介者设计模式。**

[ddae50bee4ae49ada53a6dc54c3be8c4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/59adb3c73e9d44a5a144e6f691f7215b.png