🎉🎉 Larasense is officially launched 🎉🎉
- Your Hub for Laravel News, Trends & Updates

3 Simple Ways to Use Eloquent Model Events in Laravel

laravel
tutorial
eloquent
Nabil Hassen
Nabil Hassen
Jan 9, 2025
3 Simple Ways to Use Eloquent Model Events in Laravel
Last updated on Jan 9, 2025
Table of contents:

Laravel's Eloquent ORM is a powerful tool for interacting with databases. One of its standout features is model events, which allow you to respond to specific actions performed on your models. In this blog post, we'll explore what Eloquent model events are, how to use them, and practical use cases—all in simple, beginner-friendly language.

What Are Eloquent Model Events in Laravel?

Eloquent model events let you execute code when certain actions happen to your models. For example, you can trigger specific logic when:

  • A record is created or updated.
  • A record is deleted or restored.
  • A record is fetched from the database.

These events help automate tasks such as logging, validating data, sending notifications, and more. Think of them as hooks you can use to tie additional functionality to the lifecycle of your database records.

Available Eloquent Model Events

Laravel provides events for various stages of a model's lifecycle:

  • retrieved: Triggered when a record is fetched from the database.
  • creating: Triggered before a new record is inserted into the database.
  • created: Triggered after a new record has been inserted.
  • updating: Triggered before an existing record is updated.
  • updated: Triggered after an existing record is updated.
  • saving: Triggered before a record is saved (this applies to both creating and updating).
  • saved: Triggered after a record is saved (this applies to both creating and updating).
  • deleting: Triggered before a record is deleted.
  • deleted: Triggered after a record is deleted.
  • restoring: Triggered before a soft-deleted record is restored.
  • restored: Triggered after a soft-deleted record is restored.

These events give you full control over your model's behavior at each stage of its lifecycle.

How to Use Eloquent Model Events

There are three main methods to handle Eloquent model events: using the $dispatchesEvents property, closures, and observers.

1. Using the $dispatchesEvents Property

Laravel allows you to map model events to custom event classes using the $dispatchesEvents property within your model. This approach is beneficial when you want to encapsulate event handling logic in separate classes, promoting cleaner and more maintainable code. It is important to note that for the events mapped here, you should define event listeners to handle the dispatched events.

Here's how you can define it:

use App\Events\UserCreated;
use Illuminate\Database\Eloquent\Model;
 
class User extends Model
{
protected $dispatchesEvents = [
'created' => UserCreated::class,
];
}

In this example:

  • When a new User model is created, the UserCreated event is dispatched automatically. You should also create an event listener for UserCreated to handle the logic associated with this event.

2. Using Closures

For straightforward event handling, you can define closures directly within your model's booted method. This method is ideal for simple logic that doesn't necessitate a separate event class.

Example:

use Illuminate\Database\Eloquent\Model;
 
class User extends Model
{
protected static function booted()
{
static::created(function ($user) {
// Logic to execute after a user is created
});
}
}

In this setup:

  • The closure within static::created executes immediately after a new user is created.

3. Using Observers

Observers allow you to group all your event handling logic into a single class, enhancing organization, especially when dealing with multiple events or models.

  • Defining an Observer

You can create an observer using the Artisan command:

php artisan make:observer UserObserver --model=User

This command generates an UserObserver class:

namespace App\Observers;
 
use App\Models\User;
 
class UserObserver
{
public function creating(User $user)
{
$user->username = strtolower($user->username);
}
 
public function updating(User $user)
{
if ($user->isDirty('email')) {
// Handle email changes
}
}
}
  • Registering Observers

There are two primary methods to register observers:

a. In AppServiceProvider:

Within the boot method of your AppServiceProvider, you can register the observer:

use App\Models\User;
use App\Observers\UserObserver;
 
public function boot()
{
User::observe(UserObserver::class);
}

b. As a PHP Attribute:

Alternatively, you can use PHP attributes to register observers directly within your model:

use App\Observers\UserObserver;
use Illuminate\Database\Eloquent\Attributes\ObservedBy;
 
#[ObservedBy(UserObserver::class)]
class User extends Model
{
// Model logic
}

This method offers a concise way to associate observers with models.

Practical Use Cases for Model Events

Here are some scenarios where Eloquent model events shine:

  1. Logging Changes

    • Track changes to important fields like user roles or account statuses.
  2. Sending Notifications

    • Notify users when their profile is updated or an order status changes.
  3. Maintaining Data Integrity

    • Automatically delete related records when a parent record is deleted.
  4. Enforcing Business Rules

    • Prevent certain actions like deleting admin accounts.

Best Practices for Using Model Events

  1. Keep Logic Simple: Avoid putting complex logic in event listeners. Instead, delegate tasks to service classes or jobs.
  2. Test Thoroughly: Ensure that your event listeners work correctly and don’t introduce bugs.
  3. Be Mindful of Performance: Long-running tasks in event listeners can slow down your application. Use Laravel’s queue system for such tasks.

Conclusion

Eloquent model events are a powerful way to hook into your models' lifecycle and execute custom logic. Whether you're logging changes, sending notifications, or enforcing rules, model events make your application smarter and more efficient. By using $dispatchesEvents, closures, or observers, you can implement event handling in a way that best suits your application’s needs. Try adding model events to your Laravel project today and see how they simplify your workflow!

Nabil Hassen
Nabil Hassen
Full Stack Web Developer

Stay Updated.

I'll you email you as soon as new, fresh content is published.

Thanks for subscribing to my blog.

Latest Posts

Larasenes Logo
Larasense
Stay updated on Laravel news, trends, and updates with curated content from top blogs, YouTube, and podcasts in a sleek, user-friendly design.