小谈设计模式（26）—中介者模式

专栏介绍

专栏地址

http://t.csdnimg.cn/VpriY

专栏介绍

主要对目前市面上常见的23种设计模式进行逐一分析和总结，希望有兴趣的小伙伴们可以看一下，会持续更新的。希望各位可以监督我，我们一起学习进步，加油，各位。

中介者模式

中介者模式（Mediator Pattern）是一种行为型设计模式，它通过将对象之间的通信封装到一个中介者对象中，从而实现对象之间的松耦合。中介者模式可以减少对象之间的直接依赖，提高系统的灵活性和可维护性。

分析

在中介者模式中，存在一个中介者对象，它封装了对象之间的通信逻辑。对象之间的通信不再直接发生，而是通过中介者对象进行。当一个对象需要与其他对象进行通信时，它不需要知道其他对象的具体细节，只需要与中介者进行交互即可。

角色分析

抽象中介者（Mediator）

定义了中介者对象的接口，它通常包含一个或多个抽象的通信方法，用于定义对象之间的通信规则。

具体中介者（ConcreteMediator）

实现了抽象中介者的接口，它通过协调各个同事对象来实现协作行为。

抽象同事类（Colleague）

定义了同事对象的接口，它通常包含一个中介者对象的引用，用于与中介者进行通信。

具体同事类（ConcreteColleague）

实现了抽象同事类的接口，它与其他同事对象通过中介者进行通信。

工作过程

各个同事对象将自己的引用传递给中介者对象，以便中介者对象能够与各个同事对象进行通信。
当一个同事对象需要与其他同事对象进行通信时，它将请求发送给中介者对象。
中介者对象接收到请求后，根据通信规则进行相应的处理，并将请求转发给目标同事对象。
目标同事对象接收到请求后，进行相应的处理。

优缺点分析

优点分析

1

减少了对象之间的直接依赖，提高了系统的灵活性和可维护性。

2

将对象之间的通信集中到一个中介者对象中，使得系统结构更加清晰。

缺点分析

1

中介者对象将承担较多的责任，可能会变得复杂。

2

如果中介者对象存在过多的逻辑，可能会影响系统的性能。

适用场景

1

当对象之间存在复杂的通信逻辑时，可以使用中介者模式将通信逻辑集中到一个中介者对象中。

2

当对象之间的通信关系呈现网状结构时，可以使用中介者模式将通信关系简化为星型结构。

Java程序分析

// 抽象中介者
interface Mediator {
    void sendMessage(String message, Colleague colleague);
}

// 具体中介者
class ConcreteMediator implements Mediator {
    private Colleague colleague1;
    private Colleague colleague2;

    public void setColleague1(Colleague colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(Colleague colleague2) {
        this.colleague2 = colleague2;
    }

    @Override
    public void sendMessage(String message, Colleague colleague) {
        if (colleague == colleague1) {
            colleague2.receiveMessage(message);
        } else if (colleague == colleague2) {
            colleague1.receiveMessage(message);
        }
    }
}

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

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

    public abstract void sendMessage(String message);
    public abstract void receiveMessage(String message);
}

// 具体同事类
class ConcreteColleague1 extends Colleague {
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage(String message) {
        mediator.sendMessage(message, this);
    }

    @Override
    public void receiveMessage(String message) {
        System.out.println("ConcreteColleague1 received message: " + message);
    }
}

// 具体同事类
class ConcreteColleague2 extends Colleague {
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage(String message) {
        mediator.sendMessage(message, this);
    }

    @Override
    public void receiveMessage(String message) {
        System.out.println("ConcreteColleague2 received message: " + message);
    }
}

// 测试类
public class MediatorPatternExample {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();

        ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);

        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        colleague1.sendMessage("Hello from colleague1");
        colleague2.sendMessage("Hi from colleague2");
    }
}
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
85
86
87
88
89

分析

1

在上述示例中，Mediator是抽象中介者接口，定义了中介者对象的通信方法。ConcreteMediator是具体中介者类，实现了抽象中介者接口，并通过协调各个同事对象来实现协作行为。

2

Colleague是抽象同事类，定义了同事对象的接口，并包含一个中介者对象的引用，用于与中介者进行通信。ConcreteColleague1和ConcreteColleague2是具体同事类，分别实现了抽象同事类的接口。

3

在测试类MediatorPatternExample中，创建了具体中介者对象和具体同事对象，并将同事对象的引用传递给中介者对象。然后，通过同事对象调用sendMessage方法发送消息，中介者对象根据通信规则进行处理，并将消息转发给目标同事对象。最后，目标同事对象接收到消息并进行处理。

输出结果

ConcreteColleague2 received message: Hello from colleague1
ConcreteColleague1 received message: Hi from colleague2
以上示例演示了中介者模式的基本实现，通过中介者对象实现了对象之间的松耦合，实现了对象之间的通信。
1
2
3

总结

总结起来，中介者模式通过将对象之间的通信封装到一个中介者对象中，实现了对象之间的松耦合。它可以减少对象之间的直接依赖，提高系统的灵活性和可维护性。中介者模式适用于对象之间存在复杂的通信逻辑或通信关系呈现网状结构的场景。