Java设计模式之命令模式：从入门到架构级实践

一、命令模式的核心思想

命令模式（Command Pattern）是行为型设计模式的经典实现，其核心在于将“请求”封装为独立的对象，使得请求的发送者（调用者）与接收者（执行者）完全解耦。这种模式允许你将方法调用、操作或任务抽象成对象，从而支持以下高级特性：

• 参数化客户端：通过传递不同的命令对象实现不同行为

• 请求队列化：支持任务排队、延迟执行或异步处理

• 操作撤销/重做：通过记录命令历史实现逆向操作

• 事务管理：构建原子操作的事务机制

二、模式结构深度解析

1. 核心角色定义

• Command（命令接口）

  • 声明执行操作的抽象方法（如execute()）

  • 可选定义撤销方法（如undo()）

• ConcreteCommand（具体命令）

  • 实现命令接口，绑定接收者对象

  • 在execute()中调用接收者的具体方法

• Invoker（调用者）

  • 持有命令对象的引用

  • 触发命令执行的入口（可能记录命令历史）

• Receiver（接收者）

  • 实际执行业务逻辑的对象

  • 知道如何处理与请求相关的操作

• Client（客户端）

  • 创建具体命令对象并设置接收者

  • 将命令对象传递给调用者

2. 完整代码示例：智能家居控制

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

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

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

// 调用者 - 遥控器
class RemoteControl {
    private Command command;
    private Command lastCommand;
    
    void setCommand(Command command) {
        this.command = command;
    }
    
    void pressButton() {
        command.execute();
        lastCommand = command;
    }
    
    void undoLast() {
        if (lastCommand != null) {
            lastCommand.undo();
            lastCommand = null;
        }
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Light livingRoomLight = new Light();
        Command lightOn = new LightOnCommand(livingRoomLight);
        
        RemoteControl remote = new RemoteControl();
        remote.setCommand(lightOn);
        
        remote.pressButton();  // 开灯
        remote.undoLast();     // 撤销操作 -> 关灯
    }
}

三、六大典型应用场景

1. GUI事件处理

• 将按钮点击、菜单选择等操作封装为命令对象

• 支持快捷键绑定相同操作

• 实现操作历史记录功能

2. 事务型系统

• 每个操作封装为命令对象

• 实现原子操作：要么全部成功，要么全部回滚

• 示例代码片段：

interface TransactionCommand {
    void commit();
    void rollback();
}

class MoneyTransferCommand implements TransactionCommand {
    // 实现转账业务逻辑与回滚
}

3. 异步任务处理

• 将任务封装为命令对象

• 放入线程池或消息队列异步执行

• 示例架构：

[Web请求] -> [创建Command] -> [提交到队列] -> [工作线程处理]

4. 宏命令（组合命令）

• 将多个命令组合成复合命令

• 实现批量操作

class MacroCommand implements Command {
    private List commands = new ArrayList<>();
    
    void addCommand(Command cmd) {
        commands.add(cmd);
    }
    
    @Override
    public void execute() {
        commands.forEach(Command::execute);
    }
}

5. 游戏开发

• 将玩家操作封装为命令

• 实现回放系统、撤销机制

• 支持网络同步操作

6. 智能家居系统

• 统一设备控制接口

• 支持语音控制、定时任务

• 实现场景模式（如“影院模式”关闭所有灯光）

四、架构级实践方案

案例：分布式订单处理系统

业务需求：

• 处理订单创建、支付、发货等操作

• 支持异步处理和高并发

• 实现操作撤销（如取消订单）

• 保证操作幂等性

命令模式实现方案：

1. 定义领域命令

public interface OrderCommand {
    void execute();
    void compensate();  // 补偿操作
    String getCommandId();  // 实现幂等性
}

1. 实现具体命令

public class CreateOrderCommand implements OrderCommand {
    private OrderService receiver;
    private Order order;
    
    @Override
    public void execute() {
        receiver.createOrder(order);
    }
    
    @Override
    public void compensate() {
        receiver.cancelOrder(order.getId());
    }
}

1. 构建命令总线

public class CommandBus {
    private Queue queue = new ConcurrentLinkedQueue<>();
    private Map history = new ConcurrentHashMap<>();
    
    public void sendCommand(OrderCommand cmd) {
        if (!history.containsKey(cmd.getCommandId())) {
            queue.offer(cmd);
            history.put(cmd.getCommandId(), cmd);
        }
    }
    
    public void processCommands() {
        while (!queue.isEmpty()) {
            OrderCommand cmd = queue.poll();
            try {
                cmd.execute();
            } catch (Exception e) {
                cmd.compensate();
            }
        }
    }
}

1. 集成到Spring Boot

@RestController
public class OrderController {
    @Autowired
    private CommandBus commandBus;
    
    @PostMapping("/orders")
    public String createOrder(@RequestBody Order order) {
        OrderCommand cmd = new CreateOrderCommand(order);
        commandBus.sendCommand(cmd);
        return "Order processing started";
    }
}

五、进阶开发技巧

1. 实现高性能命令队列

• 使用Disruptor高性能队列

• 批量命令处理

• 并行执行无依赖命令

2. 命令持久化方案

• 将命令序列化存储到数据库

• 实现系统恢复时重放命令

• 使用JSON序列化示例：

public class CommandSerializer {
    private ObjectMapper mapper = new ObjectMapper();
    
    public String serialize(Command cmd) {
        return mapper.writeValueAsString(cmd);
    }
    
    public Command deserialize(String json) {
        return mapper.readValue(json, Command.class);
    }
}

3. 分布式命令处理

• 使用RabbitMQ或Kafka传递命令

• 实现命令的跨服务调用

• 保证最终一致性

4. 监控与调试

• 记录命令执行时间线

• 实现命令追踪ID

• 集成Spring Actuator进行健康检查

六、模式优劣与适用场景

优势：

1. 请求发送者与接收者完全解耦

2. 支持扩展新命令而无需修改现有代码

3. 可以组合多个命令实现复杂操作

4. 方便实现撤销/重做机制

劣势：

1. 可能导致类数量膨胀

2. 增加了系统复杂度

3. 间接调用可能影响性能

适用场景判断：

• ✅ 需要将操作参数化

• ✅ 需要支持事务/撤销

• ✅ 需要异步/延迟执行

• ❌ 简单操作且无需扩展

• ❌ 对性能要求极高的场景

七、模式扩展与变种

1. 响应式命令模式

   • 结合Reactor或RxJava

   • 实现异步响应式处理流

2. 智能命令（Self-aware Command）

   • 命令对象携带执行上下文

   • 自动处理依赖关系

3. 领域驱动设计集成

   • 将Command作为领域事件

   • 实现CQRS架构

4. Serverless架构应用

   • 将每个命令部署为独立函数

   • 实现按需执行

总结与展望

命令模式为复杂系统的行为管理提供了优雅的解决方案。在微服务架构和云原生时代，命令模式的演进方向包括：

1. 与Event Sourcing结合：通过持久化命令流实现状态重建

2. 云原生实现：使用Serverless架构部署命令处理函数

3. AI集成：通过机器学习自动生成最优命令序列

建议读者在以下场景优先考虑命令模式：

• 需要构建可扩展的操作管理系统

• 系统需要支持事务或撤销机制

• 需要解耦UI层与业务逻辑层

掌握命令模式的精髓，将使你的系统架构获得前所未有的灵活性和可维护性。建议结合实际项目需求进行变通应用，同时注意不要过度设计，在复杂性和灵活性之间找到最佳平衡点。