设计模式之命令模式：原理、实现与应用

news2025/3/25 5:44:49

引言

命令模式（Command Pattern）是一种行为型设计模式，它将请求封装为对象，从而使你可以用不同的请求对客户进行参数化。命令模式支持请求的排队、记录日志、撤销操作等功能。本文将深入探讨命令模式的原理、实现方式以及实际应用场景，帮助你更好地理解和使用这一设计模式。

1. 命令模式的核心概念

1.1 什么是命令模式？

命令模式是一种行为型设计模式，它将请求封装为对象，从而使你可以用不同的请求对客户进行参数化。命令模式支持请求的排队、记录日志、撤销操作等功能。

1.2 命令模式的应用场景

请求排队：如任务队列、线程池等。
撤销操作：如文本编辑器中的撤销功能。
日志记录：如记录用户操作的日志。
事务处理：如数据库事务的提交和回滚。

2. 命令模式的实现方式

2.1 基本结构

命令模式通常包含以下几个角色：

命令接口（Command）：定义执行操作的接口。
具体命令（Concrete Command）：实现命令接口，封装具体的操作。
接收者（Receiver）：执行命令的对象。
调用者（Invoker）：持有命令对象，并调用命令的执行方法。
客户端（Client）：创建命令对象并设置其接收者。

2.2 代码示例

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

// 具体命令
public class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

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

// 接收者
public class Receiver {
    public void action() {
        System.out.println("Receiver action");
    }
}

// 调用者
public class Invoker {
    private Command command;

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);
        Invoker invoker = new Invoker();

        invoker.setCommand(command);
        invoker.executeCommand();
    }
}

3. 命令模式的最佳实践

3.1 支持撤销操作

撤销操作：通过命令模式实现撤销操作，记录命令的执行状态。
重做操作：通过命令模式实现重做操作，记录命令的执行历史。

3.2 支持日志记录

日志记录：通过命令模式记录用户操作的日志，便于追踪和审计。
事务处理：通过命令模式实现事务的提交和回滚。

3.3 遵循单一职责原则

单一职责：每个命令只负责一个操作，保持职责单一。
高内聚低耦合：命令模式使得系统更加高内聚低耦合。

4. 命令模式的实际应用

4.1 文本编辑器

在文本编辑器中，命令模式用于实现撤销和重做功能。

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

// 具体命令
public class InsertTextCommand implements TextCommand {
    private StringBuilder text;
    private String insertedText;
    private int position;

    public InsertTextCommand(StringBuilder text, String insertedText, int position) {
        this.text = text;
        this.insertedText = insertedText;
        this.position = position;
    }

    @Override
    public void execute() {
        text.insert(position, insertedText);
    }

    @Override
    public void undo() {
        text.delete(position, position + insertedText.length());
    }
}

// 调用者
public class TextEditor {
    private List<TextCommand> commandHistory = new ArrayList<>();
    private int currentCommandIndex = -1;

    public void executeCommand(TextCommand command) {
        command.execute();
        commandHistory.add(command);
        currentCommandIndex++;
    }

    public void undo() {
        if (currentCommandIndex >= 0) {
            TextCommand command = commandHistory.get(currentCommandIndex);
            command.undo();
            currentCommandIndex--;
        }
    }

    public void redo() {
        if (currentCommandIndex < commandHistory.size() - 1) {
            currentCommandIndex++;
            TextCommand command = commandHistory.get(currentCommandIndex);
            command.execute();
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        StringBuilder text = new StringBuilder("Hello, World!");
        TextEditor editor = new TextEditor();

        TextCommand insertCommand = new InsertTextCommand(text, "Java ", 7);
        editor.executeCommand(insertCommand);
        System.out.println(text);

        editor.undo();
        System.out.println(text);

        editor.redo();
        System.out.println(text);
    }
}

4.2 任务队列

在任务队列中，命令模式用于实现任务的排队和执行。

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

// 具体命令
public class PrintTask implements Task {
    private String message;

    public PrintTask(String message) {
        this.message = message;
    }

    @Override
    public void execute() {
        System.out.println(message);
    }
}

// 调用者
public class TaskQueue {
    private Queue<Task> tasks = new LinkedList<>();

    public void addTask(Task task) {
        tasks.add(task);
    }

    public void processTasks() {
        while (!tasks.isEmpty()) {
            Task task = tasks.poll();
            task.execute();
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        TaskQueue queue = new TaskQueue();
        queue.addTask(new PrintTask("Task 1"));
        queue.addTask(new PrintTask("Task 2"));
        queue.addTask(new PrintTask("Task 3"));

        queue.processTasks();
    }
}

4.3 遥控器

在遥控器中，命令模式用于实现按钮与设备的解耦。

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

// 具体命令
public class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.on();
    }
}

public class LightOffCommand implements Command {
    private Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.off();
    }
}

// 接收者
public class Light {
    public void on() {
        System.out.println("Light is on");
    }

    public void off() {
        System.out.println("Light is off");
    }
}

// 调用者
public class RemoteControl {
    private Command command;

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Light light = new Light();
        Command lightOn = new LightOnCommand(light);
        Command lightOff = new LightOffCommand(light);

        RemoteControl remote = new RemoteControl();
        remote.setCommand(lightOn);
        remote.pressButton();

        remote.setCommand(lightOff);
        remote.pressButton();
    }
}