设计模式十五命令模式：边学边做个生成电子书的工具（python+dart）

意图：将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。

主要解决：在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。

何时使用：在某些场合，比如要对行为进行"记录、撤销/重做、事务"等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将"行为请求者"与"行为实现者"解耦？将一组行为抽象为对象，可以实现二者之间的松耦合。

如何解决：通过调用者调用接受者执行命令，顺序：调用者→接受者→命令

python 代码

from abc import ABCMeta, abstractmethod
import  os
verbose = True

class RenameFile:

    def __init__(self,path_src,path_dest):
        self.src,self.dest = path_src,path_dest
    def execute(self):

        if verbose:
            print("文件重命名")
        os.rename(self.src,self.dest)
    def undo(self):
        if verbose:
            print("撤销重命名")
        os.rename(self.dest,self.src)

class CreateFile:
    def __init__(self,path,txt = "hello world!!!"):
        self.path,self.txt = path,txt
    def execute(self):
        if verbose:
            print("正在创建文件")
        with open(self.path,mode='w',encoding="utf-8") as out_file:
            out_file.write(self.txt)
    def undo(self):
        delete_file(self.path)


class ReadFile:
    def __init__(self,path):
        self.path = path
    def execute(self):
        if verbose:
            print("正在读文件")
        with open(self.path,mode="r",encoding='utf-8') as in_file:
            print(in_file.read(),end=" ")

def delete_file(path):
    if verbose:
        print("正在删除文件")
    os.remove(path)




if '__main__' ==__name__:
    origin_name,new_name = 'file1.txt','file2.txt'
    commands=[]



    for cmd in CreateFile(origin_name),ReadFile(origin_name),RenameFile(origin_name,new_name):
        commands.append(cmd)
        print(type(cmd))

    print(commands)
    [c.execute() for c in commands]

    answer  = input("undo ??Y or y")
    if answer not in "Yy":
        print("最后结果是",new_name)
        exit()
    for c in reversed(commands):
        try:
            c.undo()
        except AttributeError as e:
            pass

dart 代码实现

abstract class Order {
  void execute();
}

class Stock {
  String name = "abc";
  int quantity = 10;
  void buy() {
    print("buy stock name $name,quantity  $quantity");
  }

  void sell() {
    print("sell stock name $name,quantity $quantity");
  }
}

class BuyStock implements Order {
  Stock abcStock;
  BuyStock(this.abcStock);

  @override
  void execute() {
    abcStock.buy();
  }
}

class SellStock implements Order {
  Stock abcStock;
  SellStock(this.abcStock);

  @override
  void execute() {
    abcStock.sell();
  }
}

class Broker {
  List<Order> orderList = <Order>[];
  void takeOrder(Order order) {
    orderList.add(order);
  }

  void placeOrders() {
    for (Order order in orderList) {
      order.execute();
    }
    orderList.clear();
  }
}

void main(List<String> args) {
  Stock abcStock = Stock();
  BuyStock buyStockOrder = BuyStock(abcStock);
  SellStock sellStockOrder = SellStock(abcStock);

  Broker broker = Broker();
  broker.takeOrder(buyStockOrder);
  broker.takeOrder(sellStockOrder);

  broker.placeOrders();
}