Rails 3：如何識別觀察者中的after_commit動作？ （創建/更新/銷燬）

Question

我有一個觀察者，我註冊了一個after_commit回調。 如何判斷在創建或更新後是否被解僱？ 我可以通過詢問item.destroyed?來告訴某件物品被毀壞，但#new_record?自該物品被保存後不起作用。

我正要加入after_create/after_update解決它，這樣做@action = :create內，並檢查@action在after_commit，但似乎觀察者實例是單身，我可能只覆蓋一個值它到達之前after_commit。所以我以一種更醜陋的方式解決了這個問題，將action放在基於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 ::關注和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或：destroy。

更新爲Rails 4

對於那些尋求解決軌道4,5的問題，這種方法現在已經過時，你應該使用transaction_include_any_action?它接受的動作的array。

使用例：

transaction_include_any_action?([:create]) 

Answer 2

您可以將事件掛鉤從after_commit更改爲after_save，以捕獲所有創建和更新事件。您可以使用：

id_changed? 

...在觀察員中的助手。這在創建時是成立的，在更新時是錯誤的。

Answer 3

看看測試代碼：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 4

這類似於你的第一個辦法，但它僅使用一個方法（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是一個Singleton，它只有一個實例。因此，如果同時保存2個項目，@ new_record可以從item_1中取值，而after_commit由item_2觸發。爲了克服這個問題，應該有一個item.id檢查/映射到2個回調方法的「後同步」：hackish。

Answer 5

可以通過使用兩種技術解決。

• @nathanvda建議的方法，即檢查created_at和updated_at。如果它們相同，則記錄是新創建的，否則是其更新。

• 通過在模型中使用虛擬屬性。步驟是：

  • 在模型中before_create和before_update callbacks基於leenasn的想法添加一個字段代碼attr_accessor newly_created

  • 更新一樣

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

Answer 6

，我創建了一些模塊，可以使用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 7

我今天瞭解到，你可以做這樣的事情：

after_commit :do_something, :on => :create 

after_commit :do_something, :on => :update 

凡do_something是要在某些行動調用回調方法。

如果你想呼籲更新相同的回調和創建，但不破壞，你也可以使用： after_commit :do_something, :if => :persisted?

這真的不是記錄很好，我的日子不好過谷歌搜索它。幸運的是，我認識一些有才華的人。希望能幫助到你！

Answer 8

我很想知道爲什麼你不能將after_commit邏輯移動到after_create和after_update。在後兩個電話和after_commit之間是否發生了一些重要的狀態變化？

如果您創建和更新操作有一些重疊的邏輯，你可以只是後者的2個方法調用第三個方法，傳遞動作：

# 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 9

我用下面的代碼，以確定它是否是一個新的記錄或不：

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

它基於想法，一個新的記錄具有默認的ID等於零，然後改變它保存。 當然id變化不是一個常見的情況，所以在大多數情況下，第二個條件可以省略。