一、模式本质：将请求转化为对象

命令模式（Command Pattern）作为行为型设计模式的典型代表，其核心思想在于将请求操作封装为独立的对象，使得系统能够以统一的方式处理不同类型的请求。这种设计解耦了请求的发送者（Invoker）与执行者（Receiver），通过中间层（Command）实现灵活的请求调度与控制。

1.1 传统请求处理的问题

在传统面向对象设计中，请求发送者通常直接调用接收者的方法，例如：

// 传统调用方式
Light light = new Light();
Switch switchButton = new Switch();
switchButton.turnOn(light); // 直接耦合

这种强耦合设计导致三个核心问题：

扩展性差：新增请求类型需修改发送者代码
可测试性低：难以模拟不同请求场景
功能复用难：请求的撤销、重做等高级功能难以实现

1.2 命令模式的结构解耦

通过引入命令对象作为中间层，系统架构演变为：

// 命令接口定义
interface Command {
    void execute();
}
// 具体命令实现
class LightOnCommand implements Command {
    private Light light;
    public LightOnCommand(Light light) {
        this.light = light;
    }
    @Override
    public void execute() {
        light.turnOn();
    }
}
// 发送者调用
Command command = new LightOnCommand(new Light());
Invoker invoker = new Invoker(command);
invoker.executeCommand(); // 间接调用

这种设计实现了：

发送者与接收者解耦：Invoker仅依赖Command接口
请求对象化：可将命令序列化、持久化
动态组合：支持宏命令等复杂场景

二、核心实现：命令对象的生命周期管理

完整的命令模式实现需关注四个关键组件的设计：

2.1 命令接口设计

基础接口应包含执行方法，根据需求可扩展：

interface Command {
    void execute();       // 执行命令
    void undo();          // 撤销操作（可选）
    boolean isComplete(); // 状态跟踪（可选）
}

2.2 具体命令实现

每个具体命令封装特定业务逻辑：

class CeilingFanHighCommand implements Command {
    private CeilingFan fan;
    private int prevSpeed;
    public CeilingFanHighCommand(CeilingFan fan) {
        this.fan = fan;
    }
    @Override
    public void execute() {
        prevSpeed = fan.getSpeed();
        fan.high();
    }
    @Override
    public void undo() {
        switch(prevSpeed) {
            case 1: fan.low(); break;
            case 2: fan.medium(); break;
            default: fan.off();
        }
    }
}

2.3 空命令模式

处理空操作场景，避免空指针异常：

class NoCommand implements Command {
    @Override
    public void execute() {}
    @Override
    public void undo() {}
}

2.4 命令队列实现

通过队列实现请求的异步处理：

class CommandQueue {
    private Queue<Command> queue = new LinkedList<>();
    public void addCommand(Command cmd) {
        queue.offer(cmd);
    }
    public void executeAll() {
        while(!queue.isEmpty()) {
            queue.poll().execute();
        }
    }
}

三、典型应用场景分析

命令模式在以下场景展现独特价值：

3.1 请求队列与批处理

某智能家居系统通过命令队列实现设备控制：

// 控制器类
class SmartHomeController {
    private CommandQueue queue = new CommandQueue();
    public void scheduleCommand(Command cmd, long delay) {
        new Thread(() -> {
            try { Thread.sleep(delay); } 
            catch (InterruptedException e) {}
            queue.addCommand(cmd);
        }).start();
    }
}

3.2 事务控制与回滚

数据库操作框架利用命令模式实现事务：

class TransactionManager {
    private Stack<Command> history = new Stack<>();
    public void executeInTransaction(Command cmd) {
        try {
            cmd.execute();
            history.push(cmd);
        } catch (Exception e) {
            rollback();
            throw e;
        }
    }
    public void rollback() {
        while(!history.isEmpty()) {
            history.pop().undo();
        }
    }
}

3.3 宏命令（组合模式）

图形编辑器实现复杂操作组合：

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

3.4 日志与重放

金融交易系统记录操作日志：

class CommandLogger {
    private List<Command> log = new ArrayList<>();
    public void logCommand(Command cmd) {
        log.add(cmd);
    }
    public void replayAll() {
        log.forEach(Command::execute);
    }
}

四、Java生态中的实践案例

4.1 Java线程池的命令模式

ExecutorService通过Runnable/Callable接口实现命令模式：

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> System.out.println("Task executed")); // 提交命令

4.2 Spring框架的命令链

HandlerInterceptor接口构成责任链模式的命令序列：

public class AuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) {
        // 认证命令执行
    }
}

4.3 消息队列中间件

主流消息队列（如RocketMQ）的Producer-Consumer模型本质是异步命令模式：

// 生产者发送命令消息
Message message = new Message("Topic", "Tag", 
    "Command payload".getBytes());
producer.send(message);

五、模式优缺点与适用场景

5.1 核心优势

解耦：发送者与接收者完全隔离
扩展：新增命令不影响现有代码
组合：支持复杂命令的动态构建
控制：实现撤销、重做、事务等高级功能

5.2 潜在缺陷

类膨胀：每个命令需创建对应类
间接性：简单场景可能过度设计
内存消耗：命令对象需持久化时

5.3 适用场景

需要支持撤销/重做功能的系统
需要记录操作日志的应用
需要实现事务回滚的场景
需要将操作排队、调度或批处理的系统
需要支持组合命令的复杂系统

六、总结与展望

命令模式通过将请求对象化，为系统架构提供了卓越的灵活性和可扩展性。在微服务架构盛行的今天，其思想在事件驱动架构、CQRS模式等领域得到新的诠释。开发者应理解其本质——将行为请求转化为可管理的对象，而非机械套用设计模式。在实际应用中，可结合函数式编程的Supplier/Consumer接口、响应式编程的Mono/Flux等现代特性，创造更符合当前技术趋势的解决方案。

命令模式：解耦请求发送与执行的优雅方案