Обработчики событий Active Record

Обработчики событий — это крючки в жизненном цикле объекта Active Record, которые позволяют запускать логику до или после изменения состояния объекта. Это можно использовать, чтобы убедиться, что связанные и зависимые объекты удаляются при вызове ActiveRecord::Base#destroy (переопределяя before_destroy) или для обработки атрибутов перед валидацией (переопределяя before_validation). В качестве примера обработчиков, запущенных при вызове ActiveRecord::Base#save для нового записи, рассмотрим:

• (-) save

• (-) valid

• (1) before_validation

• (-) validate

• (2) after_validation

• (3) before_save

• (4) before_create

• (-) create

• (5) after_create

• (6) after_save

• (7) after_commit

Также обработчик after_rollback может быть настроен для запуска всякий раз, когда выполняется откат. Подробнее об after_commit и after_rollback см. в разделе ActiveRecord::Transactions.

Кроме того, обработчик after_touch запускается всякий раз, когда объект изменяется.

Наконец, обработчики after_find и after_initialize запускаются для каждого объекта, который находится и создается с помощью поиска, при этом after_initialize запускается после создания новых объектов.

Всего есть девятнадцать обработчиков, которые предоставляют огромные возможности для реакции и подготовки к каждому этапу жизненного цикла Active Record. Последовательность вызова ActiveRecord::Base#save для существующей записи аналогична, за исключением того, что каждый обработчик _create заменяется соответствующим обработчиком _update.

Примеры:

class CreditCard < ActiveRecord::Base
  # Strip everything but digits, so the user can specify "555 234 34" or
  # "5552-3434" and both will mean "55523434"
  before_validation(on: :create) do
    self.number = number.gsub(/[^0-9]/, "") if attribute_present?("number")
  end
end

class Subscription < ActiveRecord::Base
  before_create :record_signup

  private
    def record_signup
      self.signed_up_on = Date.today
    end
end

class Firm < ActiveRecord::Base
  # Disables access to the system, for associated clients and people when the firm is destroyed
  before_destroy { |record| Person.where(firm_id: record.id).update_all(access: 'disabled')   }
  before_destroy { |record| Client.where(client_of: record.id).update_all(access: 'disabled') }
end

Наследуемые очереди обработчиков

Помимо переопределяемых методов обработчиков, также можно регистрировать обработчики с помощью макросов обработчиков. Их основное преимущество заключается в том, что макросы добавляют поведение в очередь обработчиков, которая сохраняется в иерархии наследования.

class Topic < ActiveRecord::Base
  before_destroy :destroy_author
end

class Reply < Topic
  before_destroy :destroy_readers
end

Теперь, когда выполняется Topic#destroy, вызывается только destroy_author. Когда выполняется Reply#destroy, вызываются оба destroy_author и destroy_readers. Сравните это со следующей ситуацией, когда переопределяется метод before_destroy:

class Topic < ActiveRecord::Base
  def before_destroy() destroy_author end
end

class Reply < Topic
  def before_destroy() destroy_readers end
end

В этом случае Reply#destroy будет вызывать только destroy_readers и не destroy_author. Поэтому используйте макросы обработчиков, когда хотите гарантировать, что определенный обработчик вызывается для всей иерархии, и используйте обычные переопределяемые методы, когда хотите предоставить каждому потомку решение о том, хочет ли он вызвать super и запустить унаследованные обработчики.

ВАЖНО: Чтобы наследование работало для очередей обработчиков, необходимо указать обработчики перед указанием ассоциаций. В противном случае может произойти загрузка дочернего элемента перед тем, как родитель зарегистрирует обработчики, и они не будут унаследованы.

Типы обработчиков

Макросы обработчиков принимают четыре типа обработчиков: ссылки на методы (Method ссылки (символ)), объекты обратного вызова, встроенные методы (с помощью proc). Ссылки на методы и объекты обратного вызова являются рекомендуемыми подходами; встроенные методы с помощью proc иногда подходят (например, для создания миксов).

Обработчики, ссылающиеся на метод, работают путем указания защищенного или закрытого метода, доступного в объекте, например:

class Topic < ActiveRecord::Base
  before_destroy :delete_parents

  private
    def delete_parents
      self.class.delete_all "parent_id = #{id}"
    end
end

Объекты обратного вызова имеют методы, названные в честь вызываемого обработчика, с записью в качестве единственного параметра, например:

class BankAccount < ActiveRecord::Base
  before_save      EncryptionWrapper.new
  after_save       EncryptionWrapper.new
  after_initialize EncryptionWrapper.new
end

class EncryptionWrapper
  def before_save(record)
    record.credit_card_number = encrypt(record.credit_card_number)
  end

  def after_save(record)
    record.credit_card_number = decrypt(record.credit_card_number)
  end

  alias_method :after_initialize, :after_save

  private
    def encrypt(value)
      # Secrecy is committed
    end

    def decrypt(value)
      # Secrecy is unveiled
    end
end

Таким образом, вы указываете объект, которому нужно отправить сообщение при данном обработчике. Когда этот обработчик срабатывает, у объекта есть метод с именем отправленного сообщения. Вы можете сделать эти обработчики более гибкими, передавая другие данные инициализации, такие как имя атрибута, с которым нужно работать:

class BankAccount < ActiveRecord::Base
  before_save      EncryptionWrapper.new("credit_card_number")
  after_save       EncryptionWrapper.new("credit_card_number")
  after_initialize EncryptionWrapper.new("credit_card_number")
end

class EncryptionWrapper
  def initialize(attribute)
    @attribute = attribute
  end

  def before_save(record)
    record.send("#{@attribute}=", encrypt(record.send("#{@attribute}")))
  end

  def after_save(record)
    record.send("#{@attribute}=", decrypt(record.send("#{@attribute}")))
  end

  alias_method :after_initialize, :after_save

  private
    def encrypt(value)
      # Secrecy is committed
    end

    def decrypt(value)
      # Secrecy is unveiled
    end
end

before_validation* возвращаемые операторы

Если обработчик before_validation вызывает :abort, процесс будет прерван, и ActiveRecord::Base#save вернет false. Если вызвать ActiveRecord::Base#save!, будет поднято исключение ActiveRecord::RecordInvalid. Ничего не будет добавлено к объекту ошибок.

Отмена обработчиков

Если обработчик before_* вызывает :abort, все последующие обработчики и связанное действие отменяются. Обработчики обычно выполняются в порядке их определения, за исключением обработчиков, определенных как методы модели, которые вызываются последними.

Порядок выполнения обработчиков

Иногда код требует, чтобы обработчики выполнялись в определенном порядке. Например, обработчик before_destroy (log_children в этом случае) должен выполняться до того, как дочерние элементы будут уничтожены опцией dependent: :destroy.

Рассмотрим код ниже:

class Topic < ActiveRecord::Base
  has_many :children, dependent: :destroy

  before_destroy :log_children

  private
    def log_children
      # Child processing
    end
end

В этом случае проблема заключается в том, что когда выполняется обработчик before_destroy, дочерние элементы недоступны, потому что обработчик ActiveRecord::Base#destroy выполняется первым. Вы можете использовать опцию prepend в обработчике before_destroy для предотвращения этого.

class Topic < ActiveRecord::Base
  has_many :children, dependent: :destroy

  before_destroy :log_children, prepend: true

  private
    def log_children
      # Child processing
    end
end

Таким образом, обработчик before_destroy выполняется до вызова dependent: :destroy, и данные по-прежнему доступны.

Также существуют случаи, когда вы хотите, чтобы несколько обработчиков одного типа выполнялись в порядке.

Например:

class Topic < ActiveRecord::Base
  has_many :children

  after_save :log_children
  after_save :do_something_else

  private

  def log_children
    # Child processing
  end

  def do_something_else
    # Something else
  end
end

В этом случае обработчик log_children выполняется до do_something_else. То же самое относится ко всем не транзакционным обработчикам.

Если есть несколько транзакционных обработчиков, как показано ниже, порядок меняется.

Например:

class Topic < ActiveRecord::Base
  has_many :children

  after_commit :log_children
  after_commit :do_something_else

  private

  def log_children
    # Child processing
  end

  def do_something_else
    # Something else
  end
end

В этом случае обработчик do_something_else выполняется до log_children.

Транзакции

Весь цепочку обработчиков вызова #save, #save! или #destroy выполняется в рамках транзакции. Это включает в себя обработчики after_*. Если все проходит успешно, после завершения цепочки выполняется COMMIT.

Если обработчик before_* отменяет действие, выполняется ROLLBACK. Вы также можете вызвать ROLLBACK, подняв исключение в любом из обработчиков, включая обработчики after_*. Однако в этом случае клиент должен об этом знать, так как обычный вызов #save вызовет такое исключение, а не тихо вернет false.

Отладка обработчиков

Цепочка обратного вызова доступна через метод _*_callbacks объекта. Обработчики Active Model поддерживают :before, :after и :around в качестве значений для свойства kind . Свойство kind определяет, в какой части цепочки выполняется обработчик.

Чтобы найти все обработчики в цепочке обратного вызова before_save:

Topic._save_callbacks.select { |cb| cb.kind.eql?(:before) }

Возвращает массив объектов обратного вызова, составляющих цепочку before_save.

Чтобы дополнительно проверить, содержит ли цепочка обратного вызова before_save proc, определенный как rest_when_dead, используйте свойство filter объекта обратного вызова:

Topic._save_callbacks.select { |cb| cb.kind.eql?(:before) }.collect(&:filter).include?(:rest_when_dead)

Возвращает true или false в зависимости от того, содержится ли proc в цепочке обратного вызова before_save для модели Topic.