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

摘要

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

1. 命令设计模式定义

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

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

1.1. 🧱 模式结构组成：

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. ✅ 总结优势

6. 命令设计模式思考

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

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

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

6.1.2. ✅ 适用场景

例如在风控、工作流、审批流等系统，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());
    }
}

博文参考

• 1. 命令模式 — Graphic Design Patterns
• 责任链设计模式（职责链模式）