Spring + 设计模式 （二十一） 行为型 - 命令模式

命令模式

引言

命令模式是一种行为型设计模式，通过将请求封装为对象，将操作的发起者和执行者解耦。想象一个餐厅点单系统，服务员只需传递订单（命令），无需关心厨师如何烹饪。命令模式的核心思想是将“做什么”和“怎么做”分离，允许请求以对象形式传递、存储或撤销。它在企业级开发中大放异彩，适用于需要记录操作历史、实现撤销重做或异步处理的场景。命令模式的魅力在于其灵活性：通过封装请求，系统可以轻松扩展、排队或延迟执行操作，代码优雅且可维护。

实际开发中的用途

命令模式在实际开发中广泛应用于需要解耦请求发起与执行的场景，解决了操作耦合和扩展性问题。典型应用包括：

• 操作日志与撤销：如文本编辑器的保存、撤销和重做功能。
• 任务调度：如异步任务队列、定时任务或工作流引擎。
• 事件驱动系统：将用户操作封装为命令，异步处理或分发。

以电商订单系统为例，假设订单状态变更（如取消订单、确认发货）需要触发多种操作（如更新库存、发送通知）。如果直接在业务逻辑中调用这些操作，代码会变得臃肿且难以维护。使用命令模式，可以将每种操作封装为命令对象，订单服务只需调用命令的 execute 方法，具体实现由命令负责。这种方式不仅降低了耦合，还支持撤销（如取消订单后恢复库存）或异步处理（如延迟发送通知）。

示例场景：一个简单的文本编辑器，用户执行“保存”或“撤销”操作。命令模式将每种操作封装为命令对象，支持操作记录和撤销，逻辑清晰且易于扩展。

Spring 源码中的应用

在 Spring 框架中，命令模式的典型应用体现在 Spring MVC 的 HandlerMethod 和 CommandLineRunner 接口。前者将 HTTP 请求处理封装为命令对象，后者将启动时的初始化任务封装为命令。以下以 HandlerMethod 为例进行分析。

源码分析

HandlerMethod 是 Spring MVC 的核心组件，位于 org.springframework.web.method 包，负责封装控制器方法的调用逻辑。以下是关键源码片段（摘自 Spring Framework 5.3.x，HandlerMethod.java）：

// HandlerMethod.java
public class HandlerMethod {
    private final Object bean;
    private final Method method;
    private final MethodParameter[] parameters;

    public HandlerMethod(Object bean, Method method) {
        this.bean = bean;
        this.method = method;
        this.parameters = initMethodParameters();
    }

    public Object invoke(Object... args) throws Exception {
        return this.method.invoke(this.bean, args);
    }
}

分析：

• 命令模式角色：
  • 命令接口：HandlerMethod 本身，封装了控制器方法的调用逻辑。
  • 具体命令：每个 HandlerMethod 实例，对应控制器中的一个方法（如 @GetMapping 方法）。
  • 调用者：RequestMappingHandlerAdapter，负责调用 HandlerMethod 的 invoke 方法。
  • 接收者：控制器类（如 MyController），实际执行请求处理逻辑。
• 工作原理：Spring MVC 通过 HandlerMethod 将 HTTP 请求的处理逻辑封装为命令对象。RequestMappingHandlerAdapter 解析请求后，调用匹配的 HandlerMethod 的 invoke 方法，执行控制器逻辑。
• 问题解决：命令模式解耦了请求分发与处理逻辑，控制器无需关心请求如何到达，只需实现业务逻辑。HandlerMethod 还支持参数解析、返回值处理等，增强了扩展性。
• 代码体现：invoke 方法是命令模式的典型实现，封装了方法调用的细节，调用者只需传递参数即可触发执行。

这种设计让 Spring MVC 的请求处理高度模块化，支持动态路由、拦截器等功能，是命令模式在框架中的典范。

Spring Boot 代码案例

以下是一个基于 Spring Boot 的案例，模拟一个订单管理系统，使用命令模式封装订单操作（如创建、取消）。案例展示了如何利用命令模式实现低耦合和高扩展性。

案例背景

在一个电商系统中，订单操作（如创建、取消）需触发多种业务逻辑（如库存更新、通知发送）。使用命令模式，将每种操作封装为命令，支持操作执行和撤销。

代码实现

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

// 接收者：订单服务
@Service
public class OrderService {
    public void createOrder(String orderId) {
        System.out.println("Creating order: " + orderId);
        // 模拟创建订单逻辑（如更新数据库）
    }

    public void cancelOrder(String orderId) {
        System.out.println("Cancelling order: " + orderId);
        // 模拟取消订单逻辑（如恢复库存）
    }
}

// 具体命令：创建订单
@Component
public class CreateOrderCommand implements OrderCommand {
    private final OrderService orderService;
    private final String orderId;

    public CreateOrderCommand(OrderService orderService, String orderId) {
        this.orderService = orderService;
        this.orderId = orderId;
    }

    @Override
    public void execute() {
        orderService.createOrder(orderId);
    }

    @Override
    public void undo() {
        orderService.cancelOrder(orderId);
    }
}

// 具体命令：取消订单
@Component
public class CancelOrderCommand implements OrderCommand {
    private final OrderService orderService;
    private final String orderId;

    public CancelOrderCommand(OrderService orderService, String orderId) {
        this.orderService = orderService;
        this.orderId = orderId;
    }

    @Override
    public void execute() {
        orderService.cancelOrder(orderId);
    }

    @Override
    public void undo() {
        orderService.createOrder(orderId);
    }
}

// 调用者：命令管理器
@Service
public class OrderCommandManager {
    private final Stack<OrderCommand> history = new Stack<>();

    public void executeCommand(OrderCommand command) {
        command.execute();
        history.push(command);
    }

    public void undoLastCommand() {
        if (!history.isEmpty()) {
            OrderCommand command = history.pop();
            command.undo();
        }
    }
}

// 测试控制器
@RestController
public class OrderController {
    private final OrderCommandManager commandManager;
    private final OrderService orderService;

    public OrderController(OrderCommandManager commandManager, OrderService orderService) {
        this.commandManager = commandManager;
        this.orderService = orderService;
    }

    @PostMapping("/orders/create")
    public String createOrder(@RequestBody Map<String, String> request) {
        String orderId = request.get("orderId");
        OrderCommand command = new CreateOrderCommand(orderService, orderId);
        commandManager.executeCommand(command);
        return "Order created: " + orderId;
    }

    @PostMapping("/orders/cancel")
    public String cancelOrder(@RequestBody Map<String, String> request) {
        String orderId = request.get("orderId");
        OrderCommand command = new CancelOrderCommand(orderService, orderId);
        commandManager.executeCommand(command);
        return "Order cancelled: " + orderId;
    }

    @PostMapping("/orders/undo")
    public String undoOrder() {
        commandManager.undoLastCommand();
        return "Last order operation undone";
    }
}

// 主应用
@SpringBootApplication
public class CommandPatternApplication {
    public static void main(String[] args) {
        SpringApplication.run(CommandPatternApplication.class, args);
    }
}

代码说明

• 命令模式体现：OrderCommand 接口定义了 execute 和 undo 方法，CreateOrderCommand 和 CancelOrderCommand 封装了具体操作。OrderCommandManager 作为调用者，管理命令执行和撤销。
• 优势：
  • 低耦合：OrderService 只负责业务逻辑，命令对象负责封装操作，调用者无需了解实现细节。
  • 支持撤销：通过 undo 方法和命令历史栈，支持操作回滚，适合需要事务管理的场景。
  • 企业级适用性：命令模式支持异步执行（结合 @Async）、操作日志记录等，适应复杂业务需求。
• 运行效果：通过 POST 请求 /orders/create 或 /orders/cancel 执行订单操作，/orders/undo 撤销最近操作。控制台输出操作日志，逻辑清晰且可追溯。

相似的设计模式对比

命令模式与 策略模式（Strategy Pattern）在某些场景下有相似之处，但它们的侧重点和实现方式不同。以下是对比分析：

• 命令模式：
  • 关键词：请求封装、操作解耦、撤销重做。
  • 说明：将请求封装为对象，解耦发起者和执行者，支持操作记录和撤销。
• 策略模式：
  • 关键词：算法封装、行为切换、静态逻辑。
  • 说明：定义一组算法并动态切换，适合封装固定行为或策略。

对比表格

特性	命令模式	策略模式
核心思想	封装请求为对象	封装算法为对象
耦合度	较低，发起者与执行者解耦	较低，客户端与算法解耦
适用场景	操作记录、撤销、任务调度	算法选择、行为切换
扩展性	支持撤销、排队等复杂逻辑	适合简单算法替换
Spring 中的实现	HandlerMethod, CommandLineRunner	Bean 选择、AOP 策略

代码对比

以下通过一个订单状态变更功能对比两者的实现差异。

命令模式实现

public interface Command {
    void execute();
}

public class UpdateOrderStatusCommand implements Command {
    private final OrderService orderService;
    private final String orderId;
    private final String status;

    public UpdateOrderStatusCommand(OrderService orderService, String orderId, String status) {
        this.orderService = orderService;
        this.orderId = orderId;
        this.status = status;
    }

    @Override
    public void execute() {
        orderService.updateStatus(orderId, status);
    }
}

public class OrderService {
    public void updateStatus(String orderId, String status) {
        System.out.println("Order " + orderId + " updated to " + status);
    }
}

策略模式实现

public interface StatusUpdateStrategy {
    void updateStatus(String orderId);
}

public class ConfirmedStatusStrategy implements StatusUpdateStrategy {
    @Override
    public void updateStatus(String orderId) {
        System.out.println("Order " + orderId + " updated to CONFIRMED");
    }
}

public class OrderStatusUpdater {
    private final StatusUpdateStrategy strategy;

    public OrderStatusUpdater(StatusUpdateStrategy strategy) {
        this.strategy = strategy;
    }

    public void updateStatus(String orderId) {
        strategy.updateStatus(orderId);
    }
}

差异分析：

• 命令模式：UpdateOrderStatusCommand 封装了具体操作，支持动态参数（如 status）和撤销逻辑，适合复杂场景（如操作历史记录）。
• 策略模式：ConfirmedStatusStrategy 封装固定行为，逻辑简单，适合预定义的算法切换，但不支持撤销或动态参数。
• 适用性：命令模式适合需要操作封装和扩展的场景；策略模式适合简单的行为替换。

总结

命令模式是一把封装请求的利刃，通过将操作转化为对象，解耦了发起者和执行者，赋予系统灵活性和可扩展性。它的核心价值在于支持撤销、排队和异步处理，特别适合操作日志、任务调度等场景。在 Spring 中，HandlerMethod 是命令模式的典范，优雅地实现了请求处理的模块化。与策略模式相比，命令模式在处理动态操作和复杂逻辑时更具优势，但需权衡命令对象的维护成本。开发者应善用命令模式，将操作逻辑封装为独立单元，让系统如流水线般高效运行，适应多变的业务需求。

(对您有帮助 && 觉得我总结的还行) -> 受累点个免费的赞👍，谢谢