深入理解Java中介者模式：从基础到高级应用

深入理解Java中介者模式：从基础到高级应用

1. 什么是中介者模式？

中介者模式（Mediator Pattern）是一种行为型设计模式，旨在通过定义一个中介者对象来封装一系列对象之间的交互，从而使这些对象之间的通信不再直接发生，降低它们之间的耦合度。中介者模式通过将对象间的复杂通信封装到一个中介者对象中，使得各对象之间的交互变得简单、灵活和可维护。

2. 中介者模式的结构

中介者模式主要涉及以下几个角色：

• Mediator（中介者接口）：定义了与各个Colleague（同事）对象之间交互的接口。
• ConcreteMediator（具体中介者）：实现Mediator接口，负责协调各个Colleague对象之间的通信和协作。
• Colleague（同事接口）：定义了中介者和各个具体同事对象的接口。
• ConcreteColleague（具体同事）：实现Colleague接口，与ConcreteMediator进行交互。

3. 中介者模式的UML图

下面是中介者模式的UML类图示例：

+------------------+
|    Mediator      |
+------------------+
| +mediate()       |
+------------------+
        ^
        |
        |
+------------------+
| ConcreteMediator |
+------------------+
| -colleague1      |
| -colleague2      |
| +mediate()       |
+------------------+
   ^            ^
   |            |
   |            |
+------------------+    +------------------+
| ConcreteColleague1|    | ConcreteColleague2|
+------------------+    +------------------+
| -mediator        |    | -mediator        |
| +operation()     |    | +operation()     |
+------------------+    +------------------+

4. 中介者模式的核心概念

• 解耦：中介者模式通过引入中介者对象，使得对象之间不直接交互，降低了对象间的耦合度。
• 集中控制：所有的交互和协作逻辑都集中在中介者对象中，方便维护和扩展。
• 灵活性：当系统中需要增加或修改对象时，只需要修改中介者对象的逻辑，而不需要修改其他对象。

5. Java中介者模式的实现

5.1 基础示例

让我们从一个简单的示例开始，假设我们有两个同事对象，它们需要通过一个中介者对象进行通信。

// Mediator Interface
public interface Mediator {
    void mediate();
}

// ConcreteMediator
public class ConcreteMediator implements Mediator {
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;

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

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

    @Override
    public void mediate() {
        colleague1.operation();
        colleague2.operation();
    }
}

// Colleague1 Interface
public interface Colleague {
    void setMediator(Mediator mediator);
    void operation();
}

// ConcreteColleague1
public class ConcreteColleague1 implements Colleague {
    private Mediator mediator;

    @Override
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void operation() {
        System.out.println("ConcreteColleague1 operation.");
    }
}

// ConcreteColleague2
public class ConcreteColleague2 implements Colleague {
    private Mediator mediator;

    @Override
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void operation() {
        System.out.println("ConcreteColleague2 operation.");
    }
}

// Main class to demonstrate
public class Main {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        ConcreteColleague1 colleague1 = new ConcreteColleague1();
        ConcreteColleague2 colleague2 = new ConcreteColleague2();

        colleague1.setMediator(mediator);
        colleague2.setMediator(mediator);

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

        mediator.mediate();
    }
}

5.2 高级应用

在实际应用中，中介者模式可以用于复杂的系统中，例如GUI系统的事件处理。下面是一个GUI事件处理的例子，其中按钮和文本框通过一个中介者对象进行交互：

// Mediator Interface
public interface Mediator {
    void buttonPressed();
    void textChanged();
}

// ConcreteMediator
public class GUIChatMediator implements Mediator {
    private Button button;
    private TextBox textBox;

    public void setButton(Button button) {
        this.button = button;
    }

    public void setTextBox(TextBox textBox) {
        this.textBox = textBox;
    }

    @Override
    public void buttonPressed() {
        textBox.setText("Button was pressed");
    }

    @Override
    public void textChanged() {
        button.setEnabled(!textBox.getText().isEmpty());
    }
}

// Button
public class Button {
    private Mediator mediator;
    private boolean enabled = true;

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

    public void press() {
        mediator.buttonPressed();
    }

    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
        System.out.println("Button enabled: " + enabled);
    }
}

// TextBox
public class TextBox {
    private Mediator mediator;
    private String text = "";

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

    public void setText(String text) {
        this.text = text;
        mediator.textChanged();
    }

    public String getText() {
        return text;
    }
}

// Main class to demonstrate
public class Main {
    public static void main(String[] args) {
        GUIChatMediator mediator = new GUIChatMediator();
        Button button = new Button(mediator);
        TextBox textBox = new TextBox(mediator);

        mediator.setButton(button);
        mediator.setTextBox(textBox);

        textBox.setText("Hello");
        button.press();
    }
}

6. 中介者模式的优缺点

优点

• 降低耦合度：通过引入中介者对象，各个同事对象不需要直接互相交互，从而降低了耦合度。
• 集中控制：所有对象间的交互逻辑集中在中介者中，便于维护和修改。
• 增强灵活性：可以在不改变同事对象的情况下，改变中介者的交互逻辑。

缺点

• 单点故障：中介者对象的复杂度可能会导致成为系统中的瓶颈或单点故障。
• 增加复杂性：对于简单的交互场景，引入中介者可能会增加不必要的复杂性。

7. 使用中介者模式的场景

中介者模式适用于以下场景：

• 复杂的对象交互：当系统中对象之间的交互变得复杂时，可以使用中介者模式来简化这些交互。
• 解耦：需要将对象之间的依赖关系解耦，以便于独立修改和维护时。
• 集中控制：希望将所有的交互逻辑集中到一个对象中进行管理。

8. 结论

中介者模式是一种强大且灵活的设计模式，可以有效地减少对象之间的耦合度，集中管理对象间的交互。然而，在使用中介者模式时，也需要注意避免中介者成为单点故障，并在适当的场景下使用该模式以保持系统的简单性和可维护性。通过本文的示例代码和讲解，希望你对Java中的中介者模式有了深入的理解，并能够在实际项目中有效地应用这一模式。