0%

设计模式-行为型模式-中介者模式

发表于 更新于 分类于

中介者模式 - 行为型模式的协调调停者

在软件设计中，中介者模式是一种行为型设计模式，它定义了一个中介者对象，该对象封装了一组对象之间的交互方式。中介者模式使得对象之间不直接相互通信，而是通过中介者对象进行协调，降低了对象之间的耦合性。本文将深入讨论中介者模式的概念、实现方式以及在实际应用中的使用场景。

中介者模式的概念

中介者模式（Mediator Pattern）是一种行为型设计模式，其核心思想是定义一个中介者对象，该对象封装了一组对象之间的交互方式。中介者模式使得对象之间不直接相互通信，而是通过中介者对象进行协调。这样的设计降低了对象之间的耦合性，使得系统更加灵活和易于维护。

中介者模式的 UML 类图

classDiagram
    class Mediator {
        + RegisterColleague(colleague: Colleague): void
        + SendMessage(colleague: Colleague, message: string): void
    }

    class Colleague {
        - mediator: Mediator
        + Send(message: string): void
        + Receive(message: string): void
    }

    class ConcreteMediator {
        - colleagues: List
        + RegisterColleague(colleague: Colleague): void
        + SendMessage(colleague: Colleague, message: string): void
    }

    class ConcreteColleagueA
    class ConcreteColleagueB

    Mediator <|.. ConcreteMediator
    Colleague <|.. ConcreteColleagueA
    Colleague <|.. ConcreteColleagueB

中介者模式的实现方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
using System;
using System.Collections.Generic;

// 抽象中介者
public interface Mediator
{
    void RegisterColleague(Colleague colleague);
    void SendMessage(Colleague colleague, string message);
}

// 抽象同事类
public abstract class Colleague
{
    protected Mediator mediator;

    public Colleague(Mediator mediator)
    {
        this.mediator = mediator;
    }

    public abstract void Send(string message);
    public abstract void Receive(string message);
}

// 具体中介者
public class ConcreteMediator : Mediator
{
    private List<Colleague> colleagues;

    public ConcreteMediator()
    {
        this.colleagues = new List<Colleague>();
    }

    public void RegisterColleague(Colleague colleague)
    {
        colleagues.Add(colleague);
    }

    public void SendMessage(Colleague colleague, string message)
    {
        foreach (var c in colleagues)
        {
            if (c != colleague)
            {
                c.Receive(message);
            }
        }
    }
}

// 具体同事类A
public class ConcreteColleagueA : Colleague
{
    public ConcreteColleagueA(Mediator mediator) : base(mediator) { }

    public override void Send(string message)
    {
        Console.WriteLine("Colleague A sends message: " + message);
        mediator.SendMessage(this, message);
    }

    public override void Receive(string message)
    {
        Console.WriteLine("Colleague A receives message: " + message);
    }
}

// 具体同事类B
public class ConcreteColleagueB : Colleague
{
    public ConcreteColleagueB(Mediator mediator) : base(mediator) { }

    public override void Send(string message)
    {
        Console.WriteLine("Colleague B sends message: " + message);
        mediator.SendMessage(this, message);
    }

    public override void Receive(string message)
    {
        Console.WriteLine("Colleague B receives message: " + message);
    }
}

中介者模式的应用场景

中介者模式适用于以下情况：

  1. 一组对象之间存在复杂的交互关系，导致它们之间的通信结构复杂难以理解。
  2. 对象之间的交互行为需要随时变化，或者需要增加新的对象时。
  3. 系统中的对象由于通信关系过于紧密，导致它们之间的耦合性较高。

中介者模式的优势

  1. 降低耦合性： 中介者模式通过将对象之间的通信集中在中介者中，降低了对象之间的耦合性。
  2. 简化对象交互： 中介者模式将对象之间的交互方式封装在中介者中，使得对象之间的通信更加简单清晰。
  3. 易于扩展： 可以通过增加新的同事类和调整中介者的实现，轻松地扩展系统。

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Program
{
    static void Main()
    {
        // 创建具体中介者对象
        ConcreteMediator mediator = new ConcreteMediator();

        // 创建具体同事类对象，并注册到中介者
        ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
        ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
        mediator.RegisterColleague(colleagueA);
        mediator.RegisterColleague(colleagueB);

        // 同事类之间通过中介者进行通信
        colleagueA.Send("Hello from Colleague A");
        colleagueB.Send("Hi from Colleague B");
    }
}

总结

中介者模式是一种行为型设计模式，通过定义一个中介者对象，封装了一组对象之间的交互方式，降低了对象之间的耦合性。中介者模式使得对象之间不直接相互通信，而是通过中介者对象进行协调。在实际应用中