使用命令模式实现撤销与重做功能的完整指南

最新推荐文章于 2025-03-11 11:28:52 发布

勤劳兔码农

最新推荐文章于 2025-03-11 11:28:52 发布

阅读量2.1k

点赞数 24

文章标签：命令模式

本文链接：https://blog.csdn.net/2401_85639015/article/details/141475747

版权

使用命令模式实现撤销与重做功能的完整指南

命令模式是一种行为型设计模式，它将请求封装成对象，以便于对请求进行参数化、排队和记录。命令模式不仅有助于实现撤销和重做功能，还能提高系统的灵活性和可维护性。在本文中，我们将详细探讨如何使用命令模式来实现撤销与重做功能，包括设计思想、实现步骤和代码示例。

1. 撤销与重做功能概述

撤销（Undo）和重做（Redo）是用户界面应用程序中常见的功能，特别是在文本编辑器、图形编辑工具和其他需要频繁操作的应用程序中。这些功能允许用户撤销最近的操作并恢复之前的状态，或者恢复被撤销的操作。

1.1 撤销功能

撤销功能允许用户撤销最近执行的操作，将系统恢复到之前的状态。撤销通常涉及到对操作历史的跟踪，以便能够还原到先前的状态。

1.2 重做功能

重做功能允许用户恢复被撤销的操作，将系统恢复到撤销操作之前的状态。重做操作通常依赖于撤销操作的历史记录，以便能够重新应用先前的操作。

2. 命令模式概述

命令模式将请求封装成对象，使得请求的发送者与接收者解耦。命令模式通常包括以下几个角色：

2.1 命令接口（Command）

命令接口声明了执行操作的接口，包括execute()方法和undo()方法（对于撤销操作）。

public interface Command {
    void execute();
    void undo();
}

2.2 具体命令（ConcreteCommand）

具体命令实现了命令接口，并将请求的接收者与操作绑定在一起。每个具体命令负责执行具体的操作，并实现撤销操作。

public class ConcreteCommand implements Command {
    private Receiver receiver;

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

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

    @Override
    public void undo() {
        receiver.undoAction();
    }
}

2.3 接收者（Receiver）

接收者是实际执行操作的对象。它定义了具体的操作，并实现了相应的撤销操作。

public class Receiver {
    public void action() {
        // 执行操作
    }

    public void undoAction() {
        // 撤销操作
    }
}

2.4 调用者（Invoker）

调用者用于触发命令的执行。它持有对命令对象的引用，并调用命令的execute()方法。

public class Invoker {
    private Command command;

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

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

    public void undoCommand() {
        command.undo();
    }
}

3. 使用命令模式实现撤销与重做

要实现撤销与重做功能，需要对命令模式进行扩展，以便能够存储和管理撤销与重做的命令历史。以下是实现撤销与重做功能的步骤：

3.1 扩展命令接口

扩展命令接口以支持撤销和重做操作。为每个命令实现execute()、undo()和redo()方法。

public interface Command {
    void execute();
    void undo();
    void redo();
}

3.2 扩展具体命令

为每个具体命令实现undo()和redo()方法，以便能够支持撤销和重做操作。

public class ConcreteCommand implements Command {
    private Receiver receiver;

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

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

    @Override
    public void undo() {
        receiver.undoAction();
    }

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

3.3 实现撤销与重做管理

创建一个撤销与重做管理器（HistoryManager）来管理命令历史，包括撤销和重做的命令栈。

import java.util.Stack;

public class HistoryManager {
    private Stack<Command> undoStack = new Stack<>();
    private Stack<Command> redoStack = new Stack<>();

    public void executeCommand(Command command) {
        command.execute();
        undoStack.push(command);
        redoStack.clear(); // 清空重做栈
    }

    public void undo() {
        if (!undoStack.isEmpty()) {
            Command command = undoStack.pop();
            command.undo();
            redoStack.push(command);
        }
    }

    public void redo() {
        if (!redoStack.isEmpty()) {
            Command command = redoStack.pop();
            command.redo();
            undoStack.push(command);
        }
    }
}

3.4 集成示例

将上述组件整合到一个完整的应用中。以下是一个完整的撤销与重做功能实现的示例：

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

    public void undoAction() {
        System.out.println("Action undone.");
    }
}

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

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

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

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

    @Override
    public void undo() {
        receiver.undoAction();
    }

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

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

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

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

    public void undoCommand() {
        command.undo();
    }

    public void redoCommand() {
        command.redo();
    }
}

// 撤销与重做管理器
import java.util.Stack;

public class HistoryManager {
    private Stack<Command> undoStack = new Stack<>();
    private Stack<Command> redoStack = new Stack<>();

    public void executeCommand(Command command) {
        command.execute();
        undoStack.push(command);
        redoStack.clear(); // 清空重做栈
    }

    public void undo() {
        if (!undoStack.isEmpty()) {
            Command command = undoStack.pop();
            command.undo();
            redoStack.push(command);
        }
    }

    public void redo() {
        if (!redoStack.isEmpty()) {
            Command command = redoStack.pop();
            command.redo();
            undoStack.push(command);
        }
    }
}

// 主程序
public class Main {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);
        HistoryManager historyManager = new HistoryManager();
        
        // 执行操作
        historyManager.executeCommand(command);
        
        // 撤销操作
        historyManager.undo();
        
        // 重做操作
        historyManager.redo();
    }
}

4. 进阶功能与优化

4.1 多命令组合

在实际应用中，可能需要对多个命令进行组合以实现复杂的操作。可以使用组合命令（Composite Command）来实现这一点。组合命令将多个命令封装成一个单一的命令对象。

import java.util.ArrayList;
import java.util.List;

public class CompositeCommand implements Command {
    private List<Command> commands = new ArrayList<>();

    public void addCommand(Command command) {
        commands.add(command);
    }

    @Override
    public void execute() {
        for (Command command : commands) {
            command.execute();
        }
    }

    @Override
    public void undo() {
        for (Command command : commands) {
            command.undo();
        }
    }

    @Override
    public void redo() {
        for (Command command : commands) {
            command.redo();
        }
    }
}