How & When To Use Event Listeners in Laravel Practical Code Examples

Laravel's event system is phenomenal when it comes to dealing with the complex data in our web apps as it is a cornerstone for building decoupled and absolutely complex apps. This guide tells extremely detailed points on implementation and utilization of event listening especially in 2024, providing a fresh perspective with the most expansive content and detailed code examples event listeners in Laravel 11.

*(A) Understanding The Core Behind Events and Listeners
*
SO, LET'S BREAK THEM DOWN, the events in Laravel do representing specific occurrences inside an app. Listeners are the classes that would respond to all such app events. This pattern keeps promoting a separation of concerns and has been allowing for more modular and testable code.

*(B) Creating an Event
*
Let us begin by creating an even a complex event for that we will be using the Artisan command to explain better we highly suggest you'd do that too

php artisan make:event OrderPlaced

This command will be generating a new event class in the app/Events directory. Let us examine a more detailed event class

`namespace AppEvents;

use AppModelsOrder;
use AppModelsUser;
use IlluminateFoundationEventsDispatchable;
use IlluminateQueueSerializesModels;
use IlluminateBroadcastingInteractsWithSockets;
use IlluminateBroadcastingPrivateChannel;
use IlluminateContractsBroadcastingShouldBroadcast;

class OrderPlaced implements ShouldBroadcast
{
use Dispatchable, InteractsWithSockets, SerializesModels;

public $order;
public $user;

/**
 * Create a new event instance.
 *
 * @param  \App\Models\Order  $order
 * @param  \App\Models\User  $user
 * @return void
 */
public function __construct(Order $order, User $user)
{
    $this->order = $order;
    $this->user = $user;
}

/**
 * Get the channels the event should broadcast on.
 *
 * @return \Illuminate\Broadcasting\Channel|array
 */
public function broadcastOn()
{
    return new PrivateChannel('orders.'.$this->user->id);
}

/**
 * The event's broadcast name.
 *
 * @return string
 */
public function broadcastAs()
{
    return 'order.placed';
}

}`

In this expanded example, we have been including both the Order and User models. The SerializesModels trait has been ensuring that our Eloquent models are correctly serialized and deserialized when the event is passed to queued listeners. We have also implemented the ShouldBroadcast interface and defined the broadcastOn and broadcastAs methods, allowing this event to be broadcasted to websockets for real-time updates.

*Creating Multiple Listeners
*
For a single event, we might want multiple listeners. Let us create two listeners for our OrderPlaced event to expand the example furthermore. I just want you guys to make sure you get the gist of everything. So, for that please see the code example below

php artisan make:listener SendOrderConfirmation --event=OrderPlaced
php artisan make:listener UpdateInventory --event=OrderPlaced

SO now you'd understand that this command line would get us a couple of new listener classes in the app/Listeners directory of ours. Now the thing is, here below, we would examine the SendOrderConfirmation listener and see how to it how it progresses further

`namespace AppListeners;

use AppEventsOrderPlaced;
use AppMailOrderConfirmation;
use IlluminateContractsQueueShouldQueue;
use IlluminateQueueInteractsWithQueue;
use IlluminateSupportFacadesMail;
use IlluminateSupportFacadesLog;

class SendOrderConfirmation implements ShouldQueue
{
use InteractsWithQueue;

/**
 * The number of times the job may be attempted.
 *
 * @var int
 */
public $tries = 3;

/**
 * Handle the event.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @return void
 */
public function handle(OrderPlaced $event)
{
    $order = $event->order;
    $user = $event->user;

    try {
        Mail::to($user->email)->send(new OrderConfirmation($order));
        Log::info('Order confirmation email sent', ['order_id' => $order->id, 'user_id' => $user->id]);
    } catch (\Exception $e) {
        Log::error('Failed to send order confirmation email', ['order_id' => $order->id, 'user_id' => $user->id, 'error' => $e->getMessage()]);
        $this->fail($e);
    }
}

/**
 * Handle a job failure.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @param  \Throwable  $exception
 * @return void
 */
public function failed(OrderPlaced $event, $exception)
{
    Log::error('Order confirmation listener failed', ['order_id' => $event->order->id, 'user_id' => $event->user->id, 'error' => $exception->getMessage()]);
}

}`

This listener has been implementing the ShouldQueue interface, indicating that it should be queued. We have added error handling, logging, and defined a failed method to handle failures. The $tries property would be set to allow for multiple attempts in case of failure.
Now, let us look at the UpdateInventory listener

`namespace AppListeners;

use AppEventsOrderPlaced;
use IlluminateContractsQueueShouldQueue;
use IlluminateQueueInteractsWithQueue;
use IlluminateSupportFacadesDB;
use IlluminateSupportFacadesLog;

class UpdateInventory implements ShouldQueue
{
use InteractsWithQueue;

/**
 * Handle the event.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @return void
 */
public function handle(OrderPlaced $event)
{
    $order = $event->order;

    DB::transaction(function () use ($order) {
        foreach ($order->items as $item) {
            $product = $item->product;

            if ($product->stock < $item->quantity) {
                throw new \Exception("Insufficient stock for product: {$product->id}");
            }

            $product->decrement('stock', $item->quantity);
            Log::info("Inventory updated", ['product_id' => $product->id, 'quantity' => $item->quantity]);
        }
    });
}

/**
 * Handle a job failure.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @param  \Throwable  $exception
 * @return void
 */
public function failed(OrderPlaced $event, $exception)
{
    Log::error('Failed to update inventory', ['order_id' => $event->order->id, 'error' => $exception->getMessage()]);
}

}`

Now, you'd understand that, this listener is there for a reasons like to upgrade the the inventory based on the order items etc. We have wrapped the inventory update in a database transaction to ensure data consistency. We have also added error checking to prevent negative stock and included logging for successful updates and failures.

*Registering Events & Listeners
*
We will be registering these events and listeners in the EventServiceProvider

`use AppEventsOrderPlaced;
use AppListenersSendOrderConfirmation;
use AppListenersUpdateInventory;

class EventServiceProvider extends ServiceProvider
{
/**
* The event listener mappings for the application.
*
* @var array
*/
protected $listen = [
OrderPlaced::class => [
SendOrderConfirmation::class,
UpdateInventory::class,
],
];

/**
 * Register any events for your application.
 *
 * @return void
 */
public function boot()
{
    parent::boot();

    //
}

}`

Dispatching Events:

We can dispatch the event from a controller or service class

`use App\Events\OrderPlaced;
use App\Models\Order;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class OrderController extends Controller
{
/**
* Place a new order.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\JsonResponse
*/
public function placeOrder(Request $request)
{
$user = auth()->user();

    DB::transaction(function () use ($request, $user) {
        $order = Order::create($request->all());
        $order->user()->associate($user);
        $order->save();

        event(new OrderPlaced($order, $user));
    });

    return response()->json(['message' => 'Order placed successfully', 'order_id' => $order->id]);
}

}`

In this example, we have wrapped the order creation and event dispatching in a database transaction to ensure that both occur successfully or not at all.

The above is the detailed content of How & When To Use Event Listeners in Laravel Practical Code Examples. For more information, please follow other related articles on the PHP Chinese website!