Laravel Observers: A Practical Guide with Step-by-Step Example

What Are Model Observers?

Observers provide a structured way to handle multiple Eloquent model events within a single class. They serve as centralized handlers for various model lifecycle events, keeping your code organized and maintainable.

 

When to Use Observers

Use observers when you need to:

• Handle multiple events for the same model.
• Keep your model classes clean by moving event logic elsewhere.
• Group related event handling logic together.
• Maintain better separation of concerns.

Observer Structure

Observer classes contain methods that correspond to Eloquent events: 

• Each method receives the affected model as its only argument.
• Method names match the event they handle (e.g., created, updated).
• You can implement only the methods you need.

Creating an Observer

The simplest way to generate an observer is using Artisan:

This command:

1. Creates a new observer class in app/Observers
2. Sets up method stubs for common events
3. Associates it with your specified model

Observer Method Examples

Here are some common observer methods:

 

Practical Example:

Let’s implement a complete observer for a User model that:

1. Sends a welcome email when a new user registers
2. Logs user profile updates
3. Cleans up related data when a user is deleted

Step 1: Create the Observer

Generate the observer using Artisan:

 

Step 2: Implement Observer Logic

 

Step 3: Register the Observer

Option 1 :- To register an observer, you may place the ObservedBy attribute on the corresponding model(Laravel 12):

 

Option 2 :- Add this to your AppServiceProvider (app/Providers/AppServiceProvider.php):

 

 

Step 4: Generating Mailables

1. Welcome Email:

 

Edit app/Mail/WelcomeEmail.php:

 

2. Email Template (resources/views/emails/welcome.blade.php):

 

Available Observer Methods

Here are all the methods you can implement in an observer:

 

 

Best Practices and Tips

1. Keep observers focused: Each observer should handle related tasks.
2. Avoid infinite loops: Don’t call save() inside saving/saved events.
3. Consider performance: Heavy operations in observers might slow down your application.
4. Use queued jobs: For time-consuming tasks like email sending.
5. Keep models clean: Move event-related logic to observers when it grows complex.

When to Use Observers vs. Events

• Use observers when you have multiple related events for a single model.
• Use events/listeners when you need more flexibility or want different handlers in different contexts.

Conclusion

Laravel observers provide a clean, organized way to handle model events. By following this pattern, you can:

• Keep your models lean and focused.
• Centralize related event logic.
• Make your code more maintainable.
• Easily test event-related functionality. 

 Remember to consider the performance implications of your observer logic and use queues for time-consuming operations.