Java设计模式之中介者模式

中介者模式（Mediator Pattern）是一种行为型设计模式，它通过封装一系列对象之间的交互，将对象之间的通信转移到一个中介者对象中，从而降低对象之间的耦合度。中介者模式通过集中控制对象之间的交互，使得对象之间的通信变得简单明确，同时也易于扩展和维护。

在中介者模式中，对象之间的通信不再直接发生，而是通过中介者对象进行调度和协调。当一个对象需要与其他对象进行交互时，它不需要直接引用其他对象，而是通过中介者对象来发送消息或者调用方法。中介者负责将消息传递给相关的对象，并协调它们的行为。

以下是一个示例，说明中介者模式的工作原理：

// 中介者接口
public interface Mediator {
    void sendMessage(String message, Colleague colleague);
}

// 具体中介者
public 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);
        }
    }
}

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

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

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

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

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

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

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

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

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

// 客户端代码
public class Client {
    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.send("Hello, colleague2!");
        colleague2.send("Hi, colleague1!");
    }
}
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

在上面的示例中，中介者模式的核心是Mediator接口和ConcreteMediator类。Mediator接口定义了中介者的方法，ConcreteMediator类实现了具体的中介者逻辑，并负责将消息传递给相关的同事对象。

Colleague是抽象同事类，定义了同事对象的基本行为，包括发送消息和接收消息的方法。ConcreteColleague1和ConcreteColleague2是具体的同事类，它们通过中介者对象来发送消息和接收消息。

在客户端代码中，创建了一个中介者对象和两个具体的同事对象。通过设置中介者对象的同事对象，建立了同事对象与中介者对象之间的关联。然后，通过调用同事对象的send方法来发送消息，中介者对象会将消息传递给相关的同事对象，并调用它们的receiveMessage方法来接收消息。

中介者模式的优点是将对象之间的通信集中管理，降低了对象之间的耦合度，使得系统更易于维护和扩展。然而，过度使用中介者模式可能导致中介者对象变得庞大复杂，降低了系统的性能和可维护性，因此在使用中介者模式时需要权衡利弊。