行为型设计模式（四）：中介模式 & 命令模式

中介模式 Mediator

1、什么是中介模式

中介模式用于减少对象之间的直接通信，让系统可以更加松耦合。定义了一个中介者对象，该对象封装了一系列对象的交互，使得对象之间不再直接相互引用，而是通用这个中介者对象进行通信。

2、为什么使用中介模式

1. 中介模式可以减少对象之间的直接耦合，使得系统更加灵活、可维护和可扩展。
2. 中介者对象可以集中控制对象之间的交互，让系统更加清晰。

3、如何使用中介模式

设计实现一个简单的聊天室，多个用户之间可以互相发送消息，但不直接知道彼此的存在，而是通用聊天室中介者来进行消息传递

import java.util.ArrayList;
import java.util.List;

// 中介者接口
interface ChatMediator {
    void sendMessage(User sender, String message);
}

// 具体中介者
class ConcreteChatMediator implements ChatMediator {
    private List<User> users;

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

    // 添加用户到聊天室
    void addUser(User user) {
        users.add(user);
    }

    @Override
    public void sendMessage(User sender, String message) {
        for (User user : users) {
            // 排除消息发送者
            if (user != sender) {
                user.receiveMessage(message);
            }
        }
    }
}

// 抽象同事类
abstract class User {
    protected ChatMediator mediator;
    protected String name;

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

    // 发送消息
    void sendMessage(String message) {
        mediator.sendMessage(this, message);
    }

    // 接收消息
    abstract void receiveMessage(String message);
}

// 具体同事类
class ChatUser extends User {
    ChatUser(ChatMediator mediator, String name) {
        super(mediator, name);
    }

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ConcreteChatMediator mediator = new ConcreteChatMediator();

        // 创建用户并添加到聊天室
        ChatUser user1 = new ChatUser(mediator, "User1");
        ChatUser user2 = new ChatUser(mediator, "User2");
        ChatUser user3 = new ChatUser(mediator, "User3");

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

        // 用户发送消息
        user1.sendMessage("Hello, everyone!");
        user2.sendMessage("Hi there!");
    }
}

4、是否存在缺陷和不足

伴随系统的扩展，中介者对象可能会变得逐渐庞大，包含了大量的逻辑，其维护性会逐步降低。

5、如何缓解缺陷和不足

1. 如果中介者对象过于庞大，可以考虑将其分解为多个小的中介者对象，作成分布式中介者模式。
2. 可以结合命令模式，将具体的交互逻辑封装成命令对象，减轻中介者对象的负担。

命令模式 Command

1、什么是命令模式

命令模式是将请求封装为一个对象，使得可以用不同的请求参数化对象、队列化请求、以及支持可撤销的操作。命令模式将调用操作的对象和知道如何实现该操作的对象解耦。

2、为什么使用命令模式

1. 命令模式通过将请求封装成对象，解耦了调用者和接收者，使得系统更加灵活。
2. 命令模式可以支持可撤销的操作，通过保存命令的历史记录，可以实现撤销和重做的功能。

3、如何使用命令模式

设计实现一个遥控器应用，用户可以通过遥控器控制不同的电器设备

// 命令接口
interface Command {
    void execute();
}

// 具体命令1：开灯命令
class LightOnCommand implements Command {
    private Light light;

    LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOn();
    }
}

// 具体命令2：关灯命令
class LightOffCommand implements Command {
    private Light light;

    LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOff();
    }
}

// 具体命令3：打开音响命令
class StereoOnCommand implements Command {
    private Stereo stereo;

    StereoOnCommand(Stereo stereo) {
        this.stereo = stereo;
    }

    @Override
    public void execute() {
        stereo.turnOn();
    }
}

// 具体命令4：关闭音响命令
class StereoOffCommand implements Command {
    private Stereo stereo;

    StereoOffCommand(Stereo stereo) {
        this.stereo = stereo;
    }

    @Override
    public void execute() {
        stereo.turnOff();
    }
}

// 接收者1：电灯
class Light {
    void turnOn() {
        System.out.println("Light is ON");
    }

    void turnOff() {
        System.out.println("Light is OFF");
    }
}

// 接收者2：音响
class Stereo {
    void turnOn() {
        System.out.println("Stereo is ON");
    }

    void turnOff() {
        System.out.println("Stereo is OFF");
    }
}

// 调用者：遥控器
class RemoteControl {
    private Command command;

    // 设置命令
    void setCommand(Command command) {
        this.command = command;
    }

    // 执行命令
    void pressButton() {
        command.execute();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建电灯和音响
        Light light = new Light();
        Stereo stereo = new Stereo();

        // 创建命令对象
        Command lightOnCommand = new LightOnCommand(light);
        Command lightOffCommand = new LightOffCommand(light);
        Command stereoOnCommand = new StereoOnCommand(stereo);
        Command stereoOffCommand = new StereoOffCommand(stereo);

        // 创建遥控器
        RemoteControl remoteControl = new RemoteControl();

        // 设置命令并执行
        remoteControl.setCommand(lightOnCommand);
        remoteControl.pressButton();

        remoteControl.setCommand(stereoOnCommand);
        remoteControl.pressButton();

        remoteControl.setCommand(lightOffCommand);
        remoteControl.pressButton();

        remoteControl.setCommand(stereoOffCommand);
        remoteControl.pressButton();
    }
}

4、是否存在缺陷和不足

如果系统中有大量的具体命令类，可能会导致类的数量急剧增加，影响系统的可维护性。

5、如何缓解缺陷和不足

可以结合组合模式，将具体命令类组织成更加灵活的命令结构，减少具体命令类的数量。