Rails 3：如何识别观察者中的 after_commit 动作？ （创建/更新/销毁）

Question

我有一个观察者，我注册了一个after_commit 回调。 我如何判断它是否在创建或更新后被触发？ 我可以通过询问 item.destroyed? 来判断某个项目已被销毁，但 #new_record? 无法正常工作，因为该项目已保存。

我打算通过添加after_create/after_update 并在里面执行类似@action = :create 并检查after_commit 处的@action 来解决它，但似乎观察者实例是一个单例，我可能只需在它到达after_commit 之前覆盖一个值。所以我以一种更丑陋的方式解决了这个问题，在 after_create/update 上根据 item.id 将操作存储在地图中，并在 after_commit 上检查其值。真的很丑。

还有其他方法吗？

更新

正如@tardate 所说，transaction_include_action? 是一个很好的指示，尽管它是一个私有方法，并且在观察者中应该使用#send 访问它。

class ProductScoreObserver < ActiveRecord::Observer
  observe :product

  def after_commit(product)
    if product.send(:transaction_include_action?, :destroy)
      ...

很遗憾，:on 选项在观察者中不起作用。

只要确保你测试了你的观察者的地狱（如果你使用 use_transactional_fixtures，请寻找test_after_commit gem），所以当你升级到新的 Rails 版本时，你会知道它是否仍然有效。

（在 3.2.9 上测试）

更新 2

我现在使用 ActiveSupport::Concern 而不是观察者，after_commit :blah, on: :create 在那里工作。

Answer 1

我认为transaction_include_action? 是您所追求的。它提供了正在进行的特定交易的可靠指示（在 3.0.8 中验证）。

正式地，它确定事务是否包含用于 :create、:update 或 :destroy 的操作。用于过滤回调。

class Item < ActiveRecord::Base
  after_commit lambda {    
    Rails.logger.info "transaction_include_action?(:create): #{transaction_include_action?(:create)}"
    Rails.logger.info "transaction_include_action?(:destroy): #{transaction_include_action?(:destroy)}"
    Rails.logger.info "transaction_include_action?(:update): #{transaction_include_action?(:update)}"
  }
end

还可能是transaction_record_state 感兴趣，它可用于确定记录是在事务中创建还是销毁。状态应该是 :new_record 或 :destroyed 之一。

Rails 4 更新

对于那些寻求在 Rails 4 中解决问题的人，此方法现已弃用，您应该使用transaction_include_any_action?，它接受array 的操作。

用法示例：

transaction_include_any_action?([:create])

Answer 2

我今天了解到你可以这样做：

after_commit :do_something, :on => :create

after_commit :do_something, :on => :update

其中 do_something 是您要在某些操作上调用的回调方法。

如果您想为 update 和 create 调用相同的回调，而不是 destroy，您还可以使用： after_commit :do_something, :if => :persisted?

确实没有很好的记录，我很难用谷歌搜索它。幸运的是，我认识一些才华横溢的人。希望对您有所帮助！

Answer 3

您可以使用两种技术来解决。

• @nathanvda 建议的方法，即检查 created_at 和 updated_at。如果它们相同，则新创建记录，否则更新。

• 通过在模型中使用虚拟属性。步骤是：

  • 在模型中添加一个字段，代码为attr_accessor newly_created

  • 将before_create 和before_update callbacks 中的相同更新为

    def before_create (record)
        record.newly_created = true
    end
    
    def before_update (record)
        record.newly_created = false
    end
    

Answer 4

基于 leenasn 的想法，我创建了一些模块，可以使用 after_commit_on_update 和 after_commit_on_create 回调：https://gist.github.com/2392664

用法：

class User < ActiveRecord::Base
  include AfterCommitCallbacks
  after_commit_on_create :foo

  def foo
    puts "foo"
  end
end

class UserObserver < ActiveRecord::Observer
  def after_commit_on_create(user)
    puts "foo"
  end
end

Answer 5

看一下测试代码：https://github.com/rails/rails/blob/master/activerecord/test/cases/transaction_callbacks_test.rb

在那里你可以找到：

after_commit(:on => :create)
after_commit(:on => :update)
after_commit(:on => :destroy)

和

after_rollback(:on => :create)
after_rollback(:on => :update)
after_rollback(:on => :destroy)

Answer 6

我用下面的代码判断是否是新记录：

previous_changes[:id] && previous_changes[:id][0].nil?

它基于新记录的默认 id 等于 nil 的想法，然后在保存时更改它。 当然 id 变化不是常见的情况，所以大多数情况下第二个条件可以省略。

Answer 7

我很想知道为什么你不能将你的 after_commit 逻辑移动到 after_create 和 after_update 中。后两个调用和after_commit 之间是否发生了一些重要的状态变化？

如果你的创建和更新处理有一些重叠的逻辑，你可以让后两个方法调用第三个方法，传入动作：

# Tip: on ruby 1.9 you can use __callee__ to get the current method name, so you don't have to hardcode :create and :update.
class WidgetObserver < ActiveRecord::Observer
  def after_create(rec)
    # create-specific logic here...
    handler(rec, :create)
    # create-specific logic here...
  end
  def after_update(rec)
    # update-specific logic here...
    handler(rec, :update)
    # update-specific logic here...
  end

  private
  def handler(rec, action)
    # overlapping logic
  end
end

如果您仍然更愿意使用 after_commit，您可以使用线程变量。只要允许对死线程进行垃圾回收，就不会泄漏内存。

class WidgetObserver < ActiveRecord::Observer
  def after_create(rec)
    warn "observer: after_create"
    Thread.current[:widget_observer_action] = :create
  end

  def after_update(rec)
    warn "observer: after_update"
    Thread.current[:widget_observer_action] = :update
  end

  # this is needed because after_commit also runs for destroy's.
  def after_destroy(rec)
    warn "observer: after_destroy"
    Thread.current[:widget_observer_action] = :destroy
  end

  def after_commit(rec)
    action = Thread.current[:widget_observer_action]
    warn "observer: after_commit: #{action}"
  ensure
    Thread.current[:widget_observer_action] = nil
  end

  # isn't strictly necessary, but it's good practice to keep the variable in a proper state.
  def after_rollback(rec)
    Thread.current[:widget_observer_action] = nil
  end
end

Answer 8

这类似于您的第一种方法，但它只使用一种方法（before_save 或 before_validate 真的很安全），我不明白为什么这会覆盖任何值

class ItemObserver
  def before_validation(item) # or before_save
    @new_record = item.new_record?
  end

  def after_commit(item)
    @new_record ? do_this : do_that
  end
end

更新

此解决方案不起作用，因为正如@eleano 所述，ItemObserver 是一个单例，它只有一个实例。因此，如果同时保存 2 个项目，@new_record 可以从 item_1 获取其值，而 after_commit 由 item_2 触发。为了克服这个问题，应该有一个item.id 检查/映射到“同步后”两个回调方法：hackish。

Answer 9

您可以将事件挂钩从 after_commit 更改为 after_save，以捕获所有创建和更新事件。然后你可以使用：

id_changed?

...观察者的助手。这将在创建时为真，在更新时为假。