命令模式

说明

命令模式的基本概念是，将动作分离为单独的对象，并且作为参数传递它们

出发点

假设我们有一连串的动作或事务被封装为对象。 我们希望这些动作或命令在以后的不同时间以某种顺序执行或调用， 这些命令也可以作为某些事件的结果被触发。例如，当用户按下某个按钮，或某个数据包到达时。 此外，这些命令应该可以撤销。这对于编辑器的操作可能很有用。我们可能想存储命令日志， 这样，如果系统崩溃，我们可以在之后重新应用这些修改。

示例

定义两个数据库操作，建表和加字段。每个操作都是一个命令，它知道如何撤销命令。例如，删表和删字段。当用户调用数据库迁移操作时，每条命令都会按照定义的顺序执行。而当用户调用回滚操作时，整个命令集会以相反的顺序调用。

使用trait对象

我们定义了一个trait，将我们的命令封装成两个操作，execute和rollback。所有命令结构体必须实现这个trait。

  1. pub trait Migration {
  2.     fn execute(&self) -> &str;
  3.     fn rollback(&self) -> &str;
  4. }
  6. pub struct CreateTable;
  7. impl Migration for CreateTable {
  8.     fn execute(&self) -> &str {
  9.         "create table"
  10.     }
  11.     fn rollback(&self) -> &str {
  12.         "drop table"
  13.     }
  14. }
  16. pub struct AddField;
  17. impl Migration for AddField {
  18.     fn execute(&self) -> &str {
  19.         "add field"
  20.     }
  21.     fn rollback(&self) -> &str {
  22.         "remove field"
  23.     }
  24. }
  26. struct Schema {
  27.     commands: Vec<Box<dyn Migration>>,
  28. }
  30. impl Schema {
  31.     fn new() -> Self {
  32.         Self { commands: vec![] }
  33.     }
  35.     fn add_migration(&mut self, cmd: Box<dyn Migration>) {
  36.         self.commands.push(cmd);
  37.     }
  39.     fn execute(&self) -> Vec<&str> {
  40.         self.commands.iter().map(|cmd| cmd.execute()).collect()
  41.     }
  42.     fn rollback(&self) -> Vec<&str> {
  43.         self.commands
  44.             .iter()
  45.             .rev() // reverse iterator's direction
  46.             .map(|cmd| cmd.rollback())
  47.             .collect()
  48.     }
  49. }
  51. fn main() {
  52.     let mut schema = Schema::new();
  54.     let cmd = Box::new(CreateTable);
  55.     schema.add_migration(cmd);
  56.     let cmd = Box::new(AddField);
  57.     schema.add_migration(cmd);
  59.     assert_eq!(vec!["create table", "add field"], schema.execute());
  60.     assert_eq!(vec!["remove field", "drop table"], schema.rollback());
  61. }

使用函数指针

我们可以采用另一种方法。将每个单独的命令创建为不同的函数，并存储函数指针, 以便以后在不同的时间调用这些函数。因为函数指针实现了Fn、 FnMut和FnOnce这三个特性，我们也可以传递和存储闭包。

  1. type FnPtr = fn() -> String;
  2. struct Command {
  3.     execute: FnPtr,
  4.     rollback: FnPtr,
  5. }
  7. struct Schema {
  8.     commands: Vec<Command>,
  9. }
  11. impl Schema {
  12.     fn new() -> Self {
  13.         Self { commands: vec![] }
  14.     }
  15.     fn add_migration(&mut self, execute: FnPtr, rollback: FnPtr) {
  16.         self.commands.push(Command { execute, rollback });
  17.     }
  18.     fn execute(&self) -> Vec<String> {
  19.         self.commands.iter().map(|cmd| (cmd.execute)()).collect()
  20.     }
  21.     fn rollback(&self) -> Vec<String> {
  22.         self.commands
  23.             .iter()
  24.             .rev()
  25.             .map(|cmd| (cmd.rollback)())
  26.             .collect()
  27.     }
  28. }
  30. fn add_field() -> String {
  31.     "add field".to_string()
  32. }
  34. fn remove_field() -> String {
  35.     "remove field".to_string()
  36. }
  38. fn main() {
  39.     let mut schema = Schema::new();
  40.     schema.add_migration(|| "create table".to_string(), || "drop table".to_string());
  41.     schema.add_migration(add_field, remove_field);
  42.     assert_eq!(vec!["create table", "add field"], schema.execute());
  43.     assert_eq!(vec!["remove field", "drop table"], schema.rollback());
  44. }

使用 Fn trait对象

最后，我们可以在vector中分别存储实现的每个命令，而不是定义一个命令trait。

  1. type Migration<'a> = Box<dyn Fn() -> &'a str>;
  3. struct Schema<'a> {
  4.     executes: Vec<Migration<'a>>,
  5.     rollbacks: Vec<Migration<'a>>,
  6. }
  8. impl<'a> Schema<'a> {
  9.     fn new() -> Self {
  10.         Self {
  11.             executes: vec![],
  12.             rollbacks: vec![],
  13.         }
  14.     }
  15.     fn add_migration<E, R>(&mut self, execute: E, rollback: R)
  16.     where
  17.         E: Fn() -> &'a str + 'static,
  18.         R: Fn() -> &'a str + 'static,
  19.     {
  20.         self.executes.push(Box::new(execute));
  21.         self.rollbacks.push(Box::new(rollback));
  22.     }
  23.     fn execute(&self) -> Vec<&str> {
  24.         self.executes.iter().map(|cmd| cmd()).collect()
  25.     }
  26.     fn rollback(&self) -> Vec<&str> {
  27.         self.rollbacks.iter().rev().map(|cmd| cmd()).collect()
  28.     }
  29. }
  31. fn add_field() -> &'static str {
  32.     "add field"
  33. }
  35. fn remove_field() -> &'static str {
  36.     "remove field"
  37. }
  39. fn main() {
  40.     let mut schema = Schema::new();
  41.     schema.add_migration(|| "create table", || "drop table");
  42.     schema.add_migration(add_field, remove_field);
  43.     assert_eq!(vec!["create table", "add field"], schema.execute());
  44.     assert_eq!(vec!["remove field", "drop table"], schema.rollback());
  45. }

讨论

如果我们的命令很小，可以定义成函数，或作为闭包传递，那么使用函数指针可能更好， 因为它不需要动态分发。但如果我们的命令是个完整的结构， 有一堆函数和变量被分别定义为独立的模块，那么使用trait对象会更合适。 有个应用实例是actix， 它在为例程注册handler函数时使用了trait对象。在使用Fn trait对象时， 我们可以用和函数指针相同的方式创建和使用命令。

说到性能，在性能和代码的简易性、组织性间我们总需要权衡。 静态分发可以提供更好的性能，而动态分发在我们组织应用程序时提供了灵活性。

参见