Nivel inicial7 min de lectura · Publicado el

Callbacks en Ruby on Rails: before_action y before_save

Callbacks en Ruby on Rails: before_save, before_create y after_save como alarmas del móvil programadas antes y después de guardar. Callbacks: saltan solosrubentejera.com before_savebefore_createafter_saveguardarsalta sola
Cada callback es una alarma programada alrededor de guardar: before_save y before_create (este, solo al crear) suenan antes de escribir en la base de datos, y after_save, después. Nadie las llama: saltan solas.

Hay tareas que se repiten antes o después de otras: buscar el artículo antes de mostrarlo, editarlo o borrarlo, o rellenar un campo antes de guardarlo. Los callbacks (a veces llamados hooks) te dejan «programar» esas tareas una vez para que Rails las ejecute en el momento justo: en los controladores, antes o después de una acción; en los modelos, alrededor de validar, guardar o borrar un registro.

Es como la alarma del móvil a las 7:00: no tienes que acordarte de mirar la hora, salta sola cuando toca.

Callbacks en controladores

Callback Cuándo se ejecuta
before_action Antes de la acción que pides
after_action Después de la acción
around_action Antes y después, envolviendo la acción

Y los puedes combinar con:

  • only: solo en las acciones que indiques.
  • except: en todas las acciones excepto las que indiques.

En este ejemplo, antes de show, edit, update y destroy se ejecuta el método privado set_article, que busca el artículo por su id:

class ArticlesController < ApplicationController
  before_action :set_article, only: %i[show edit update destroy]

  def index
    @articles = Article.all
  end

  def show
  end

  # new, create, edit, update, destroy…

  private

  def set_article
    @article = Article.find(params[:id])
  end
end

Callbacks en modelos

Se ejecutan alrededor del momento de validar y guardar un registro:

Callback Cuándo se ejecuta
before_validation Antes de validar el registro
before_save Antes de guardarlo, tanto al crearlo como al actualizarlo
before_create Antes de crearlo (solo la primera vez, nunca al actualizarlo)
after_create Después de crearlo
after_save Después de guardarlo

Hay más (before_update, after_destroy, after_commit…). Para ver el orden real, basta un modelo que escriba el nombre de cada callback cuando salta. Al crear un registro con create!, la salida es esta:

before_validation
after_validation
before_save
before_create
after_create
after_save
after_commit

Y al actualizarlo con update!, los de create se cambian por los de update:

before_validation
after_validation
before_save
before_update
after_update
after_save
after_commit

after_commit es el último porque espera a que la transacción se confirme en la base de datos. Por eso es el sitio para avisar a otros sistemas o encolar un correo: si el guardado falla, no se ejecuta.

before_validation corre justo antes de las validaciones de Active Record.

Ejemplo

Antes de crear cada artículo, total_quantity se pone a 0:

class Article < ApplicationRecord
  before_save   :log_save
  before_create :set_total_quantity

  private

  def log_save
    Rails.logger.info("Voy a guardar el artículo #{title}")
  end

  def set_total_quantity
    self.total_quantity = 0
  end
end

Para escribir mensajes, usa Rails.logger en vez de puts: respeta el nivel y el formato del log de cada entorno, así que los mensajes acaban en el mismo sitio que el resto del log de la aplicación.

Compruébalo con un test

Un callback se ejecuta sin que nadie lo llame, así que un test es la forma de dejar escrito qué hace y cuándo. Estos dos comprueban el before_create de arriba: que salta al crear y que no vuelve a saltar al actualizar.

require "test_helper"

class ArticleCallbacksTest < ActiveSupport::TestCase
  test "al crear, before_create pone total_quantity a 0" do
    article = Article.create!(title: "Nuevo", total_quantity: 99)

    assert_equal 0, article.reload.total_quantity
  end

  test "al actualizar, before_create no vuelve a ejecutarse" do
    article = Article.create!(title: "Nuevo")
    article.update!(total_quantity: 5)

    assert_equal 5, article.reload.total_quantity
  end
end
bin/rails test test/models/article_callbacks_test.rb
2 runs, 2 assertions, 0 failures, 0 errors, 0 skips

El primer test también enseña algo que sorprende: aunque pases total_quantity: 99, el callback lo pisa. Si eso no es lo que quieres, el test te lo dice antes que un usuario.

Contar visitas sin callbacks

El original sumaba una visita cada vez que se mostraba el artículo con update(visits_count: visits_count + 1). Eso ejecuta todas las validaciones y callbacks del modelo solo para sumar 1. increment! lo hace más directo:

class ArticlesController < ApplicationController
  def show
    @article.update_visits_count
  end
end

class Article < ApplicationRecord
  def update_visits_count
    increment!(:visits_count)
  end
end

La guía de Rails incluye increment! entre los métodos que se saltan los callbacks y las validaciones, justo lo que quieres aquí.

Un callback debería hacer poco y que se note.

Errores frecuentes

1. Devolver false para cancelar el guardado. En versiones antiguas de Rails, un before_save que devolvía false detenía el guardado. Rails 5.0 lo declaró obsoleto y hoy no tiene ningún efecto:

class ConFalse < ApplicationRecord
  self.table_name = "articles"
  before_save { false }
end

ConFalse.create(title: "x").persisted?  # => true: se ha guardado

Para cancelar, usa throw :abort. Entonces save devuelve false y save! lanza una excepción:

class ConAbort < ApplicationRecord
  self.table_name = "articles"
  before_save { throw :abort if title.blank? }
end

ConAbort.new(title: "").save  # => false
ConAbort.create!(title: "")
ActiveRecord::RecordNotSaved: Failed to save the record

Si lo que quieres es rechazar datos incorrectos con un mensaje para el usuario, no uses un callback: usa una validación.

2. Un before_action con except que alcanza a create. Es el fallo del ejemplo original, corregido arriba. Con except: [:index, :new], el método que busca el registro se ejecuta también en create, donde no hay id. Con el código de este artículo (find(params[:id])), la petición acaba en un 404. En el log, con un controlador de cursos:

ActiveRecord::RecordNotFound (Couldn't find Course without an ID):

En el scaffold de Rails 8, que busca con find(params.expect(:id)), el fallo es otro: expect echa en falta el id y la respuesta es un 400.

ActionController::ParameterMissing (param is missing or the value is empty or invalid: id):

Con only: y la lista de acciones que sí reciben id, una acción nueva no hereda el callback sin que lo decidas.

3. Contar con un callback que no salta. update_column, update_all, increment!, delete o insert_all, entre otros, escriben en la base de datos sin ejecutar callbacks ni validaciones. Con el modelo que imprime cada callback, ni update_column(:title, "z") ni increment!(:visits_count) sacan una sola línea. Va bien para contar visitas, pero si una regla importante vive en un callback, estos métodos se la saltan.

Cuándo no usar callbacks

Los callbacks se ejecutan sin que nadie los llame en el código que estás leyendo. Si encadenas muchos (enviar correos, avisar a otros sistemas, tocar otros modelos), un simple save hace cosas que nadie espera y los tests se complican. Para lógica que se comparte entre varios modelos o controladores, mira también los concerns en Ruby on Rails.

Para borrar los hijos al borrar el padre no hace falta un callback: basta dependent: :destroy en la asociación.

Ejercicio de cinco minutos

  1. Escribe un test que cree un artículo con el título " hola " y espere "hola". Comprueba que falla.
  2. Haz que pase con un before_validation que quite los espacios (self.title = title&.strip).
  3. Añade un test que actualice el título con update_column y comprueba que los espacios se quedan: así verás qué métodos se saltan el callback.

Fuentes

Comprobado en noviembre de 2026 en las guías oficiales de Rails 8.1.4.1: Active Record Callbacks (lista y orden de callbacks, throw :abort, RecordNotSaved y métodos que se los saltan) y Action Controller Overview (before_action, after_action, around_action). Que devolver false quedó obsoleto en Rails 5.0 está en sus notas de la versión. El uso de only: %i[show edit update destroy] coincide con el scaffold que genera Rails 8.1.4.1.

Ejecutado el 11 de noviembre de 2026 en Docker con la imagen oficial ruby:3.4 (Ruby 3.4.12), Rails 8.1.4.1 y SQLite: el orden de los callbacks al crear y al actualizar, el test del before_create, false frente a throw :abort, update_column e increment! sin callbacks, y un before_action con except: [:index, :new] en el controlador de un scaffold, con find(params[:id]) (404 por RecordNotFound) y con el find(params.expect(:id)) que genera Rails 8.1 (400 por ParameterMissing).