Laravel introduces a powerful event-driven architecture that makes managing workflows effortless. In this post, i’ll walk through how to use Events, Listeners, and Notifications to create clean, asynchronous processes.
Step 1: Setup Laravel Project
we can create a new Laravel project using Composer:
<code>composer create-project --prefer-dist laravel/laravel EventNotificationQueue</code>
Ensure <code>.env</code> file is updated with database and credentials, like so:
<pre><code class="language-DB_CONNECTION=mysql">DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=database_name
DB_USERNAME=database_user
DB_PASSWORD=database_password
</code></pre>
Update Mailtrap credentials in <code>.env</code> to send notifications via email.
<pre><code>MAIL_MAILER=smtp
MAIL_HOST=sandbox.smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=****************
MAIL_PASSWORD=****************
</code></pre>
Step 2: Build the Event-Driven Workflow*
Now let’s create the essential components:
<ol>
<li>Create the Event: Generate an event to encapsulate the data and logic.</li>
</ol>
<code>php artisan make:event UserCreated</code>
<pre><code>&lt;?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 UserCreated
{
 use Dispatchable, InteractsWithSockets, SerializesModels;

 /**
 * Create a new event instance.
 */
 public function __construct(public User $user)
 {
 }

 /**
 * Get the channels the event should broadcast on.
 *
 * @return array&lt;int, \Illuminate\Broadcasting\Channel&gt;
 */
 public function broadcastOn(): array
 {
 return [
 new PrivateChannel(&#x27;channel-name&#x27;),
 ];
 }
}
</code></pre>
<ol start="2">
<li>Create the Listener: Generate a listener that responds to the event.</li>
</ol>
<code>php artisan make:listener SendUserWelcomeNotification --event=UserCreated</code>
<pre><code>&lt;?php

namespace App\Listeners;

use App\Events\UserCreated;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;
use App\Notifications\UserWelcomeNotification;
use Illuminate\Support\Facades\Notification;

class SendUserWelcomeNotification implements ShouldQueue
{
 /**
 * Create the event listener.
 */
 public function __construct()
 {
 //
 }

 /**
 * Handle the event.
 */
 public function handle(UserCreated $event): void
 {
 // $event-&gt;user-&gt;notify(new UserWelcomeNotification());
 Notification::send(notifiables: $event-&gt;user, notification: new UserWelcomeNotification());
 }
}
</code></pre>
<ol start="3">
<li>Create the Notification: Generate a notification class to handle user communication</li>
</ol>
<code>php artisan make:notification UserWelcomeNotification</code>
<code>php artisan make:notifications-table</code>
<pre><code>&lt;?php

namespace App\Notifications;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Messages\MailMessage;
use Illuminate\Notifications\Notification;

class UserWelcomeNotification extends Notification
{
 use Queueable;

 /**
 * Create a new notification instance.
 */
 public function __construct()
 {
 //
 }

 /**
 * Get the notification&#x27;s delivery channels.
 *
 * @return array&lt;int, string&gt;
 */
 public function via(object $notifiable): array
 {
 return [&#x27;mail&#x27;, &#x27;database&#x27;];
 }

 /**
 * Get the mail representation of the notification.
 */
 public function toMail(object $notifiable): MailMessage
 {
 return (new MailMessage)
 -&gt;subject(&#x27;Welcome!&#x27;)
 -&gt;line(&#x27;We’re glad you joined us.&#x27;)
 -&gt;action(&#x27;Visit Us&#x27;, url(&#x27;/&#x27;))
 -&gt;line(&#x27;Thank you!&#x27;);
 }

 /**
 * Get the array representation of the notification.
 *
 * @return array&lt;string, mixed&gt;
 */
 public function toArray(object $notifiable): array
 {
 return [
 &#x27;user_id&#x27; =&gt; $notifiable-&gt;id,
 &#x27;message&#x27; =&gt; &#x27;Welcome to our platform, &#x27; . $notifiable-&gt;name . &#x27;!&#x27;,
 ];
 }
}
</code></pre>
<ol start="4">
<li>Now, let’s dispatching event automatically: To dispatching event automatically, we have to add this like in <code>User</code> Model</li>
</ol>
<pre><code>protected $dispatchesEvents = [
 &#x27;created&#x27; =&gt; UserCreated::class,
 ];
</code></pre>
Define a function on <code>database/seeders/DatabaseSeeder</code>
<pre><code>public function run(): void
 {
 User::factory(10)-&gt;create();
 }
</code></pre>
Type <code>php artisan migrate:fresh --seed</code>
Step 3: Understand the Workflow
Here’s how everything fits together:
<ul>
<li>A <code>UserCreated</code> event is dispatched automatically when a user is created.</li>
<li>The <code>SendUserWelcomeNotification</code> listener processes the event asynchronously using queues.</li>
<li>The listener then sends a <code>UserWelcomeNotification</code> via email and stores it in the database.</li>
</ul>
Step 4: Process the Queue
Run the queue worker to process tasks in the background:
<code>php artisan queue:work</code>
Key Features in Laravel 11
<ol>
<li>No Manual Registration in <code>EventServiceProvider</code>:</li>
</ol>
<ul>
<li>Laravel 11 automatically discovers events and listeners—no need for manual registration.</li>
</ul>
<ol start="2">
<li>Automatic <code>Listener</code> Directory Scanning:</li>
</ol>
<ul>
<li>Laravel defaults to scanning the <code>app/Listeners</code> directory. Want a custom directory? Specify it in <code>bootstrap/app.php</code> like</li>
</ul>
<pre><code class="language-&lt;?php">
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;

return Application::configure(basePath: dirname(__DIR__))
 -&gt;withRouting(
 web: __DIR__.'/../routes/web.php',
 commands: __DIR__.'/../routes/console.php',
 health: '/up',
 )
 -&gt;withMiddleware(function (Middleware $middleware) {
 //
 })
 //if you have custom listeners dir
 -&gt;withEvents(discover: [
 __DIR__.'/../app/{{ customListeners }}',
 ])
 -&gt;withExceptions(function (Exceptions $exceptions) {
 //
 })-&gt;create();
</code></pre>
🚀 With just a few simple steps, we’re on your way to building an event-driven architecture in Laravel 11. Ready to level up our development workflow? Drop your thoughts or questions in the comments! 💬
#Laravel11 #EventDrivenArchitecture #PHP #WebDevelopment
<a href="https://github.com/muhammadsanwarulislam/EventNotificationQueue" target="_blank" rel="noopener nofollow">https://github.com/muhammadsanwarulislam/EventNotificationQueue</a>

PHP(Laravel)

Learn how to implement event-driven workflows in Laravel 11 using events, listeners, and notifications for clean, asynchronous operations. Set up a Laravel project, create events, listeners, and notifications, automatically dispatch events, and process tasks in the background using queues. New features in Laravel 11 include automated event and listener discovery, eliminating the need for manual registration.

Let’s Deep Dive into Event-Driven Workflow in Laravel 11! 🚀

really intresting im building an app right now that usa alot of email but im dispatching it in the controller eventualy i can refactor the code for
better cleaning