Laravel Events

Laravel events are a powerful tool for decoupling different parts of your application and allowing for more modular and maintainable code. In this blog post, we’ll take a closer look at what events are, how they work, and how you can use them in your Laravel projects.

What are Laravel Events?

An event in Laravel is simply a way to perform an action or trigger some logic in your application when a certain condition is met. For example, you might want to send an email to a user when they register for your website, or log a message to the database when a user completes a purchase. Events allow you to separate this type of logic from the rest of your application, making it easier to maintain and test.

Laravel includes a number of built-in events, such as:

The Event class, which is the base class for all events in Laravel.
The Event facade, which provides a simple way to raise and handle events.
The Event service provider, which is responsible for registering event listeners and subscribers.
There are two types of events in Laravel:

Simple Events: These are basic events that are triggered using the event() helper function or the Event facade. They can be handled by a single listener or multiple listeners.

Advanced Events: These are events that can be queued and dispatched using Laravel’s built-in queue worker. They can also be handled by multiple listeners, and you can use the Event class to create advanced events.

How do Laravel Events Work?

Laravel events work by using a “publisher-subscriber” model. When a certain event is fired, it is “published” to any listeners that are registered to listen for that event. The listeners then “subscribe” to the event and perform some action when it is fired.

For example, let’s say you want to send a welcome email to a user when they register for your website. You would create an event class that represents the user being registered, and a listener class that sends the welcome email. When a user is registered, the event is fired and the listener is called, sending the welcome email to the user.

Creating and Firing Events

To create a new event in Laravel, you simply create a new class that extends the base Event class and contains any relevant data that needs to be passed to the listener(s). Then, in the appropriate place in your application (such as a controller or model), you can fire the event using the event() helper function or the Event facade.

Here is an example of how events can be used in Laravel:

Let’s say you have a “User” model in your application and you want to perform some action every time a user is created.

First, you would create a new event class that represents the user being created. This class should extend the base Event class and contain any relevant data that needs to be passed to the listener(s).

class UserCreated extends Event
{
    public $user;

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

Next, you would create a listener class that will handle the event. This class should implement the Listener interface and define a handle method that will be called when the event is fired.

class SendWelcomeEmail implements Listener
{
    public function handle(UserCreated $event)
    {
        // Send a welcome email to the user
        Mail::to($event->user->email)->send(new WelcomeEmail);
    }
}

In the User model, you can fire the event when the user is created:

class User extends Model
{
    protected $dispatchesEvents = [
        'created' => UserCreated::class,
    ];
}

Finally, you would register the listener in the EventServiceProvider:

protected $listen = [
    UserCreated::class => [
        SendWelcomeEmail::class,
    ],
];

Now, every time a new user is created, the UserCreated event will be fired and the SendWelcomeEmail listener will be called, sending a welcome email to the user.

This way you can make your code more modular and clean, you can create multiple events for multiple actions, and you can create multiple listeners for each event.

If you’re new to using events in Laravel, we recommend starting with a simple example like the one we discussed in this post, and then experimenting with different events and listeners in your own projects. With a little practice, you’ll soon find that events can be a valuable tool for making your Laravel code cleaner and more maintainable.