Laravel Events with OrderShipped event example

TL;DR Laravel provides an elegant way to decouple business logic from actual processing through events, a notification mechanism that allows other parts of the application to be informed about significant occurrences without direct dependencies. An event is triggered and listened to by different components, allowing specific actions to be performed. To create a new event, define it in the app/Events directory, then create a listener responsible for processing it and register the listener in the EventServiceProvider. Finally, trigger the event from within your application using the event() helper function.

The Power of Laravel Events: A Deeper Dive with OrderShipped Example

As Fullstack Developers, we're constantly looking for ways to improve our applications' scalability and maintainability. One essential feature that helps us achieve this is the use of events in Laravel. In this article, we'll delve into the world of Laravel events, exploring what they are, how they work, and a practical example using the OrderShipped event.

What are Laravel Events?

Laravel provides an elegant way to decouple your application's business logic from the actual processing. This is where events come in – a notification mechanism that allows us to inform other parts of our application about significant occurrences without worrying about direct dependencies.

Think of events like notifications sent by your application, which can be listened to and processed by different components. When an event occurs, it triggers all registered listeners, allowing them to perform specific actions.

Key Concepts

Before diving into the OrderShipped example, let's cover some essential concepts:

• Event: A notification that something has happened in your application.
• Listener: A class responsible for processing events and executing related actions.
• Event Dispatcher: The component that manages event registration and triggering.

Creating an Event

To create a new event, we need to define it within the app/Events directory. In this case, let's create the OrderShipped event:

// app/Events/OrderShipped.php

namespace App\Events;

use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Contracts\Broadcastable\Broadcaster;
use App\Models\Order;

class OrderShipped implements ShouldQueue
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public $order;

    public function __construct(Order $order)
    {
        $this->order = $order;
    }
}

Here, we've created a simple OrderShipped event with an $order property. This property will be used by the listener to access relevant information.

Creating a Listener

Now that our event is defined, let's create a listener responsible for processing it:

// app/Listeners/OrderShippedListener.php

namespace App\Listeners;

use App\Events\OrderShipped;
use Illuminate\Contracts\Queue\ShouldQueue;

class OrderShippedListener implements ShouldQueue
{
    public function handle(OrderShipped $event)
    {
        // Process the order shipment here
        $event->order->update(['status' => 'shipped']);

        // Send a notification to the customer, for example
        // \App\Notifications\OrderShipped::to($event->order->customer)->send();
    }
}

In this listener, we're updating the order status and sending a notification to the customer (this part is commented out as it's not essential to our example).

Registering the Listener

Don't forget to register your listener in the EventServiceProvider. You can do this by adding the following line:

// app/Providers/EventServiceProvider.php

namespace App\Providers;

use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
use Illuminate\Contracts\Events\Dispatcher;

class EventServiceProvider extends ServiceProvider
{
    protected $listen = [
        OrderShipped::class => [OrderShippedListener::class],
    ];
}

Triggering the Event

Finally, to trigger our OrderShipped event, we need to dispatch it from within our application. Let's assume we have a controller that handles order shipping:

// app/Http/Controllers/OrdersController.php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Events\OrderShipped;
use App\Models\Order;

class OrdersController extends Controller
{
    public function shipOrder(Request $request)
    {
        // Update the order status and dispatch the event
        Order::find($request->id)->update(['status' => 'shipped']);
        event(new OrderShipped(Order::find($request->id)));
    }
}

By following these steps, we've successfully implemented a Laravel event using the OrderShipped example.

Best Practices

To get the most out of your events:

• Use queues to offload event processing and prevent blocking
• Keep listeners as thin as possible for easier maintenance
• Monitor and log event triggers and listener executions