Observers in Laravel 11

Photo by Ilya Pavlov on Unsplash

Laravel continues to pave the way for elegant web development with its robust array of features designed to streamline complex tasks. One such feature, often overlooked but incredibly powerful, is the observer class in Laravel. Observers in Laravel allow developers to listen and react to various model events in a clean and organized manner. In this article, we will delve into the concept of observers, their implementation, and best practices, particularly focusing on the newly released Laravel 11.

https://laravel.com/docs/11.x/eloquent#observers

What is an Observer in Laravel?

In Laravel, an observer class acts as a central place where you can group event listeners for a particular model. This means you can neatly manage events like creating, updating, deleting, and restoring models without cluttering your application logic. Observers are particularly useful when you want to execute code in response to model lifecycle changes, thereby adhering to the SOLID principles of object-oriented design.

Creating Observers

Creating an observer in Laravel 11 is straightforward thanks to the artisan CLI. To generate an observer, you use the make:observer command. For instance, to create an observer for the User model, you would run:

php artisan make:observer UserObserver --model=User

This command scaffolds a new UserObserver class in the app/Observers directory. If the directory doesn't exist, Laravel's artisan will handle its creation. Here’s how a freshly minted observer looks like:

<?php

namespace App\Observers;
use App\Models\User;
class UserObserver
{
    public function created(User $user): void {
        // Code to run after a user is created
    }
    public function updated(User $user): void {
        // Code to run after a user is updated
    }
    public function deleted(User $user): void {
        // Code to run after a user is deleted
    }
    public function restored(User $user): void {
        // Code to run after a user is restored
    }
    public function forceDeleted(User $user): void {
        // Code to run after a user is permanently deleted
    }
}

Registering Observers

To activate an observer, you need to register it with the model it should observe. Laravel 11 introduces a more declarative approach with the ObservedBy attribute, allowing for a cleaner and more expressive way to link observers to models:

use App\Observers\UserObserver;
use Illuminate\Database\Eloquent\Attributes\ObservedBy;

#[ObservedBy([UserObserver::class])]
class User extends Authenticatable {
    // Model methods here
}

Alternatively, you can manually register an observer in your AppServiceProvider:

use App\Models\User;
use App\Observers\UserObserver;

public function boot(): void {
    User::observe(UserObserver::class);
}

Observers and Database Transactions

A new feature in Laravel 11 is handling observers within database transactions. Observers can be instructed to only execute their event handlers after the database transaction is committed, using the ShouldHandleEventsAfterCommit interface:

namespace App\Observers;

use App\Models\User;
use Illuminate\Contracts\Events\ShouldHandleEventsAfterCommit;
class UserObserver implements ShouldHandleEventsAfterCommit {
    public function created(User $user): void {
        // This will only run after the transaction is committed
    }
}

Best Practices with Observers

When using observers, keep in mind the following best practices:

• Keep it Light: Observers should handle light tasks to avoid performance issues. Heavy processing should be offloaded to jobs.
• Single Responsibility Principle: Each observer method should handle one specific task or set of tasks.
• Testing: Always write tests for your observer methods to ensure they work as expected without side effects.

Conclusion

Observers in Laravel 11 offer a robust, elegant way to manage model events cleanly and concisely. By leveraging the full capabilities of observers, developers can write more maintainable, scalable, and cleaner code, adhering to modern best practices in software development. As you continue to explore Laravel 11, consider integrating observers into your models to keep your code organized and focused on its core responsibilities.