设计模式——命令设计模式（行为型）

摘要

本文介绍了命令设计模式，这是一种行为型设计模式，用于将请求封装为对象，实现请求的解耦和灵活控制。它包含命令接口、具体命令、接收者、调用者和客户端等角色，优点是解耦请求发送者与接收者，支持命令的排队、记录、撤销等操作，但会增加系统复杂性。文中通过点餐系统类比说明其结构，并介绍了实现方式、适合场景和实战示例。

1. 命令设计模式定义

将请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，队列或记录请求日志，以及支持可撤销的操作。命令模式将“命令的发起者”与“命令的执行者”解耦，通过封装命令对象来实现请求的解耦和灵活控制。

优点：解耦请求发送者与接收者、支持命令的排队、记录、撤销/重做、更容易扩展新命令类
缺点：增加了系统中类的数量，带来一定结构复杂性

1.1. 🧱 模式结构组成：

角色	说明
Command（命令接口）	声明执行操作的接口。
ConcreteCommand（具体命令）	实现命令接口，绑定接收者并调用其方法。
Receiver（接收者）	执行命令实际操作的类。
Invoker（调用者）	负责调用命令对象来执行请求。
Client（客户端）	创建命令对象并将其配置给调用者。

1.2. ✅ 举例类比（生活化）：

点餐系统中：

顾客 → Invoker
服务员传菜 → Command
厨师 → Receiver
每道菜 → ConcreteCommand

2. 命令设计模式结构

命令模式包含如下角色：

Command: 抽象命令类
ConcreteCommand: 具体命令类
Invoker: 调用者
Receiver: 接收者
Client:客户类

2.1. 命令设计模式类图

2.2. 命令设计模式时序图

3. 命令设计模式实现方式

命令设计模式的实现方式，核心在于 将命令抽象成独立对象，使得发送者和接收者解耦。下面是标准实现结构和 Java 示例实现方式，结合注解风格以方便应用于 Spring 项目中。

3.1. 定义命令接口（Command）

public interface Command {
    void execute();
}

3.2. 创建接收者类（Receiver）

public class RiskDecisionReceiver {
    public void approve() {
        System.out.println("审批通过逻辑执行...");
    }

    public void reject() {
        System.out.println("审批拒绝逻辑执行...");
    }
}

3.3. 创建具体命令类（ConcreteCommand）

public class ApproveCommand implements Command {
    
    private final RiskDecisionReceiver receiver;

    public ApproveCommand(RiskDecisionReceiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.approve();
    }
}

public class RejectCommand implements Command {
    
    private final RiskDecisionReceiver receiver;

    public RejectCommand(RiskDecisionReceiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.reject();
    }
}

3.4. 调用者类（Invoker）

public class DecisionInvoker {
    
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void run() {
        command.execute();
    }
}

3.5. 客户端调用示例（Client）

public class RiskDecisionClient {
    
    public static void main(String[] args) {
        RiskDecisionReceiver receiver = new RiskDecisionReceiver();
        Command approveCommand = new ApproveCommand(receiver);
        Command rejectCommand = new RejectCommand(receiver);

        DecisionInvoker invoker = new DecisionInvoker();

        // 审批通过流程
        invoker.setCommand(approveCommand);
        invoker.run();

        // 审批拒绝流程
        invoker.setCommand(rejectCommand);
        invoker.run();
    }
}

3.6. Spring 实现提示（可选）

如果你使用 Spring，可以用如下方式注入和管理：

使用 @Component 管理 Receiver 和 ConcreteCommand
使用 @Autowired 注入 Receiver 到命令中
用策略注册表 + 命令名映射管理命令

结果好处

增加新命令非常容易（只需实现接口）
接收者逻辑和命令发送者解耦
可以实现撤销、重做、命令日志等增强功能

4. 命令设计模式适合场景

4.1. ✅ 适合使用命令设计模式的场景

场景	说明
需要将请求调用者与接收者解耦	调用者只负责触发命令，不知道命令如何实现。
需要对请求排队、记录日志、支持撤销/重做	如编辑器中的操作撤销、银行交易日志等。
需要支持宏命令（多个命令组合执行）	比如批量操作、流水线处理等。
需要将操作封装为对象传递	方便将命令存入队列、数据库，延迟执行。
系统中存在多个操作行为，需要灵活扩展	每种行为封装为命令，新增行为无需改调用者逻辑。
远程调用 / 宏任务调度	比如分布式系统中对远程服务的封装。

4.2. ❌ 不适合使用命令设计模式的场景

场景	原因
业务操作非常简单，没有扩展需求	引入命令对象反而让结构复杂，得不偿失。
命令对象数量极多且变化频繁	会导致命令类泛滥，维护成本变高。
不需要记录历史或撤销操作的业务	命令封装就失去了很多优势，增加冗余。
操作同步且不需要解耦调用者和执行者	可以直接调用接收者方法，无需封装为命令。
高性能敏感系统中	引入命令对象和调用链会带来额外性能开销。

4.3. 📌 命令设计模式的场景总结：

项目	命令模式适用	不适用
是否需要行为解耦	✅ 是	❌ 否
是否需要日志/撤销/排队	✅ 是	❌ 否
行为是否变化频繁	✅ 是	❌ 否（简单稳定）
是否存在命令组合需求	✅ 是	❌ 否
是否为高频调用或性能敏感	❌ 否（不适用）	✅ 是

5. 命令设计模式实战示例

5.1. 🌟 场景简介

风控命令中心根据业务场景动态执行不同的风控策略，如：

黑名单校验
信用评分校验
设备指纹校验等

5.2. 1️⃣ 命令接口定义

public interface RiskCommand {
    void execute(RiskContext context);
}

5.3. 2️⃣ 风控上下文对象（命令输入参数）

public class RiskContext {
    private String userId;
    private String ip;
    private String deviceId;
    private Map<String, Object> resultMap = new HashMap<>();

    // getter/setter省略
}

5.4. 3️⃣ 各种具体命令实现

5.4.1. 黑名单校验命令

@Component("blacklistCommand")
public class BlacklistCommand implements RiskCommand {

    @Override
    public void execute(RiskContext context) {
        // 模拟黑名单校验逻辑
        System.out.println("执行黑名单校验 for user: " + context.getUserId());
        context.getResultMap().put("blacklist", false);
    }
}

5.4.2. 信用分数校验命令

@Component("creditScoreCommand")
public class CreditScoreCommand implements RiskCommand {

    @Override
    public void execute(RiskContext context) {
        // 模拟信用分校验逻辑
        System.out.println("执行信用分校验 for user: " + context.getUserId());
        context.getResultMap().put("creditScorePass", true);
    }
}

5.5. 4️⃣ 命令调用者（Invoker）

@Component
public class RiskCommandInvoker {

    @Autowired
    private ApplicationContext applicationContext;

    public void runCommands(List<String> commandNames, RiskContext context) {
        for (String name : commandNames) {
            RiskCommand command = applicationContext.getBean(name, RiskCommand.class);
            command.execute(context);
        }
    }
}

5.6. 5️⃣ 控制器或服务调用示例

@Service
public class RiskEngineService {

    @Autowired
    private RiskCommandInvoker invoker;

    public void runRiskProcess(String userId) {
        RiskContext context = new RiskContext();
        context.setUserId(userId);
        context.setIp("192.168.1.1");
        context.setDeviceId("DEVICE123");

        List<String> commands = Arrays.asList("blacklistCommand", "creditScoreCommand");
        invoker.runCommands(commands, context);

        System.out.println("风控结果: " + context.getResultMap());
    }
}

5.7. ✅ 总结优势

点	说明
解耦	控制器无需知道风控规则细节
灵活扩展	添加新命令只需实现接口并加 `@Component`
动态组合	命令名可来自配置文件、数据库、用户输入等
日志/回滚	每个命令可独立记录日志或支持回滚逻辑

6. 命令设计模式思考

6.1. 命令模式是不是适合用于在Controller 层与service层之间？用于构建Controller 的命令？

6.1.1. 可以使用，但不是最佳常规选择

命令模式主要用于封装请求为对象，从而实现请求的参数化、请求排队、撤销、日志、事务等操作。在某些特定场景下可以作为Controller与Service之间的中间层抽象使用，例如：

6.1.2. ✅ 适用场景

场景	说明
控制层处理的业务请求种类多、变化大	使用命令模式封装请求参数及处理逻辑，使代码结构清晰
控制层希望将不同业务处理模块“延迟执行”或“排队执行”	命令可异步队列执行
需要记录请求日志、支持撤销/回滚等扩展行为	命令对象天然适合这些行为
多个 Controller 共用相似的业务指令	可将通用处理抽象成命令复用

例如在风控、工作流、审批流等系统，Controller 接收请求后会根据参数生成命令对象，并交由统一的命令执行器处理逻辑，非常合适使用命令模式。

6.1.3. ❌ 不适合场景（常规应用）

对于大部分业务系统，如果 Controller 只是简单地调用 Service 的方法，并没有复杂的行为拆解需求：

命令模式反而会引入过多抽象；
增加类和代码复杂度；
开发维护成本上升。

6.1.4. ✳️ 总结判断标准

需求	是否适合命令模式
请求结构稳定、简单	❌ 不适合
业务逻辑复杂、执行方式灵活	✅ 适合
希望请求可记录、排队、组合、延迟执行	✅ 非常适合
控制层职责只做参数接收和转发	❌ 不适合

6.1.5. ✅ 示例（适合的 Controller 场景）

@RestController
public class RiskController {

    @Autowired
    private RiskCommandInvoker invoker;

    @PostMapping("/risk/check")
    public ResponseEntity<String> riskCheck(@RequestBody RiskRequest request) {
        RiskContext context = new RiskContext();
        context.setUserId(request.getUserId());

        // 将 Controller 参数转化为一组命令
        List<String> commands = Arrays.asList("blacklistCommand", "creditScoreCommand");

        invoker.runCommands(commands, context);

        return ResponseEntity.ok("风控结果: " + context.getResultMap());
    }
}