如何通过包含模块来包装 Ruby 方法的调用？

Question

当我的某些班级发生某些事情时，我希望收到通知。我想以这样的方式进行设置，使这些类中我的方法的实现不会改变。

我想我会有类似以下模块的东西：

module Notifications
  extend ActiveSupport::Concern

  module ClassMethods
    def notify_when(method)
      puts "the #{method} method was called!"
      # additional suitable notification code
      # now, run the method indicated by the `method` argument
    end
  end
end

然后我可以将它混合到我的类中，如下所示：

class Foo
  include Notifications

  # notify that we're running :bar, then run bar
  notify_when :bar

  def bar(...)  # bar may have any arbitrary signature
    # ...
  end
end

我的主要愿望是我不想修改 :bar 来获取通知工作正常。这可以做到吗？如果是这样，我将如何编写 notify_when 实现？

另外，我正在使用 Rails 3，所以如果有我可以使用的 ActiveSupport 或其他技术，请随时分享。 （我查看了 ActiveSupport::Notifications，但这需要我修改 bar 方法。）

---

我注意到我可能想使用“模块+超级技巧”。我不确定这是什么——也许有人可以启发我？

Answer 1

自从这里的这个问题一直活跃以来已经有一段时间了，但是还有另一种可能性通过包含（或扩展）的模块来包装方法。

从 2.0 开始，您可以前置模块，有效地使其成为前置类的代理。

在下面的示例中，调用扩展模块 module 的方法，并传递要包装的方法的名称。对于每个方法名称，都会创建一个新模块并添加到前面。这是为了代码简单。您还可以将多个方法附加到单个代理。

与使用 alias_method 和 instance_method（稍后绑定到 self）的解决方案的一个重要区别是，您可以在方法之前定义要包装的方法本身被定义。

module Prepender

  def wrap_me(*method_names)
    method_names.each do |m|
      proxy = Module.new do
        define_method(m) do |*args|
          puts "the method '#{m}' is about to be called"
          super *args
        end
      end
      self.prepend proxy
    end
  end
end

使用：

class Dogbert
  extend Prepender

  wrap_me :bark, :deny

  def bark
    puts 'Bah!'
  end

  def deny
    puts 'You have no proof!'
  end
end

Dogbert.new.deny

# => the method 'deny' is about to be called
# => You have no proof!

Answer 2

我想你可以使用别名方法链。

像这样的事情：

def notify_when(method)  
  alias_method "#{method}_without_notification", method
  define_method method do |*args|
    puts "#{method} called"
    send "#{method}_without_notification", args
  end
end

您不必使用这种方法自己修改方法。

Answer 3

我可以想到两种方法：

(1) 装饰 Foo 方法以包含通知。

(2) 使用代理对象来拦截对 Foo 的方法调用，并在发生时通知您

第一个解决方案是 Jakub 采取的方法，尽管 alias_method 解决方案不是实现此目的的最佳方法是使用此方法：

def notify_when(meth)  
  orig_meth = instance_method(meth)
  define_method(meth) do |*args, &block|
    puts "#{meth} called"
    orig_meth.bind(self).call *args, &block
  end
end

第二个解决方案要求您将 method_missing 与代理结合使用：

class Interceptor
  def initialize(target)
    @target = target
  end

  def method_missing(name, *args, &block)
    if @target.respond_to?(name)
      puts "about to run #{name}"
      @target.send(name, *args, &block)
    else
      super
    end
  end
end

class Hello; def hello; puts "hello!"; end; end

i = Interceptor.new(Hello.new)
i.hello #=> "about to run hello"
        #=> "hello!"

第一个方法需要修改方法（您说您不想要的东西）和第二种方法需要使用代理，这也许是您不想要的。抱歉，没有简单的解决方案。