Create events and listeners: Use the Artisan command to generate UserRegistered events and SendWelcomeEmail and LogUserRegistration listeners; 2. Define event classes: Inject user instances into the UserRegistered constructor for listeners to access; 3. Write listener logic: SendWelcomeEmail sends welcome emails, and LogUserRegistration records user registration logs; 4. Register events and listeners: bind events and listeners in the $listen array of EventServiceProvider; 5. Distribute events: After the user is registered, the UserRegistered event is triggered through event() or Event::dispatch() to make the listener automatically execute; 6. Optional enable automatic event discovery: Set shouldDiscoverEvents to return true and run the event:cache command to automatically register the listener; 7. Best practice: Keep the listener single responsibility, and time-consuming tasks use the ShouldQueue interface to implement queue processing to avoid writing complex logic in events. This mode improves application maintainability and scalability by decoupling business logic, and is suitable for notification, logging, analysis and other scenarios.

Laravel Events and Listeners are a powerful way to make your application more modular and maintained by decoupling actions from the code that triggers them. Instead of writing long, tightly coupled logic in your controllers or models, you can dispatch events and let listeners react to them. This tutorial walks you through setting up and using events and listeners in Laravel with a practical example.

What Are Events and Listeners?

• Event : Something that happened in your app (eg, a user registered).
• Listener : A class that reacts to that event (eg, send a welcome email, log activity).

This pattern follows the observer pattern , allowing one part of your app to notify others without knowing who's listening.

Step 1: Generate an Event and Listener

Laravel makes it easy to create events and listeners using Artisan commands.

Let's say we want to send a welcome email and log user registration.

Create the Event

 php artisan make:event UserRegistered

This creates a file: app/Events/UserRegistered.php

Create the Listener

 php artisan make:listener SendWelcomeEmail --event=UserRegistered
php artisan make:listener LogUserRegistration --event=UserRegistered

This creates:

• app/Listeners/SendWelcomeEmail.php
• app/Listeners/LogUserRegistration.php

You can also create listeners without specifying the event and wire them manually later.

Step 2: Define the Event Class

Open app/Events/UserRegistered.php . It should look like this:

 <?php

namespace App\Events;

use App\Models\User;
use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Broadcasting\PresenceChannel;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class UserRegistered
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public $user;

    public function __construct(User $user)
    {
        $this->user = $user;
    }

    public function broadcastOn()
    {
        return new PrivateChannel(&#39;channel-name&#39;);
    }
}

We're passing the $user model to the event so listeners can access it.

Step 3: Write the Listener Logic

Open app/Listeners/SendWelcomeEmail.php :

 <?php

namespace App\Listeners;

use App\Events\UserRegistered;
use Illuminate\Support\Facades\Mail;
use App\Mail\WelcomeEmail;

class SendWelcomeEmail
{
    public function handle(UserRegistered $event)
    {
        Mail::to($event->user->email)->send(new WelcomeEmail($event->user));
    }
}

Make sure you have a WelcomeEmail Mailable:

 php artisan make:mail WelcomeEmail

Similarly, for logging:

 <?php

namespace App\Listeners;

use App\Events\UserRegistered;
use Illuminate\Support\Facades\Log;

class LogUserRegistration
{
    public function handle(UserRegistered $event)
    {
        Log::info(&#39;New user registered: &#39; . $event->user->email);
    }
}

Step 4: Register the Event and Listeners

Open app/Providers/EventServiceProvider.php .

In the $listen array, map the event to its listeners:

 protected $listen = [
    'App\Events\UserRegistered' => [
        'App\Listeners\SendWelcomeEmail',
        'App\Listeners\LogUserRegistration',
    ],
];

This tells Laravel which listeners should run when UserRegistered is dispatched.

After making changes here, run:

 php artisan event:cache

(for production; not required in local during development)

Step 5: Dispatch the Event

Now, trigger the event from your controller or model.

In your RegisterController or wherever user registration happens:

 use App\Events\UserRegistered;
use Illuminate\Support\Facades\Event;

// After user creation
event(new UserRegistered($user));

// Or using the Event facade
Event::dispatch(new UserRegistered($user));

Example in a controller method:

 public function register(Request $request)
{
    $user = User::create($request->validated());

    event(new UserRegistered($user));

    return redirect('/dashboard');
}

When this runs, both listeners will execute.

Optional: Event Discovery

If you don't want to manually register events in EventServiceProvider , Laravel can auto-discover them.

Enable it in EventServiceProvider :

 public function shouldDiscoverEvents()
{
    return true;
}

Laravel will scan the Listeners directory and auto-register event-listener pairs based on type-hinting in the handle() method.

Then you don't need to list them in $listen .

Run:

 php artisan event:cache

Best Practices

• Keep listeners focused: One job per listener.
• Use queueable listeners for slow tasks (like sending emails):

 class SendWelcomeEmail implements ShouldQueue
{
    use Queueable;
}

Make sure your listener uses the Queueable trait and implements ShouldQueue .

• Avoid heavy logic in events; use them just to signal.

Summary

Events and listeners help you write cleaner, more scalable Laravel apps by separating concerns. You've now:

• Created an event ( UserRegistered )
• Made listeners ( SendWelcomeEmail , LogUserRegistration )
• Registered them in EventServiceProvider
• Dispatched the event from your code

This pattern is great for audit logging, notifications, analytics, and more.

Basically, if something happens and other parts of your app need to know — use events.

The above is the detailed content of Laravel events and listeners tutorial. For more information, please follow other related articles on the PHP Chinese website!