命令模式：把请求封装成对象的神操作[特殊字符]，解耦调用者与接收者的终极方案！

发布于：2025-06-28 ⋅ 阅读:(17) ⋅ 点赞:(0)

命令模式：把请求封装成对象的神操作🚀，解耦调用者与接收者的终极方案！

文章目录

前言：为什么需要命令模式？🤔

各位宝子们，今天我们来聊一个设计模式界的"中间人"——命令模式！😎 还在为调用者和接收者之间的强耦合而头疼吗？还在为请求的排队、记录、撤销操作而烦恼吗？命令模式来拯救你啦！

命令模式是设计模式家族中的"行为型选手"，它能帮我们将请求封装成对象，让你能够使用不同的请求参数化客户端，并且支持请求排队、记录日志、撤销操作等高级功能。今天就带大家彻底搞懂这个"看似复杂，实则实用"的设计模式！💯

一、命令模式：请求的封装大师 📦

1.1 什么是命令模式？

命令模式（Command Pattern）是一种行为型设计模式，它将请求封装成一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。就像现实生活中的遥控器一样，你按下按钮（命令），电视就会执行相应的操作，而你不需要知道电视内部是如何工作的！📺

1.2 为什么需要命令模式？

想象一下这些场景：

  • 需要将发出请求的对象与执行请求的对象解耦
  • 需要在不同的时刻指定、排列和执行请求
  • 需要支持取消、恢复等操作
  • 需要将一组操作组合成原子操作（事务）
  • 需要支持日志记录，以便在系统崩溃时能够重新执行操作

这些场景有什么共同点？它们都涉及到请求的封装和管理。命令模式就是为这些场景量身定制的！🚀

二、命令模式的结构：角色分明的团队合作 👥

命令模式包含以下几个角色：

  • 命令（Command）：声明执行操作的接口
  • 具体命令（ConcreteCommand）：实现命令接口，定义绑定接收者和动作的关系
  • 调用者（Invoker）：要求命令执行请求
  • 接收者（Receiver）：知道如何实施与执行一个请求相关的操作
  • 客户端（Client）：创建具体命令对象并设定接收者
// 接收者：知道如何执行与请求相关的操作
public class Light {
    public void turnOn() {
        System.out.println("灯已打开！💡");
    }
    
    public void turnOff() {
        System.out.println("灯已关闭！🌑");
    }
}

// 命令接口：所有具体命令都必须实现的接口
public interface Command {
    void execute();
    void undo(); // 支持撤销操作
}

// 具体命令：开灯命令
public class LightOnCommand implements Command {
    private Light light;
    
    public LightOnCommand(Light light) {
        this.light = light;
    }
    
    @Override
    public void execute() {
        light.turnOn();
    }
    
    @Override
    public void undo() {
        light.turnOff();
    }
}

// 具体命令：关灯命令
public class LightOffCommand implements Command {
    private Light light;
    
    public LightOffCommand(Light light) {
        this.light = light;
    }
    
    @Override
    public void execute() {
        light.turnOff();
    }
    
    @Override
    public void undo() {
        light.turnOn();
    }
}

// 调用者：遥控器
public class RemoteControl {
    private Command command;
    private Command lastCommand; // 记录上一次执行的命令，用于撤销
    
    public void setCommand(Command command) {
        this.command = command;
    }
    
    public void pressButton() {
        command.execute();
        lastCommand = command;
    }
    
    public void pressUndoButton() {
        if (lastCommand != null) {
            lastCommand.undo();
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建接收者
        Light light = new Light();
        
        // 创建具体命令对象，并绑定接收者
        Command lightOn = new LightOnCommand(light);
        Command lightOff = new LightOffCommand(light);
        
        // 创建调用者
        RemoteControl remote = new RemoteControl();
        
        // 执行开灯命令
        remote.setCommand(lightOn);
        remote.pressButton(); // 输出：灯已打开！💡
        
        // 执行关灯命令
        remote.setCommand(lightOff);
        remote.pressButton(); // 输出：灯已关闭！🌑
        
        // 撤销上一次操作（关灯）
        remote.pressUndoButton(); // 输出：灯已打开！💡
    }
}

看到了吗？通过命令模式，我们实现了调用者（遥控器）和接收者（灯）的解耦！遥控器不需要知道它控制的是什么设备，它只需要知道按下按钮时要执行什么命令。这就像你使用电视遥控器时，不需要知道电视内部的电路是如何工作的！📱✨

三、命令模式实战：实际应用场景 💼

3.1 GUI按钮和菜单项

在图形用户界面中，按钮和菜单项是命令模式的典型应用。当用户点击按钮或选择菜单项时，会触发相应的命令执行。

// Swing中的ActionListener就是一种命令模式的应用
JButton saveButton = new JButton("保存");
saveButton.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // 执行保存命令
        document.save();
    }
});

3.2 多级撤销功能

命令模式非常适合实现撤销（Undo）和重做（Redo）功能，这在文本编辑器、图形编辑器等应用中非常常见。

public class TextEditor {
    private Stack<Command> undoStack = new Stack<>();
    private Stack<Command> redoStack = new Stack<>();
    
    public void executeCommand(Command command) {
        command.execute();
        undoStack.push(command);
        redoStack.clear(); // 执行新命令后，清空重做栈
    }
    
    public void undo() {
        if (!undoStack.isEmpty()) {
            Command command = undoStack.pop();
            command.undo();
            redoStack.push(command);
        }
    }
    
    public void redo() {
        if (!redoStack.isEmpty()) {
            Command command = redoStack.pop();
            command.execute();
            undoStack.push(command);
        }
    }
}

3.3 宏命令（组合命令）

命令模式还可以用来实现宏命令，即一次执行多个命令。

public class MacroCommand implements Command {
    private List<Command> commands = new ArrayList<>();
    
    public void addCommand(Command command) {
        commands.add(command);
    }
    
    @Override
    public void execute() {
        for (Command command : commands) {
            command.execute();
        }
    }
    
    @Override
    public void undo() {
        // 逆序撤销所有命令
        for (int i = commands.size() - 1; i >= 0; i--) {
            commands.get(i).undo();
        }
    }
}

// 客户端代码
Light light = new Light();
TV tv = new TV();
Stereo stereo = new Stereo();

Command lightOn = new LightOnCommand(light);
Command tvOn = new TVOnCommand(tv);
Command stereoOn = new StereoOnCommand(stereo);

MacroCommand allOn = new MacroCommand();
allOn.addCommand(lightOn);
allOn.addCommand(tvOn);
allOn.addCommand(stereoOn);

RemoteControl remote = new RemoteControl();
remote.setCommand(allOn);

// 一键启动所有设备
remote.pressButton();
// 输出：
// 灯已打开！💡
// 电视已打开！📺
// 音响已打开！🔊

四、命令模式在Java标准库中的应用 📚

4.1 Java的Runnable接口

Java中的Runnable接口就是命令模式的一种应用。Runnable对象封装了一个要执行的命令，可以传递给Thread对象执行。

// Runnable就是一个命令接口
Runnable command = new Runnable() {
    @Override
    public void run() {
        System.out.println("执行命令...");
    }
};

// Thread是调用者
Thread thread = new Thread(command);
thread.start();

4.2 Swing的Action接口

Java Swing中的Action接口也是命令模式的应用，它封装了一个命令及其相关属性（如名称、图标等）。

Action saveAction = new AbstractAction("保存", saveIcon) {
    @Override
    public void actionPerformed(ActionEvent e) {
        document.save();
    }
};

// 可以将同一个Action绑定到不同的UI组件
JButton saveButton = new JButton(saveAction);
JMenuItem saveMenuItem = new JMenuItem(saveAction);

4.3 Java的Executor框架

Java的Executor框架也使用了命令模式。Executor接口定义了一个执行命令的方法，而ExecutorService提供了更多的功能，如线程池管理、异步执行等。

ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交命令给执行器
executor.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("任务1执行中...");
    }
});

// 提交带返回值的命令
Future<String> future = executor.submit(new Callable<String>() {
    @Override
    public String call() throws Exception {
        return "任务2执行结果";
    }
});

// 获取结果
try {
    String result = future.get();
    System.out.println(result);
} catch (Exception e) {
    e.printStackTrace();
}

// 关闭执行器
executor.shutdown();

五、命令模式的优缺点与适用场景 ⚖️

5.1 优点

  • 解耦调用者和接收者：命令模式将发出命令的对象与执行命令的对象解耦
  • 可扩展性好：可以方便地增加新的命令，而不需要修改现有代码
  • 支持撤销和重做：命令对象可以保存状态，支持撤销和重做操作
  • 支持组合命令：可以将多个命令组合成一个命令（宏命令）
  • 支持命令队列和日志：命令可以排队执行，也可以记录日志，支持事务和恢复

5.2 缺点

  • 类数量增加：每个命令都需要一个单独的类，可能导致类的数量增加
  • 复杂度增加：引入了新的抽象层，增加了系统的复杂度

5.3 适用场景

  • 需要将请求发送者和接收者解耦：当你需要将发出请求的对象与执行请求的对象解耦时
  • 需要参数化对象：当你需要使用不同的请求参数化对象时
  • 需要支持撤销操作：当你需要支持撤销、重做等操作时
  • 需要支持事务：当你需要将一组操作作为一个整体执行，要么全部执行，要么全部不执行时
  • 需要支持日志和恢复：当你需要记录操作日志，以便在系统崩溃时能够恢复操作时

六、命令模式与其他模式的对比 🔄

6.1 命令模式 vs 策略模式

  • 命令模式：封装要执行的操作，关注的是请求的发送者和接收者之间的解耦
  • 策略模式：封装算法族，关注的是算法的可替换性

6.2 命令模式 vs 装饰器模式

  • 命令模式：将请求封装成对象，关注的是请求的发送和执行
  • 装饰器模式：动态地给对象添加新功能，关注的是对象功能的扩展

6.3 命令模式 vs 状态模式

  • 命令模式：封装请求，关注的是请求的发送和执行
  • 状态模式：封装状态相关的行为，关注的是对象状态的变化

七、命令模式的最佳实践 🌟

  1. 保持命令简单：每个命令应该只做一件事，遵循单一职责原则
  2. 使用命令队列：对于需要按顺序执行的命令，可以使用命令队列
  3. 考虑命令的生命周期：在某些情况下，命令对象可能需要长时间存在，如支持撤销操作
  4. 使用宏命令：对于需要一起执行的多个命令，可以使用宏命令
  5. 结合其他模式：命令模式可以与其他模式结合使用，如工厂模式创建命令对象

总结：命令模式，请求封装的艺术 🎯

命令模式是一种强大的行为型设计模式，它将请求封装成对象，使得请求的发送者和接收者解耦，同时支持请求的排队执行、记录日志、撤销操作等高级功能。

在实际开发中，当你需要将请求的发送者和接收者解耦，或者需要支持撤销、重做、日志记录等功能时，命令模式是一个非常好的选择！记住，好的设计模式就像好的工具一样，用在对的地方才能发挥最大的作用！🌈

下次当你需要处理请求时，先问问自己：“我是应该直接调用方法，还是应该使用命令模式呢？” 如果你需要解耦、参数化、撤销或日志记录等功能，那么命令模式可能是更好的选择！💪

希望这篇文章对你理解命令模式有所帮助！如果有任何问题，欢迎在评论区留言讨论！👇

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布