您现在的位置是：首页 >学无止境 >「中介者（Mediator）」设计模式 Swift实现网站首页学无止境

设计模式介绍

中介者设计模式（Mediator Pattern）是一种行为型设计模式，它可以促进对象之间的松耦合关系，通过集中控制这些对象之间的通信来减少对象之间的直接依赖。

在这种模式中，中介者对象充当了通信的中心枢纽，其主要的功能是将对象之间的通信转移至自身，从而使这些对象之间解耦，并且更容易维护和扩展。

具体来说，在中介者模式中，每个对象都有指向中介者对象的引用，通过调用中介者对象的方法来与其它对象进行协调和通信，而不是直接与其它对象进行交互。

下面我们用一个简单的 Swift 代码例子来阐述中介者模式的应用。

具体业务场景举例一

假设我们有一个电子竞技比赛的游戏，有两个角色分别是 PlayerA 和 PlayerB，他们之间需要进行协同作战，需要进行通信。我们可以使用中介者模式来实现：

首先，我们需要定义一个 Mediator 协议，用于规范中介者的行为：

protocol Mediator {
    func communicate(sender: Player)
}

然后，我们定义 PlayerA 和 PlayerB 两个角色类，分别继承自 Player 类，并在构造函数中将中介者对象传递进去：

class Player: NSObject {
    var mediator: Mediator
    init(mediator: Mediator) {
        self.mediator = mediator
    }
    func attack() {
        
    }
}

class PlayerA: Player {
    override init(mediator: Mediator) {
        super.init(mediator: mediator)
    }
    override func attack() {
        // 发起攻击
        mediator.communicate(sender: self)
    }
}

class PlayerB: Player {
    override init(mediator: Mediator) {
        super.init(mediator: mediator)
    }
    override func attack() {
        // 发起攻击
        mediator.communicate(sender: self)
    }
}

其中，PlayerA 和 PlayerB 都覆盖了 attack() 方法，并在其中通过中介者通信。

最后，我们定义一个 GameMediator 类，实现 Mediator 协议，并在其中实现 communicate(sender: Player) 方法，来控制角色之间的通信：

class GameMediator: Mediator {
    func communicate(sender: Player) {
        if sender is PlayerA {
            print("PlayerA 发起攻击")
            print("PlayerB 响应攻击，并进行防御")
        } else if sender is PlayerB {
            print("PlayerB 发起攻击")
            print("PlayerA 响应攻击，并进行防御")
        }
    }
}

在 GameMediator 的 communicate() 方法中，我们根据发送者的类型来实现不同的协作策略。

现在我们可以在客户端代码中实例化 GameMediator 和 PlayerA、PlayerB 对象，并进行通信：

let mediator = GameMediator()
let playerA = PlayerA(mediator: mediator)
let playerB = PlayerB(mediator: mediator)

playerA.attack()
playerB.attack()

输出结果：

PlayerA 发起攻击
PlayerB 响应攻击，并进行防御
PlayerB 发起攻击
PlayerA 响应攻击，并进行防御

在这个代码示例中，我们使用中介者模式实现了 PlayerA 和 PlayerB 之间的通信，使得他们之间解耦，并且更容易维护和扩展。

具体业务场景举例二

假设我们有一个聊天室系统，其中包含了多个用户和一个中介者聊天室对象，我们可以使用中介者模式来实现用户之间的聊天。

首先，我们定义一个 Mediator 协议，规范中介者的行为：

// 中介者协议
protocol Mediator {
    func sendMessage(message: String, sender: User)
}

// 用户协议
protocol User {
    var name: String { get }
    func sendMessage(message: String)
    func receiveMessage(message: String)
}

在这里，我们定义了一个 Mediator 协议和一个 User 协议，其中 Mediator 协议规定了 sendMessage() 方法，用于接收用户的消息并进行转发，而 User 协议规定了 sendMessage() 和 receiveMessage() 方法，分别用于发送和接收聊天消息。

然后，我们定义 ChatRoom 对象，实现 Mediator 协议，并在其中实现 sendMessage() 方法：

// 聊天室中介者类
class ChatRoom: Mediator {
    func sendMessage(message: String, sender: User) {
        for user in users {
            if user.name != sender.name {
                user.receiveMessage(message: message)
            }
        }
    }
    
    func addUser(user: User) {
        users.append(user)
    }
    
    var users: [User] = []
}

在 ChatRoom 中，我们维护了一个用户数组 users，用于存储所有加入到聊天室中的用户。sendMessage() 方法会遍历这个数组，并把消息发送给除了发送者本身以外的所有用户。

最后，我们定义 UserA 和 UserB 两个用户对象，分别实现 User 协议：

class UserA: User {
    var name: String
    var mediator: Mediator
    
    init(name: String, mediator: Mediator) {
        self.name = name
        self.mediator = mediator
    }
    
    func sendMessage(message: String) {
        mediator.sendMessage(message: "(name): (message)", sender: self)
    }
    
    func receiveMessage(message: String) {
        print("(name) 收到消息：(message)")
    }
}

class UserB: User {
    var name: String
    var mediator: Mediator
    
    init(name: String, mediator: Mediator) {
        self.name = name
        self.mediator = mediator
    }
    
    func sendMessage(message: String) {
        mediator.sendMessage(message: "(name): (message)", sender: self)
    }
    
    func receiveMessage(message: String) {
        print("(name) 收到消息：(message)")
    }
}

在 UserA 和 UserB 中，我们实现了 sendMessage() 方法和 receiveMessage() 方法，其中 sendMessage() 方法会调用中介者对象的 sendMessage() 方法，将用户发送的消息进行转发。

最后，我们可以在客户端代码中实例化 ChatRoom 对象和 UserA、UserB 对象，并进行聊天：

let chatRoom = ChatRoom()
let userA = UserA(name: "张三", mediator: chatRoom)
let userB = UserB(name: "李四", mediator: chatRoom)

chatRoom.addUser(user: userA)
chatRoom.addUser(user: userB)

userA.sendMessage(message: "你好")
userB.sendMessage(message: "你好")

输出结果：

李四 收到消息：张三: 你好
张三 收到消息：李四: 你好

这就是中介者设计模式