Callbacks are a common way for you to execute code at specific times in the life cycle of an Active Record object, for instance just before it is created, after it is saved, or after it is destroyed. These can be very useful if you’ve got something to execute whenever an object hits one of those lifecycle points, like modifying the user’s email to be lowercase when creating her account. Callbacks are a way of saying something like “Hey Active Record, when you’ve finished creating a new User object, give me a call so I can run this method before anything else happens.”
This is a brief section on a useful topic. The Rails Guide reading provides good coverage of it, so my summary will be necessarily brief.
Look through these now and then use them to test yourself after doing the assignment:
Callbacks provide hooks into specific points (either before, after, or sometimes “around”) in the life cycle of an object. Those life cycle moments are:
#valid?
method.#all
, #first
, #find
). This is often triggered by Rails working with objects behind the scenes.You often get three choices for callbacks. Not all object lifecycle steps support all callbacks, but the basic three are (using create
as an example):
before_create
– Runs the method before the stated actionafter_create
– Runs the method after the stated actionaround_create
– A bit trickier. In this one, you will write a method which actually yield
s at some point to the original action. That way you can have code before it and after it and YOU decide at which point the original action gets done. Not entirely common.To use a callback, you need to “register” it at the top of your Model by using the appropriate method (e.g. before_create
). You pass that method either a symbol which corresponds to a method name or you could just write the callback as a block then and there. Rails will hang onto that method and call it at the appropriate time. For example:
# app/models/user.rb
class User < ActiveRecord::Base
before_create do |user|
puts "about to create #{user.name}"
end
after_create :just_created
private
def just_created
puts "just created a user"
end
end
Callbacks give you several options for narrowing down or selecting specifically when you want them to run. If you only want to run a callback when a particular controller action calls it, use the :on
option, which takes either a single symbol or a full array, e.g. before_create :run_code, :on => [:create, :update]
.
You can also use conditional logic options :if
and :unless
to try a method before running callbacks, for instance:
before_create :run_code, :unless => :method_is_true
private
def method_is_true
true
end
Sometimes your Rails app will need to interact with an external application (which is inherently imperfect) as a part of the save process. Other times your save will involve juggling several balls at once and, if one fails, they all need to be rolled back. Typically these cases will involve wrapping your database save operation in a “transaction,” which means that either all the steps work or they all fail and are rolled back.
The commit
ting of a transaction and its potential rollback
if it fails are both lifecycle events that you can latch onto with callbacks, e.g. after_commit
and before_rollback
. This is uncommon, so consider it another one of those “just remember that it’s an option” type things.
Callbacks are useful and many, like :after_create
and :before_destroy
, are pretty common. There’s no rocket science here, just a helpful concept.
This section contains helpful links to other content. It isn’t required, so consider it supplemental.
This section contains questions for you to check your understanding of this lesson. If you’re having trouble answering the questions below on your own, review the material above to find the answer.
5-6 months
Job Guarantee
1-on-1 Mentorship