Ruby 中的命令模式

Question

我喜欢 Ruby，并且正在学习设计模式。这是命令模式的示例。领域模型如下：

• Command - 所有命令的通用接口
• OnCommand、OffCommand - 实现 Command 接口的特定命令，都使用 TV 对象作为接收器
• 按钮 - 使用 Command 对象获取结果
• RemoteContol - 客户端，初始化 Button 和 Command 对象 Button - 使用 Command 对象执行命令
• 电视 - 接收命令

这里是这个问题的一些代码：

class TV
  def on
    puts 'TV is on'
  end

  def off
    puts 'TV is off'
  end
end

class Command
  class Error < StandardError; end

  def execute
    raise Error
  end
end

class OnCommand < Command
  attr_reader :tv

  def initialize(tv)
    @tv = tv
  end

  def execute
    tv.on
  end
end

class OffCommand < Command
  attr_reader :tv

  def initialize(tv)
    @tv = tv
  end

  def execute
    tv.off
  end
end

class Button
  attr_reader :command

  def initialize(command)
    @command = command
  end

  def execute_command
    command.execute
  end
end

class RemoteControl
  attr_reader :tv

  def initialize(tv)
    @tv = tv
    @buttons = {
      on: Button.new(OnCommand.new(tv)),
      off: Button.new(OffCommand.new(tv))
    }
  end

  def use_button(name)
    button(name).execute_command
  end

  private

  def button(name)
    @buttons.fetch name
  end
end

这是用法示例：

tv = TV.new                                                                                                             
remote_control = RemoteControl.new(tv)                                                                                  
remote_control.use_button(:on) # TV is on                                                                                         
remote_control.use_button(:off) # TV is off 

我对命令模式的理解程度如何？这是一个很好的例子吗？

感谢任何想法

更新

我想将 TV 替换为 InfraredTransmitter 作为命令接收器将使示例更合适。因为只有电视本身才能执行“on”命令。 RemoteControl 可以物理访问其红外发射器，该发射器能够向电视发送不同的命令。

Answer 1

Command 不应有对TV 的任何引用。这里不是命令，它是tv-only命令。这是更红宝石的方法：

class Command
  def call(*args, &cb)
    target, command, *rest = *args
    target.public_send command, *rest, &cb
  end
end

%i|on off|.each do |command|
  const_set("Command#{command.to_s.capitalize}", Class.new(Command) do
    def call(*args, &cb)
      target, *rest = *args
      super(target, command, *rest, &cb)
    end
  end
end

class Button
  attr_reader :command

  def initialize(command) # accepts :on, "on", CommandOn
    @command = case command
               when Class then command
               when Symbol, String
                 const_get("Command#{command.to_s.capitalize}")
               end.new
  end

  def call(target, *args, &cb)
    command.(target, *args, &cb)
  end
end

class RemoteControl
  def initialize(tv)
    @tv = tv
    @buttons = %i|on off|.map { |c| [c, Button.new(c)] }.to_h
  end
  def call(command)
    @buttons[command].(@tv)
  end
end

remote_control = RemoteControl.new(TV.new)
remote_control.(:on)
remote_control.(:off)

通过这种方法，Command 可以被重复用于任何其他目标，而无需声明新的Command。它必须与目标无关，否则它不是通用的Command 模式。

---

正如@Aetherus 所指出的，在这种方法中，这里根本不需要超类。上面的Command 可能会被安全删除，除非你有一些通用的逻辑要放在那里。

Answer 2

您不需要超类Command。只需定义那些具体的命令。这就是动态编程语言做事的方式。他们不关心类型。他们只关心对象是否具有所需的方法。

Answer 3

我看是对的。
Command 模式有以下参与者：

Command – 声明用于执行操作的接口
ConcreteCommand – 定义 Receiver 对象和操作之间的绑定
Client – 创建一个 ConcreteCommand 对象并设置其接收者
Invoker – 要求命令执行请求
Receiver – 知道如何执行相关操作执行请求

因此，在您的示例中，Command 是 Command，OnCommand，OffCommand 是 ConcreteCommand( s)，TV 是 Receiver，Button 是 Invoker，RemoteControl > 是客户。