命令模式（Command Pattern）是一种常用的设计模式，属于行为型模式的一种。它的主要目的是将一个请求封装为一个对象，从而允许用户使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。

1 命令模式的组成

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

1. Command：命令接口，声明执行操作的接口。
2. ConcreteCommand：具体命令，实现命令接口，并调用接收者的一个或多个动作来完成具体的命令。会保持一个接受者的引用。它是一个容器并不会执行具体处理
3. Invoker：调用者，负责调用命令对象执行请求。
4. Receiver：接收者，知道如何实施与执行一个请求相关的操作。
5. Client：客户端，创建一个具体命令对象，并设置其接收者。

2 使用场景

命令模式在实际场景中的作用主要体现在以下几个方面：

1. 解耦调用者和接收者：
   命令模式可以将发出命令的对象和接收以及执行命令的对象解耦。这意味着命令的发送者不需要知道具体是谁执行的命令，也不需要知道命令是如何实现的。这种解耦使得系统更加灵活，易于扩展和修改。
2. 命令的排队与执行：
   命令模式允许将命令保存在队列中，然后在需要的时候依次执行。这在多线程程序中特别有用，可以在一个线程中排队命令，并在另一个线程中一一执行，有效地实现了线程间的任务调度。
3. 支持撤销和重做操作：
   命令模式可以通过实现撤销（undo）和重做（redo）命令来支持用户的撤销操作，这在编辑器、图形界面工具等需要提供用户操作回退功能的应用中非常有用。
4. 支持操作的宏命令：
   通过命令模式，可以将多个命令组合成一个宏命令，然后以单一命令的方式执行。这种方式常用于实现复杂的用户界面操作、事务性操作，或是需要一系列步骤共同完成一个任务的场景。
5. 动态调整命令：
   由于命令是对象，可以在运行时动态地改变命令的参数，或者完全更换执行的命令。这为动态调整程序的行为提供了极大的灵活性。
6. 日志和事务：
   命令模式可以用来记录详细的日志，记录用户的具体操作，或者在需要的时候，实现对命令的持久化。在软件崩溃后，这些记录可以用来恢复用户的操作。在事务型系统中，可以用命令模式来实现事务的提交和回滚。

3 特点

• 解耦命令的发出者和执行者：发出请求的对象与接收和执行请求的对象是解耦的。
• 扩展性好：可以很容易地新增命令或者改变命令的执行者。
• 组合命令：可以组合多个命令，实现复杂的功能。
• 支持撤销操作：命令模式可以用来实现命令的撤销和重做。-

4 示例代码

• 用户界面按钮和菜单项：GUI中的每个按钮或菜单项基本上都是一个命令模式的实现。
• 多级撤销功能：通过命令模式实现命令的历史记录，用户可以进行撤销或重做操作。
• 事务型行为：命令模式可以与数据库事务结合使用，用于实现事务的逻辑，其中每个操作都可以看作是一个命令。
• 排队请求：比如工作队列的设计，将请求排队，并在不同的时间点处理它们。
• 复合命令：可以组合多个命令，形成宏命令。

4.1 用户界面按钮和菜单项

一个简单的遥控器操作电灯的开关：

class Command:
    def execute(self):
        pass

class Light:
    """接收者：电灯，执行与电灯相关的操作"""
    def turn_on(self):
        print("电灯打开了。")

    def turn_off(self):
        print("电灯关闭了。")

class TurnOnCommand(Command):
    """具体命令：打开电灯"""
    def __init__(self, light):
        self.light = light

    def execute(self):
        self.light.turn_on()

class TurnOffCommand(Command):
    """具体命令：关闭电灯"""
    def __init__(self, light):
        self.light = light

    def execute(self):
        self.light.turn_off()

class RemoteControl:
    """调用者：遥控器，发出命令的请求"""
    def __init__(self):
        self.command = None

    def set_command(self, command):
        self.command = command

    def press_button(self):
        self.command.execute()

# 客户端代码
light = Light()
turn_on = TurnOnCommand(light)
turn_off = TurnOffCommand(light)

remote = RemoteControl()
remote.set_command(turn_on)
remote.press_button()

remote.set_command(turn_off)
remote.press_button()

一个文本编辑器的例子 使用命令模式来实现复制和粘贴功能：

class Command:
    def execute(self):
        pass

class TextEditor:
    def __init__(self, text=''):
        self.text = text
        self.clipboard = ''

    def copy(self):
        self.clipboard = self.text
        print(f"已复制: {self.clipboard}")

    def paste(self):
        self.text += self.clipboard
        print(f"当前文本: {self.text}")

class CopyCommand(Command):
    def __init__(self, editor):
        self.editor = editor

    def execute(self):
        self.editor.copy()

class PasteCommand(Command):
    def __init__(self, editor):
        self.editor = editor

    def execute(self):
        self.editor.paste()

editor = TextEditor("Hello")
copy_cmd = CopyCommand(editor)
paste_cmd = PasteCommand(editor)

copy_cmd.execute()
paste_cmd.execute()

4.2 多级撤销功能

一个简单的计算器，能够执行操作并支持撤销功能：

class Command:
    def execute(self):
        pass

    def undo(self):
        pass

class Calculator:
    def __init__(self):
        self.value = 0

    def add(self, num):
        self.value += num
        print(f"当前值: {self.value}")

    def subtract(self, num):
        self.value -= num
        print(f"当前值: {self.value}")

class AddCommand(Command):
    def __init__(self, calc, num):
        self.calc = calc
        self.num = num

    def execute(self):
        self.calc.add(self.num)

    def undo(self):
        self.calc.subtract(self.num)

calc = Calculator()
cmd = AddCommand(calc, 10)
cmd.execute()
cmd.undo()

4.3 事务型行为

模拟了数据库事务的基本操作：

class Command:
    def execute(self):
        pass

    def rollback(self):
        pass

class Database:
    def __init__(self):
        self.data = {}

    def insert(self, key, value):
        self.data[key] = value
        print(f"插入: {key} -> {value}")

    def delete(self, key):
        if key in self.data:
            del self.data[key]
            print(f"删除: {key}")

class InsertCommand(Command):
    def __init__(self, db, key, value):
        self.db = db
        self.key = key
        self.value = value

    def execute(self):
        self.db.insert(self.key, self.value)

    def rollback(self):
        self.db.delete(self.key)

db = Database()
cmd = InsertCommand(db, 'id1', 'Data 1')
cmd.execute()
cmd.rollback()

4.4 排队请求

如何使用命令模式将请求排队并在不同的时间点处理：

from queue import Queue

class Command:
    def execute(self):
        pass

class Worker:
    def do_something(self, msg):
        print(f"工作内容: {msg}")

class DoSomethingCommand(Command):
    def __init__(self, worker, msg):
        self.worker = worker
        self.msg = msg

    def execute(self):
        self.worker.do_something(self.msg)

queue = Queue()
worker = Worker()

queue.put(DoSomethingCommand(worker, "任务1"))
queue.put(DoSomethingCommand(worker, "任务2"))

while not queue.empty():
    cmd = queue.get()
    cmd.execute()

4.5 复合命令

通过命令模式实现的宏命令示例，可以执行一系列命令：

class Command:
    def execute(self):
        pass

class MacroCommand(Command):
    def __init__(self):
        self.commands = []

    def add_command(self, cmd):
        self.commands.append(cmd)

    def execute(self):
        for cmd in self.commands:
            cmd.execute()

class SimpleCommand(Command):
    def __init__(self, payload):
        self.payload = payload

    def execute(self):
        print(f"执行: {self.payload}")

macro = MacroCommand()
macro.add_command(SimpleCommand("步骤1"))
macro.add_command(SimpleCommand("步骤2"))

macro.execute()