设计模式——21. 中介者模式

最新推荐文章于 2024-09-30 16:40:56 发布
最新推荐文章于 2024-09-30 16:40:56 发布
阅读量329 收藏
点赞数
分类专栏： 设计模式大全 文章标签： 设计模式 中介者模式 java python golang javascript c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guohuang/article/details/133801291
版权

1. 说明

中介者模式（Mediator Pattern）是一种行为设计模式，它允许对象之间通过一个中介者对象进行通信，而不是直接相互引用。这种模式有助于减少对象之间的直接关联，从而提高系统的可维护性和松耦合性。中介者模式将对象之间的交互集中在一个中介者对象中，该对象负责协调和管理对象之间的通信。
中介者模式通常包含以下角色：

  1. 中介者（Mediator）： 中介者是一个接口或抽象类，定义了对象之间通信的协议。
  2. 具体中介者（Concrete Mediator）： 具体中介者是实现中介者接口的具体类，它负责实际协调和管理对象之间的通信。
  3. 同事类（Colleague）： 同事类是相互交互的对象，它们通过中介者来通信而不是直接相互引用。
    中介者模式的主要优点包括：
  • 减少了对象之间的直接关联，使系统更加松耦合。
  • 提高了系统的可维护性，因为对象之间的通信逻辑集中在中介者中。
  • 可以更容易地扩展系统，添加新的同事类或更改现有的同事类。
    中介者模式通常在以下情况下使用：
  • 当系统中的对象之间存在复杂的相互关系，导致对象之间相互依赖性较高时，中介者模式可以帮助降低依赖性，提高系统的可维护性。
  • 当需要一个对象集中控制其他对象之间的通信时，中介者模式可以用来管理和协调对象之间的交互。

总之，中介者模式有助于将系统中的对象解耦，提高系统的灵活性和可维护性。它在复杂的系统中特别有用，可以帮助管理对象之间的复杂交互。

2. 使用的场景

中介者模式的使用场景通常包括以下情况：

  1. 对象之间的关系复杂： 当系统中的对象之间存在复杂的相互关系，导致对象之间相互依赖性较高时，中介者模式可以帮助降低依赖性，提高系统的可维护性。这种情况下，中介者充当了对象之间的协调者，负责管理它们之间的通信。
  2. 减少子类化： 在某些情况下，为了实现对象之间的通信，可能需要创建大量的子类。使用中介者模式可以减少子类化，因为对象通过中介者而不是直接相互引用。
  3. 分布式系统： 在分布式系统中，不同的组件通常需要进行通信，但直接通信可能会导致复杂性增加。中介者模式可以用于集中管理分布式系统中的通信。
  4. 图形用户界面（GUI）应用程序： GUI 应用程序中的用户界面元素通常需要相互响应用户操作。中介者模式可以用于管理用户界面元素之间的交互，以确保用户界面的一致性和协调性。
  5. 多人协作系统： 在多人协作系统中，不同用户可能需要共享信息或协同工作。中介者模式可以用于管理用户之间的通信和协作，以确保数据的一致性和安全性。
  6. 电子设备控制系统： 在家庭自动化或工业控制系统中，多个电子设备可能需要协同工作。中介者模式可以用于控制和协调这些设备之间的通信和操作。

总之，中介者模式适用于任何需要管理对象之间复杂关系和通信的场景，以提高系统的可维护性和灵活性。它有助于降低对象之间的耦合度，使系统更易于扩展和维护。

3. 应用例子

下面是一个使用 Python 实现的简单中介者模式示例，模拟了一个简单的聊天室应用程序，其中多个用户通过中介者进行聊天：

# 中介者接口
class Mediator:
    def send_message(self, message, user):
        pass

# 具体中介者
class ChatMediator(Mediator):
    def __init__(self):
        self.users = []

    def add_user(self, user):
        self.users.append(user)

    def send_message(self, message, user):
        for u in self.users:
            if u != user:
                u.receive_message(message)

# 同事类
class User:
    def __init__(self, name, mediator):
        self.name = name
        self.mediator = mediator

    def send(self, message):
        print(f"{self.name} 发送消息: {message}")
        self.mediator.send_message(message, self)

    def receive_message(self, message):
        print(f"{self.name} 收到消息: {message}")

# 使用示例
if __name__ == "__main__":
    chat_mediator = ChatMediator()

    user1 = User("User1", chat_mediator)
    user2 = User("User2", chat_mediator)
    user3 = User("User3", chat_mediator)

    chat_mediator.add_user(user1)
    chat_mediator.add_user(user2)
    chat_mediator.add_user(user3)

    user1.send("大家好！")
    user2.send("你好，User1！")
    user3.send("欢迎加入聊天！")

在这个示例中：

  • Mediator 是中介者接口，定义了 send_message 方法，用于发送消息给其他用户。
  • ChatMediator 是具体中介者类，实现了中介者接口，负责维护用户列表并协调用户之间的通信。
  • User 是同事类，每个用户都有一个名称和一个中介者。它们可以通过中介者发送和接收消息。

通过中介者模式，用户对象不需要直接与其他用户通信，而是通过中介者来发送和接收消息，从而降低了对象之间的耦合度。这有助于添加新用户和扩展聊天室功能。

4. 实现要素

中介者模式的实现要素包括以下部分：

  1. 中介者（Mediator）： 中介者是一个接口或抽象类，定义了对象之间通信的协议。它通常包括方法来注册、删除和通知各个同事对象。
  2. 具体中介者（Concrete Mediator）： 具体中介者是实现中介者接口的具体类，它负责实际协调和管理对象之间的通信。它需要维护一个对所有同事对象的引用。
  3. 同事类（Colleague）： 同事类是相互交互的对象，它们通过中介者来通信而不是直接相互引用。同事类通常包括方法来发送消息给中介者以及接收来自中介者的消息。
  4. 具体同事类（Concrete Colleague）： 具体同事类是实现同事类接口的具体类，它们通过中介者与其他同事对象通信。具体同事类之间通常存在一些关联和相互依赖。

5. Java/golang/javascrip/C++ 等语言实现方式

5.1 Java实现

上述例子用Java语言实现示例如下：

import java.util.ArrayList;
import java.util.List;

// 中介者接口
interface Mediator {
    void sendMessage(String message, User user);
}

// 具体中介者
class ChatMediator implements Mediator {
    private List<User> users = new ArrayList<>();

    @Override
    public void sendMessage(String message, User user) {
        for (User u : users) {
            if (u != user) {
                u.receiveMessage(message);
            }
        }
    }

    public void addUser(User user) {
        users.add(user);
    }
}

// 同事类
class User {
    private String name;
    private Mediator mediator;

    public User(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    public void sendMessage(String message) {
        System.out.println(name + " 发送消息: " + message);
        mediator.sendMessage(message, this);
    }

    public void receiveMessage(String message) {
        System.out.println(name + " 收到消息: " + message);
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        ChatMediator chatMediator = new ChatMediator();

        User user1 = new User("User1", chatMediator);
        User user2 = new User("User2", chatMediator);
        User user3 = new User("User3", chatMediator);

        chatMediator.addUser(user1);
        chatMediator.addUser(user2);
        chatMediator.addUser(user3);

        user1.sendMessage("大家好！");
        user2.sendMessage("你好，User1！");
        user3.sendMessage("欢迎加入聊天！");
    }
}

在这个示例中：

  • Mediator 是中介者接口，定义了 sendMessage 方法，用于发送消息给其他用户。
  • ChatMediator 是具体中介者类，实现了中介者接口，负责维护用户列表并协调用户之间的通信。
  • User 是同事类，每个用户都有一个名称和一个中介者。它们可以通过中介者发送和接收消息。

通过中介者模式，用户对象不需要直接与其他用户通信，而是通过中介者来发送和接收消息，从而降低了对象之间的耦合度。这有助于添加新用户和扩展聊天室功能。

5.2 Golang实现

上述例子用golang实现示例如下：

package main

import (
        "fmt"
        "sync"
)

// Mediator 接口定义中介者的方法
type Mediator interface {
        SendMessage(message string, user *User)
}

// ChatMediator 是具体中介者类
type ChatMediator struct {
        users []*User
        mutex sync.Mutex
}

// NewChatMediator 创建 ChatMediator 实例
func NewChatMediator() *ChatMediator {
        return &ChatMediator{
                users: make([]*User, 0),
        }
}

// AddUser 将用户添加到中介者中
func (m *ChatMediator) AddUser(user *User) {
        m.mutex.Lock()
        defer m.mutex.Unlock()
        m.users = append(m.users, user)
}

// SendMessage 将消息广播给所有用户，除了发送者
func (m *ChatMediator) SendMessage(message string, sender *User) {
        m.mutex.Lock()
        defer m.mutex.Unlock()
        for _, user := range m.users {
                if user != sender {
                        user.ReceiveMessage(message)
                }
        }
}

// User 是同事类
type User struct {
        name     string
        mediator Mediator
}

// NewUser 创建 User 实例
func NewUser(name string, mediator Mediator) *User {
        return &User{
                name:     name,
                mediator: mediator,
        }
}

// SendMessage 发送消息
func (u *User) SendMessage(message string) {
        fmt.Printf("%s 发送消息: %s\n", u.name, message)
        u.mediator.SendMessage(message, u)
}

// ReceiveMessage 接收消息
func (u *User) ReceiveMessage(message string) {
        fmt.Printf("%s 收到消息: %s\n", u.name, message)
}

func main() {
        mediator := NewChatMediator()

        user1 := NewUser("User1", mediator)
        user2 := NewUser("User2", mediator)
        user3 := NewUser("User3", mediator)

        mediator.AddUser(user1)
        mediator.AddUser(user2)
        mediator.AddUser(user3)

        user1.SendMessage("大家好！")
        user2.SendMessage("你好，User1！")
        user3.SendMessage("欢迎加入聊天！")
}

在这个示例中：

  • Mediator 是中介者接口，定义了 SendMessage 方法，用于发送消息给其他用户。
  • ChatMediator 是具体中介者类，负责维护用户列表并协调用户之间的通信。
  • User 是同事类，每个用户都有一个名称和一个中介者。它们可以通过中介者发送和接收消息。

通过中介者模式，用户对象不需要直接与其他用户通信，而是通过中介者来发送和接收消息，从而降低了对象之间的耦合度。这有助于添加新用户和扩展聊天室功能。

5.3 Javascript实现

上述例子用javascript实现示例如下：

// 中介者接口
class Mediator {
  constructor() {
    this.users = [];
  }

  addUser(user) {
    this.users.push(user);
  }

  sendMessage(message, sender) {
    for (const user of this.users) {
      if (user !== sender) {
        user.receiveMessage(message);
      }
    }
  }
}

// 具体中介者
class ChatMediator extends Mediator {
  constructor() {
    super();
  }
}

// 同事类
class User {
  constructor(name, mediator) {
    this.name = name;
    this.mediator = mediator;
  }

  sendMessage(message) {
    console.log(`${this.name} 发送消息: ${message}`);
    this.mediator.sendMessage(message, this);
  }

  receiveMessage(message) {
    console.log(`${this.name} 收到消息: ${message}`);
  }
}

// 使用示例
const chatMediator = new ChatMediator();

const user1 = new User("User1", chatMediator);
const user2 = new User("User2", chatMediator);
const user3 = new User("User3", chatMediator);

chatMediator.addUser(user1);
chatMediator.addUser(user2);
chatMediator.addUser(user3);

user1.sendMessage("大家好！");
user2.sendMessage("你好，User1！");
user3.sendMessage("欢迎加入聊天！");

在这个示例中：

  • Mediator 是中介者类，负责维护用户列表并定义 addUser 和 sendMessage 方法。
  • ChatMediator 是具体中介者类，继承自 Mediator，用于实际协调用户之间的通信。
  • User 是同事类，每个用户都有一个名称和一个中介者。它们可以通过中介者发送和接收消息。

通过中介者模式，用户对象不需要直接与其他用户通信，而是通过中介者来发送和接收消息，从而降低了对象之间的耦合度。这有助于添加新用户和扩展聊天室功能。

5.4 C++实现

上述例子用C++实现如下：

#include <iostream>
#include <vector>

// 前向声明
class User;

// 中介者抽象类
class Mediator {
public:
    virtual void addUser(User* user) = 0;
    virtual void sendMessage(const std::string& message, User* sender) = 0;
};

// 具体中介者类
class ChatMediator : public Mediator {
private:
    std::vector<User*> users;

public:
    void addUser(User* user) override {
        users.push_back(user);
    }

    void sendMessage(const std::string& message, User* sender) override {
        for (User* user : users) {
            if (user != sender) {
                user->receiveMessage(message);
            }
        }
    }
};

// 用户类
class User {
private:
    std::string name;
    Mediator* mediator;

public:
    User(const std::string& name, Mediator* mediator) : name(name), mediator(mediator) {
        mediator->addUser(this);
    }

    void sendMessage(const std::string& message) {
        std::cout << name << " 发送消息: " << message << std::endl;
        mediator->sendMessage(message, this);
    }

    void receiveMessage(const std::string& message) {
        std::cout << name << " 收到消息: " << message << std::endl;
    }
};

int main() {
    ChatMediator chatMediator;

    User user1("User1", &chatMediator);
    User user2("User2", &chatMediator);
    User user3("User3", &chatMediator);

    user1.sendMessage("大家好！");
    user2.sendMessage("你好，User1！");
    user3.sendMessage("欢迎加入聊天！");

    return 0;
}

在这个示例中：

  • Mediator 是中介者抽象类，定义了 addUser 和 sendMessage 纯虚函数。
  • ChatMediator 是具体中介者类，继承自 Mediator，负责维护用户列表并协调用户之间的通信。
  • User 是用户类，每个用户都有一个名称和一个中介者指针。它们可以通过中介者发送和接收消息。

通过中介者模式，用户对象不需要直接与其他用户通信，而是通过中介者来发送和接收消息，从而降低了对象之间的耦合度。这有助于添加新用户和扩展聊天室功能。

7. 练习题

假设你正在开发一个多人游戏，其中有多个玩家角色。这些角色可以相互交互，比如发送消息、交换物品等。使用中介者模式设计一个游戏中的聊天系统，其中玩家角色可以通过中介者发送和接收消息。

要求：

  1. 创建一个中介者类，用于协调玩家角色之间的通信。
  2. 创建多个玩家角色类，它们可以向中介者发送消息，并能够接收来自其他玩家的消息。
  3. 模拟玩家之间的交互，例如，一个玩家发送消息后，其他玩家能够收到该消息并显示在控制台上。
  4. 编写一个示例程序来演示中介者模式在多人游戏中的应用。

你可以使用 C++、Java、Python 或任何其他编程语言来实现这个练习。
你可以在评论区里或者私信我回复您的答案，这样我或者大家都能帮你解答，期待着你的回复~

guohuang
关注
专栏目录
Java设计模式——中介者模式
邻家小乌龟的博客
11-16 355
Java设计模式——中介者模式学习笔记整理（自用）
设计模式——JAVA.docx
04-03
### JAVA设计模式总结之23种设计模式及六大原则 #### 一、设计模式之六大原则 ##### 总原则：开闭原则（Open Close Principle） 开闭原则是设计模式中最核心的原则之一，它强调的是软件实体（类、模块、函数等）...
C++之中介者(Mediator)模式
lovely_yoshino的博客
06-20 4103
0. 简介 中介者模式和命令模式类似，都有着一层中间层来作为沟通的渠道，只是中介者模式使用了Mediator来实现实现更新函数changed。而在命令模式中使用Invoke作为最上层，用于管理具体类的操作，从而对接收者增删。简而言之，命令模式在发送者和请求者之间建立单向连接，使请求者可以调用发送者的不同方法。中介者清除了发送者和请求者之间的直接连接， 强制它们通过一个中介对象进行间接沟通。 1. 中介者模式示意图 中介者模式是一种行为设计模式， 能让你减少对象之间混乱无序的依赖关系。 该模式会限制对象之间的
设计模式之中介者模式详解
glass__sky的博客
06-10 6366
一般来说，类之间的关系是比较复杂的，多个类之间互相关联时，他们之间的关系会呈现为复杂的网状结构，这是一种过度耦合的架构，即不利于类的复用，也不稳定。例如在下左图中，有六个类对象，假如对象1发生变化，那么将会有4个对象受到影响。如果对象2发生变化，那么将会有5个对象受到影响。也就是说，类之间直接关联的设计是不好的。...
C++ 设计模式——中介者模式
qq_68194402的博客
08-30 2363
中介者模式（Mediator Pattern）是一种行为型设计模式，它允许对象间的通信被封装到一个中介者对象中。该模式的主要目的是减少多个对象和类之间的通信复杂性，通过创建一个集中的控制点来管理相互间的依赖关系。这种模式特别适用于大型系统中，可以帮助减少组件之间的直接交互，从而使其更易于维护和扩展。
js设计模式——8.中介者模式
weixin_33674976的博客
04-18 80
js设计模式——8.中介者模式 /*js设计模式——中介者模式*/ class A { constructor() { this.number = 0; } setNumber(num, m) { this.number = num; if (m) { ...
设计模式——中介者模式
weixin_42903300的博客
06-19 798
虽然将一个系统分割成许多类对象可以增加程序的复用性，但是对象之间的相互连接又降低了程序的复用性。大量的连接使得一个对象不可能在没有其他对象支持的情况下工作，系统表现为一个不可分割的整体，类之间的关系千丝万缕，对系统进行任何大的改动都会并比较困难。Colleague叫做抽象同事类，而ConcreteColleague是具体同事类，每个具体同事只知道自己的行为，而不了解其他同事的情况，但是它们都认识中介者对象。Mediator是抽象中介者，定义了同事对象到中介者对象的接口。
设计模式——Mediator(中介者)模式
qq_36566262的博客
04-20 1034
目录前言1 定义2 适用性3 结构3.1 结构图3.2 参与者4 应用举例——以房产中介为例4.1 Mediator——HouseMediator4.2 具体Mediator——BeijingHouseMediato4.3 Colleague4.4 具体Colleague——ConcreteColleagueOne、ConcreteColleagueTwo5 总结参考文献 前言 将一个系统分割为多个对象可以增强复用性，但是对象之间相互连接又会降低复用性。如果使用一个中介对象来改变这总交互关系将增强系统健壮性
C++设计模式(21)——中介者模式
伍粟的博客
02-25 1008
C++ 中介者模式
C++设计模式——Mediator中介者模式
CoderZZ_2024的博客
09-11 1596
中介者模式是一种行为型设计模式。它通过一个中介者对象将多个对象之间的交互关系进行封装，使得对象之间的交互需要通过中介者对象来完成。该设计模式的结构很容易理解，以中介者为中心。中介者模式的设计思想侧重于在对象之间增加一个用来调度的中介。有了中介者模式，各个对象可以专注于各自的业务处理逻辑，而不需要关心通信的具体实现细节。航空管制系统：航空管制系统作为中介者，协调飞机、航空公司和机场的通信和协作。交易系统：在金融领域，交易系统将银行、金融机构、客户等各个参与者进行协调，确保资金的安全快速转移。
17行为型设计模式——中介者模式
qq_55610255的博客
08-27 988
中介者（Mediator）定义一个接口用于与各个组件进行通信。具体中介者（ConcreteMediator）实现该接口，负责协调各个组件之间的交互。同事类（Colleague）各个参与交互的对象，通常是需要通过中介者来进行交互的对象。每个同事类对象持有对中介者对象的引用，通过中介者来发送和接收消息。中介者模式集中管理所有对象的交互行为，通过中介者减少对象之间的直接依赖，即不需要各个对象显式的去相互交互，而是由中介者去和各个对象直接交互，一定程度下降低耦合度，并使得系统的设计更加清晰、模块化。
浅析Java设计模式【3】——代理.pdf
07-27
### 浅析Java设计模式【3】——代理 #### 一、代理模式概述 代理模式是一种行为型设计模式，主要用于在客户端与目标对象之间起到一个中介的作用，通过代理对象来控制对目标对象的访问。代理模式的核心在于它可以...
设计模式、系统设计 record part02
m0_47505062的博客
09-27 1189
软件设计模式1.应对重复发生的问题2.解决方案3.可以反复使用1.本质是面向对象2.优点很多1.创建型-创建和使用分离2.结构型-组合3.行为型-协作5+7+11=23种模式UML-统一建模语言-Unified Modeling Language1.可视化图形化2.各种图（9种图）3.可以同时表示静态信息、动态信息类图就是图形化显式类关联关系。
单例设计模式
SunnyRivers
09-26 908
单例模式（Singleton Pattern）指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点，属于创建型设计模式。单例模式在现实生活中的应用非常广泛，例如公司CEO、部门经理等都属于单例模型。J2EE标准中的ServletContext和ServletContextConfig、Spring框架应用中的ApplicationContext、数据库中的连接池等也都是单例模式。对于Java来说，单例模式可以保证在一个JVM中只存在单一实例。单例模式的应用场景主要有以下几个方面。
Qt C++设计模式-＞享元模式
m0_46494667的博客
09-24 1382
享元模式（Flyweight Pattern）是一种结构型设计模式，旨在通过共享相同对象来减少内存使用，尤其适合在大量重复对象的情况下。它通过将对象的可共享部分抽取出来，并在多个上下文中共享，从而避免对象的多次创建。
行为设计模式 -模板方法模式- JAVA
智的博客
09-28 1646
模板方法是一种行为设计模式。模板方法设计模式用于创建方法存根并将某些实现步骤推迟到子类。模板方法模式定义了一个算法的步骤，并允许子类别为一个或多个步骤提供其实践方式。让子类别在不改变算法架构**的情况下，重新定义算法中的某些步骤。在面向对象程序设计过程中，我们常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。通俗理解，就是设计构建一个对象的时候，类的步骤已经固定了，可是某些类的实现逻辑。
【Java】六大设计原则和23种设计模式
weixin_71491685的博客
09-28 1237
代理模式给某一个对象提供一个代理对象并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我只是负责选择自己喜欢的车，然后付钱就可以了。
【设计模式-职责链】
最新发布
严文文 Chris
09-30 375
职责链模式是一种行为设计模式，**它通过将请求发送给链上的多个处理者来避免请求发送者与处理者之间的紧密耦合。每个处理者可以选择处理请求或将其传递给链中的下一个处理者。**这样，可以将处理请求的责任链式组织，从而实现更灵活的请求处理机制。
软件设计模式——工厂模式
weixin_54859557的博客
09-25 1156
软件设计模式——工厂模式
Java实现中介者模式——虚拟聊天室设计
中介者模式是一种行为设计模式，它的主要作用是降低多个对象之间的耦合度，通过引入一个中介对象来协调这些对象之间的交互。在本实验中，抽象中介者角色由`AbstractChatroom`类代表，它定义了成员注册、发送文本信息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

guohuang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值