Laravel Events & Listeners: A Practical Tutorial

Q: How do I create an event in Laravel?

Run the following command to generate an event class: php artisan make: event EventName

Priyanka Dhokia — Mon, 24 Feb 2025 11:21:02 +0000

Quick Summary

Laravel events provide a highly effective way of writing modular, maintainable applications through event-driven programming. This guides you through the fundamentals of Laravel events, from creating them to event handling through listeners and observers. Whether you’re new to Laravel or a seasoned developer, this guide will help you maximize the potential of Laravel events in your projects.

Table of Content

Introduction
What are Laravel Events, Listeners, and Observers?
Step-by-Step Implementation of Laravel Events
- Step 1: Create a Laravel Project
- Step 2: Configure the Database
- Step 3: Create a Registration Controller
- Step 4: Create a Registration View
- Step 5: Create an Event
- Step 6: Create a Listener
- Step 7: Create an Observer
- Step 8: Create a Mailable
- Step 9: Create an Email Template
- Step 10: Define Routes
Conclusion
FAQs

Introduction

Laravel’s event system allows developers to create scalable, decoupled applications by separating different aspects of an application into events and listeners. Events can be used to execute tasks such as sending mail, logging actions, or broadcasting real-time updates asynchronously, improving the application’s performance. In this blog, we will explain how to use event and listener in Laravel effectively.

What are Laravel Events, Listeners, and Observers?

In Laravel, Listeners, Observers, and Events all have their roles in controlling applications’ workflow. Events provide a mechanism to trigger specific actions based on predefined occurrences. Listeners respond to these events and execute necessary tasks, while Observers monitor model changes and automate repetitive tasks. Understanding these components helps in structuring applications for better maintainability and performance.

Events: Events in Laravel make it easier to handle several tasks asynchronously by separating concerns. Instead of executing all logic in one point, events allow tasks to be broken into smaller, manageable units.

Listeners: Listeners execute tasks in the background when an event is triggered, improving the application’s performance. They ensure that responses to events are handled separately. Many developers rely on a Laravel listener to optimize how events are managed within their applications.

Observers: Observers listen for particular model events, like creating, updating, or deleting, and execute actions automatically. This increases code reusability by using the same logic for different models.

Step-by-Step Implementation of Laravel Events

Implementing Laravel Events involves setting up a structured workflow where different components work together seamlessly. This step-by-step guide will walk you through the whole process, from starting a Laravel project to configuring events and listeners effectively. These steps will assist you in using Laravel’s event-driven functionality to develop scalable and maintainable apps.

Step 1: Create a Laravel Project

First, create a new Laravel project using the following command:

composer create-project --prefer-dist laravel/laravel laravel-event cd laravel-event

cd laravel-event

Step 2: Configure the Database

Set up the database configuration in the .env file:

    DB_CONNECTION=mysql
    DB_HOST=127.0.0.1
    DB_PORT=3306
    DB_DATABASE=user_registration
    DB_USERNAME=root
    DB_PASSWORD=password

Run the migration command to create the necessary database tables:

php artisan migrate

For an improved user interface, you can optionally install Tailwind CSS.

Step 3: Create a Registration Controller

Generate a new controller for user registration:

php artisan make: controller Auth/RegisterController

The file will be created at App/Http/Controllers/Auth/RegisterController.php.

Inside this controller, define methods to handle GET requests (display the registration form) and POST requests (store user information and send emails).

RegisterController.php

    
    namespace App\Http\Controllers\Auth;
    use App\Http\Controllers\Controller;
    use Illuminate\Http\Request;
    use Illuminate\Support\Facades\Hash;
    use Illuminate\Support\Facades\Validator;
    use App\Models\User;
    use App\Events\UserRegistered;
    class RegisterController extends Controller
    {
        public function showRegistrationForm()
        {
            return view('auth.register');
        }
        public function register(Request $request)
        {
            $validator = Validator::make($request->all(), [
                'name' => 'required|string|max:255',
                'email' => 'required|string|email|max:255|unique:users',
                'password' => 'required|string|min:8|confirmed',
            ]);
            if ($validator->fails()) {
                return back()->withErrors($validator)->withInput();
            }
            $user = User::create([
                'name' => $request->name,
                'email' => $request->email,
                'password' => Hash::make($request->password),
            ]);
            event(new UserRegistered($user));
            return redirect()->back()->with('success', 'Registration successful! Please check your email.');
        }
    }

Step 4: Create a Registration View

Generate a Blade view for the registration form:

php artisan make: view auth.register

The file will be located at resources/views/auth/register.blade.php.

register.blade.php

    
          @csrf
          
              Name
              
              @error('name')
                  {{ $message }}
              @enderror
          
          
              Email
              
              @error('email')
                  {{ $message }}
              @enderror
          
          
              Password
              
              @error('password')
                  {{ $message }}
              @enderror
          
          
              Confirm Password
              
              @error('password_confirmation')
                  {{ $message }}
              @enderror

Step 5: Create an Event

Generate a new event:

php artisan make: event UserRegistered

This will create a file at app/Events/UserRegistered.php.

UserRegistered.php

    
namespace App\Events;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
class UserRegistered
{
    use Dispatchable, InteractsWithSockets, SerializesModels;
    public $user;
    /**
     * Create a new event instance.
     */
    public function __construct($user)
    {
        $this->user = $user;
    }
}

Step 6: Create a Listener

Generate a listener to handle the UserRegistered event:

php artisan make: listener SendWelcomeEmail --event=UserRegistered

This will create app/Listeners/SendWelcomeEmail.php. A Laravel event listener ensures that specific actions are executed in response to the event.

SendWelcomeEmail.php

    
namespace App\Listeners;
use App\Events\UserRegistered;
use App\Mail\WelcomeEmail;
use Illuminate\Support\Facades\Mail;
class SendWelcomeEmail
{
  
    /**
     * Handle the event.
     */
    public function handle(UserRegistered $event): void
    {
        Mail::to($event->user->email)->send(new WelcomeEmail($event->user));
    }
}

Step 7: Create an Observer

Generate an observer to monitor user model events:

php artisan make: observer UserObserver --model=User

This observer will be located at app/Observers/UserObserver.php.

UserObserver.php

    
namespace App\Observers;
use App\Models\User;
class UserObserver
{
    /**
     * Handle the User "created" event.
     */
    public function created(User $user): void
    {
        \Log::info('A new user has been created: ' . $user->name);
    }
}

Step 8: Create a Mailable

Generate a mailable class for sending welcome emails:

php artisan make: mail WelcomeEmail

This will generate app/Mail/WelcomeEmail.php.

WelcomeEmail.php

    
namespace App\Mail;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;
class WelcomeEmail extends Mailable
{
    use Queueable, SerializesModels;
    /**
     * Create a new message instance.
     */
    public $user;
    public function __construct($user)
    {
        $this->user = $user;
    }
    /**
     * Get the message envelope.
     */
    public function build()
    {        return $this->view('emails.welcome')
        ->subject('Welcome to Our Platform!')
        ->with(['user' => $this->user]);
    }

SMTP Configuration:
Add the following SMTP configuration to your .env file:

    MAIL_MAILER=smtp
    MAIL_HOST=smtp.gmail.com
    MAIL_PORT=587
    MAIL_USERNAME=your_email@gmail.com
    MAIL_PASSWORD=your_password_or_app_specific_password
    MAIL_ENCRYPTION=tls
    MAIL_FROM_ADDRESS=your_email@gmail.com
    MAIL_FROM_NAME=YourAppName

This setup ensures that Laravel can send emails using SMTP.

Step 9: Create an Email Template

Generate a Blade view for the welcome email:

php artisan make: view emails.welcome

The file will be stored at resources/views/emails/welcome.blade.php.

Welcome.blade.php

    
    
        
        
        Welcome to Our Platform
    
    
        Hello, {{ $user->name }}!
        Welcome to our platform! We are excited to have you join us.

Step 10: Define Routes

Add the following routes to routes/web.php:

    use App\Http\Controllers\Auth\RegisterController;

    Route::get('register', [RegisterController::class, 'showRegistrationForm'])->name('register');
    Route::post('register', [RegisterController::class, 'register']);

These routes display the registration form and handle user registrations.

You can find the link to the complete tutorial here: GitHub Repository.

Conclusion

Implementing Laravel events leads to better performance and scalability and allows for more organized, modular code. Understanding how to utilize events and listeners effectively helps developers handle tasks asynchronously and manage complex systems more efficiently. By following best practices for event management, your Laravel applications will remain robust, flexible, and easy to maintain. Hire Laravel Developers from us and ensure your project’s success with secure, scalable & flexible results.

Priyanka Dhokia - Laravel Developer at Glorywebs