¿Cuál es el propósito de la devolución de llamada around_create en el modelo de Rails?

Question

cuando se ejecuta el código de devolución de llamada around_create, ¿en qué situaciones deberíamos usarlo?

Answer 1

around_create se llama cuando se guarda un modelo con el indicador new?. Se puede usar para agregar datos para agregar/cambiar valores del modelo, llamar a otros métodos, etc ... No puedo pensar en un caso de uso específico para esta devolución de llamada, pero completa un conjunto de "antes, después, alrededor". call-backs para la acción de crear. Hay un conjunto de devolución de llamada similar "antes, después, alrededor" para encontrar, actualizar, guardar y eliminar eventos.

Answer 2

Tenía esta pregunta, también, y ahora he encontrado la respuesta: around_create le permite básicamente hacer un before_create y un after_create en un método. Tienes que usar yield para ejecutar el guardado en el medio.

class MyModel < ActiveRecord::Base 
    around_create :my_callback_method 

    private 
    def my_call_back_method 
     # do some "before_create" stuff here 

     yield # this makes the save happen 

     # do some "after_create" stuff here 
    end 
end 

Answer 3

Un caso de uso clásico para los filtros "en torno" es para medir el rendimiento, o registrar o hacer otros tipos de monitoreo o modificación del estado.

Answer 4

acaba de encontrar un caso de uso para mí:

imaginar una situación con vigilante polimórficos y el observador en algunos casos hay que realizar la acción antes de guardar y en otros casos después de ella.

Con alrededor de filtro puede capturar la acción de guardar en un bloque y ejecutarlo cuando lo necesite.

class SomeClass < ActiveRecord::Base 

end 

class SomeClassObserver < ActiveRecord::Observer 
    def around_create(instance, &block) 
    Watcher.perform_action(instance, &block) 
    end 
end 

# polymorphic watcher 
class Watcher 
    def perform_action(some_class, &block) 
    if condition? 
     Watcher::First.perform_action(some_class, &block) 
    else 
     Watcher::Second.perform_action(some_class, &block) 
    end 
    end 
end 

class Watcher::First 
    def perform_action(some_class, &block) 
    # update attributes 
    some_class.field = "new value" 

    # save 
    block.call 
    end 
end 

class Watcher::Second 
    def perform_action(some_class, &block) 
    # save 
    block.call 

    # Do some stuff with id 
    Mailer.delay.email(some_class.id) 
    end 
end 

Answer 5

Además Tom Harrison Jr's answer acerca del registro y seguimiento, estoy encontrando que el diferenciador clave es control de ganancia sobre si o no la operación se ejecuta en absoluto. De lo contrario, puede implementar sus propias devoluciones de llamada before_* y after_* para hacer lo mismo.

Tome around_update, por ejemplo. Supongamos que tiene un caso en el que no desea que se ejecute la actualización. Por ejemplo, estoy construyendo una gema que guarda borradores en otra tabla drafts pero no guarda ciertas actualizaciones en la tabla "maestra".

around_update :save_update_for_draft 

private 

def save_update_for_draft 
    yield if update_base_record? 
end 

Los detalles del método update_base_record? referencia aquí realmente no importa. Puede ver que la operación de actualización simplemente no se ejecutará si ese método no se evalúa a true.