Java设计模式之中介者模式

概念

中介者模式是一种行为型设计模式，它用一个中介对象来封装一系列对象之间的交互方式，使得对象之间不必相互显式引用，从而降低它们之间的耦合度。

中介者模式的原理

在中介者模式中，多个对象通过一个中介者对象进行通信，不再直接相互依赖。中介者对象负责分发任意一个对象发送的消息到相关的对象，实现对象之间的松散耦合。

中介者模式的结构

1. 中介者接口（Mediator）：定义了同事对象（Colleague）与中介者对象通信的方法。

2. 具体中介者（ConcreteMediator）：实现中介者接口，协调各个同事对象之间的交互。

3. 同事类（Colleague）：各个具体同事类，通过中介者与其他同事通信，不再直接与其他同事类交互。

中介者模式的案例-详细用法

假设我们有一个聊天应用，其中用户可以通过聊天室进行消息传递。这里，聊天室就是中介者。

// 中介者接口
interface ChatRoomMediator {
    void showMessage(User user, String message);
}

// 具体中介者
class ChatRoom implements ChatRoomMediator {
    @Override
    public void showMessage(User user, String message) {
        System.out.println(user.getName() + ": " + message);
    }
}

// 同事类
abstract class User {
    protected ChatRoomMediator mediator;
    protected String name;

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

    public abstract void send(String message);

    public String getName() {
        return name;
    }
}

// 具体同事类
class ChatUser extends User {

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

    @Override
    public void send(String message) {
        System.out.println(this.name + " 发送消息: " + message);
        mediator.showMessage(this, message);
    }
}

// 客户端代码
public class MediatorPatternDemo {
    public static void main(String[] args) {
        ChatRoomMediator chatRoom = new ChatRoom();
        
        User user1 = new ChatUser(chatRoom, "Alice");
        User user2 = new ChatUser(chatRoom, "Bob");
        
        user1.send("你好，Bob!");
        user2.send("你好，Alice!");
    }
}

中介者模式的案例-详细用法

为了提供一个具体的中介者模式案例，我们可以使用一个机场航班调度系统作为例子。假设我们有多个航班和一个控制塔，它们通过控制塔来协调彼此之间的操作，从而避免直接彼此通讯。

案例：机场航班调度系统

设计

• 中介者接口（ControlTowerMediator）：定义航班与控制塔之间的通信方法。

• 具体中介者（ControlTower）：实现中介者接口，协调航班的起降和停机。

• 同事类（Flight）：表示航班，通过中介者与其他航班通信。

• 具体同事类（具体航班）：实现具体的航班逻辑。

// 中介者接口
interface ControlTowerMediator {
    void registerFlight(Flight flight);
    boolean canLand(Flight flight);
    void notifyDeparture(Flight flight);
}

// 具体中介者
class ControlTower implements ControlTowerMediator {
    private List<Flight> flights;

    public ControlTower() {
        flights = new ArrayList<>();
    }

    @Override
    public void registerFlight(Flight flight) {
        flights.add(flight);
    }

    @Override
    public boolean canLand(Flight flight) {
        // 简单的逻辑示例：检查是否有跑道空闲
        return !flights.contains(flight);
    }

    @Override
    public void notifyDeparture(Flight flight) {
        flights.remove(flight);
        System.out.println("航班 " + flight.getFlightNumber() + " 已离开。");
    }
}

// 同事类
abstract class Flight {
    protected ControlTowerMediator controlTower;
    protected String flightNumber;

    public Flight(ControlTowerMediator controlTower, String flightNumber) {
        this.controlTower = controlTower;
        this.flightNumber = flightNumber;
    }

    public abstract void land();
    public abstract void depart();

    public String getFlightNumber() {
        return flightNumber;
    }
}

// 具体同事类
class CommercialFlight extends Flight {

    public CommercialFlight(ControlTowerMediator controlTower, String flightNumber) {
        super(controlTower, flightNumber);
    }

    @Override
    public void land() {
        if (controlTower.canLand(this)) {
            System.out.println("航班 " + this.flightNumber + " 正在降落。");
            controlTower.registerFlight(this);
        } else {
            System.out.println("航班 " + this.flightNumber + " 无法降落，目前跑道忙碌。");
        }
    }

    @Override
    public void depart() {
        System.out.println("航班 " + this.flightNumber + " 正在起飞。");
        controlTower.notifyDeparture(this);
    }
}

// 客户端代码
public class MediatorPatternAirportDemo {
    public static void main(String[] args) {
        ControlTowerMediator controlTower = new ControlTower();
        
        Flight flight1 = new CommercialFlight(controlTower, "A123");
        Flight flight2 = new CommercialFlight(controlTower, "B456");
        
        flight1.land();
        flight2.land();
        
        flight1.depart();
        
        flight2.land();
    }
}

解释

1. ControlTower：作为中介者，实现航班的注册和起降协调。

2. Flight：抽象类，定义了航班的基本操作。

3. CommercialFlight：具体的航班实现，通过中介者进行起降操作。

4. 客户端代码：模拟多个航班的降落和起飞过程，通过控制塔统一管理。

这种方式简化了多个航班之间的直接通信，控制塔（中介者）负责管理所有的飞行操作逻辑，确保航班安全有序地进出机场。

使用场景

1. 复杂通信逻辑：当一组对象之间存在复杂的通信逻辑时，可以通过中介者简化。
2. 解耦对象：需要降低多个对象之间的耦合度时，可以引入中介者来控制交互。

优点

• 松散耦合：各个对象只依赖中介者，减少直接关联。
• 集中控制交互：把复杂的交互逻辑统一在中介者中处理。

缺点

• 中介者会变得复杂：随着交互逻辑的增加，中介者可能变得难以维护。