中介者模式在Java中的实现：设计模式精解

中介者模式在Java中的实现：设计模式精解

中介者模式（Mediator Pattern）是一种行为型设计模式，用于定义一个中介者对象，以封装一系列对象之间的交互，从而使对象之间的交互不再直接发生，减少了系统中的耦合度。中介者模式适用于对象之间的交互复杂的场景，使得各个对象之间的协作变得更加简单和清晰。

本文将详细解析中介者模式在Java中的实现，介绍其结构、优缺点，并通过具体的代码示例展示如何在Java中使用中介者模式。

---

1. 中介者模式的基本概念

中介者模式的核心思想是将多个对象之间的复杂交互集中到一个中介者对象中，从而使得对象之间不再直接通信，降低系统的耦合度。这样，当系统中需要增加或修改对象时，只需要修改中介者对象的逻辑，而不需要修改其他对象。

1.1 中介者模式的主要角色

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

1.2 中介者模式的UML类图

+------------------+
|    Mediator      |
+------------------+
| +mediate()       |
+------------------+
        ^
        |
        |
+------------------+    +------------------+
| ConcreteMediator |    | ConcreteMediator |
+------------------+    +------------------+
| -colleague1      |    | -colleague2      |
| -colleague2      |    | -colleague2      |
| +mediate()       |    | +mediate()       |
+------------------+    +------------------+
   ^            ^
   |            |
   |            |
+------------------+    +------------------+
| ConcreteColleague|    | ConcreteColleague|
|      1          |    |      2          |
+------------------+    +------------------+
| -mediator        |    | -mediator        |
| +operation()     |    | +operation()     |
+------------------+    +------------------+

2. 中介者模式的实现

2.1 示例：聊天室

假设我们正在实现一个聊天室，其中多个用户通过一个聊天室中介者进行消息的发送和接收。每个用户对象都可以发送和接收消息，但它们之间的直接通信将通过中介者对象来完成。

2.1.1 中介者接口

// Mediator Interface
public interface ChatRoomMediator {
    void sendMessage(String message, User user);
    void addUser(User user);
}

2.1.2 具体中介者

// ConcreteMediator
import java.util.ArrayList;
import java.util.List;

public class ChatRoom implements ChatRoomMediator {
    private List<User> users;

    public ChatRoom() {
        this.users = new ArrayList<>();
    }

    @Override
    public void sendMessage(String message, User user) {
        for (User u : users) {
            // Message should not be sent to the user who sent it
            if (u != user) {
                u.receiveMessage(message);
            }
        }
    }

    @Override
    public void addUser(User user) {
        this.users.add(user);
    }
}

2.1.3 同事接口

// Colleague Interface
public abstract class User {
    protected ChatRoomMediator mediator;
    protected String name;

    public User(ChatRoomMediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }

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

2.1.4 具体同事

// ConcreteColleague1
public class ConcreteUser extends User {

    public ConcreteUser(ChatRoomMediator mediator, String name) {
        super(mediator, name);
    }

    @Override
    public void sendMessage(String message) {
        System.out.println(this.name + " sends: " + message);
        mediator.sendMessage(message, this);
    }

    @Override
    public void receiveMessage(String message) {
        System.out.println(this.name + " receives: " + message);
    }
}

2.1.5 主类

// Main class to demonstrate
public class Main {
    public static void main(String[] args) {
        ChatRoomMediator mediator = new ChatRoom();
        
        User user1 = new ConcreteUser(mediator, "Alice");
        User user2 = new ConcreteUser(mediator, "Bob");
        User user3 = new ConcreteUser(mediator, "Charlie");

        mediator.addUser(user1);
        mediator.addUser(user2);
        mediator.addUser(user3);

        user1.sendMessage("Hello, everyone!");
        user2.sendMessage("Hi Alice!");
    }
}

2.2 示例：订单处理系统

假设我们正在实现一个订单处理系统，其中订单的处理涉及到多个步骤，如验证、支付、发货等。每个步骤都通过一个处理器对象进行处理，而这些处理器对象通过一个中介者对象来协调工作。

2.2.1 中介者接口

// Mediator Interface
public interface OrderMediator {
    void processOrder();
    void setOrder(Order order);
    void setPayment(Payment payment);
    void setShipping(Shipping shipping);
}

2.2.2 具体中介者

// ConcreteMediator
public class OrderProcessingMediator implements OrderMediator {
    private Order order;
    private Payment payment;
    private Shipping shipping;

    @Override
    public void processOrder() {
        if (order != null && payment != null && shipping != null) {
            order.process();
            payment.process();
            shipping.process();
        } else {
            System.out.println("Order, payment or shipping is missing.");
        }
    }

    @Override
    public void setOrder(Order order) {
        this.order = order;
    }

    @Override
    public void setPayment(Payment payment) {
        this.payment = payment;
    }

    @Override
    public void setShipping(Shipping shipping) {
        this.shipping = shipping;
    }
}

2.2.3 同事接口

// Colleague Interface
public interface OrderProcessComponent {
    void process();
}

2.2.4 具体同事

// ConcreteColleague1
public class Order implements OrderProcessComponent {
    @Override
    public void process() {
        System.out.println("Processing order.");
    }
}

// ConcreteColleague2
public class Payment implements OrderProcessComponent {
    @Override
    public void process() {
        System.out.println("Processing payment.");
    }
}

// ConcreteColleague3
public class Shipping implements OrderProcessComponent {
    @Override
    public void process() {
        System.out.println("Processing shipping.");
    }
}

2.2.5 主类

// Main class to demonstrate
public class Main {
    public static void main(String[] args) {
        OrderProcessingMediator mediator = new OrderProcessingMediator();

        Order order = new Order();
        Payment payment = new Payment();
        Shipping shipping = new Shipping();

        mediator.setOrder(order);
        mediator.setPayment(payment);
        mediator.setShipping(shipping);

        mediator.processOrder();
    }
}

---

3. 中介者模式的优缺点

3.1 优点

• 降低耦合度：通过将对象间的交互集中到中介者对象中，各个对象之间不再直接通信，从而降低了系统的耦合度。
• 集中控制：所有对象间的交互逻辑集中在中介者中，便于管理和修改。
• 提高灵活性：可以在不修改同事对象的情况下，修改中介者的交互逻辑，增加新的功能或修复问题。

3.2 缺点

• 中介者复杂化：中介者对象可能变得过于复杂，尤其是在处理复杂的对象交互时。
• 单点故障：中介者可能成为系统中的瓶颈或单点故障点，一旦中介者出现问题，所有对象的交互都会受到影响。

---

4. 实践建议

• 使用场景：中介者模式适用于需要处理复杂交互的场景，尤其是当对象之间的交互逻辑比较复杂时。
• 注意复杂度：在使用中介者模式时，需要注意中介者的复杂度，尽量避免中介者变得过于庞大，可以考虑将其拆分为多个中介者。
• 结合其他模式：中介者模式可以与其他设计模式结合使用，例如与观察者模式结合，用于处理复杂的事件通知机制。

---

5. 总结

中介者模式是一种有效

的行为型设计模式，通过将对象之间的交互集中到中介者对象中，降低了系统的耦合度，提高了系统的灵活性和可维护性。通过具体的Java代码示例，本文展示了中介者模式在实际开发中的应用，并介绍了中介者模式的优缺点和实践建议。希望这些内容能帮助你更好地理解和应用中介者模式，在实际开发中提升系统的设计质量。