Event subscribers let you group event handling methods in one class. This keeps your code organized and easy to manage.
You want to handle multiple related events in one place.
You want to keep event listener logic clean and reusable.
You want to separate event handling from other parts of your app.
You want to register event handlers dynamically in one class.
Syntax
Laravel
class UserEventSubscriber
{
public function onUserLogin($event)
{
// Handle user login event
}
public function onUserLogout($event)
{
// Handle user logout event
}
public function subscribe($events)
{
$events->listen(
'App\Events\UserLoggedIn',
[UserEventSubscriber::class, 'onUserLogin']
);
$events->listen(
'App\Events\UserLoggedOut',
[UserEventSubscriber::class, 'onUserLogout']
);
}
}
The subscribe method registers event handlers.
Each handler method receives the event object as a parameter.
Examples
This subscriber listens for the OrderPlaced event and runs onOrderPlaced when it happens.
Laravel
class OrderEventSubscriber
{
public function onOrderPlaced($event)
{
// Code to run when order is placed
}
public function subscribe($events)
{
$events->listen('App\Events\OrderPlaced', [self::class, 'onOrderPlaced']);
}
}
This subscriber handles two product-related events in one class.
Laravel
class ProductEventSubscriber
{
public function onProductCreated($event)
{
// Handle product created event
}
public function onProductDeleted($event)
{
// Handle product deleted event
}
public function subscribe($events)
{
$events->listen('App\Events\ProductCreated', [self::class, 'onProductCreated']);
$events->listen('App\Events\ProductDeleted', [self::class, 'onProductDeleted']);
}
}
Sample Program
This example shows a subscriber class handling user login and logout events. When events are dispatched, the subscriber methods print messages with the user's name.
Laravel
<?php
namespace App\Listeners;
class UserEventSubscriber
{
public function onUserLogin($event)
{
echo "User logged in: {$event->user->name}\n";
}
public function onUserLogout($event)
{
echo "User logged out: {$event->user->name}\n";
}
public function subscribe($events)
{
$events->listen('App\Events\UserLoggedIn', [self::class, 'onUserLogin']);
$events->listen('App\Events\UserLoggedOut', [self::class, 'onUserLogout']);
}
}
// Simulate event objects
class User {
public $name;
public function __construct($name) { $this->name = $name; }
}
class UserLoggedIn {
public $user;
public function __construct($user) { $this->user = $user; }
}
class UserLoggedOut {
public $user;
public function __construct($user) { $this->user = $user; }
}
// Simulate event dispatcher
class EventDispatcher {
protected $listeners = [];
public function listen($eventName, $callback) {
$this->listeners[$eventName][] = $callback;
}
public function dispatch($event) {
$eventName = get_class($event);
if (!empty($this->listeners[$eventName])) {
foreach ($this->listeners[$eventName] as $listener) {
call_user_func($listener, $event);
}
}
}
public function subscribe($subscriber) {
$subscriber->subscribe($this);
}
}
// Usage
$dispatcher = new EventDispatcher();
$subscriber = new \App\Listeners\UserEventSubscriber();
$dispatcher->subscribe($subscriber);
$user = new User('Alice');
$dispatcher->dispatch(new UserLoggedIn($user));
$dispatcher->dispatch(new UserLoggedOut($user));
OutputSuccess
Important Notes
Register your subscriber in EventServiceProvider under the $subscribe property.
Subscribers help keep event handling code clean and grouped logically.
Summary
Event subscribers group multiple event handlers in one class.
They register handlers using the subscribe method.
This keeps your app organized and easier to maintain.
Practice
(1/5)
1. What is the main purpose of an event subscriber in Laravel?
easy
A. To replace middleware in routing
B. To group multiple event handlers in one class for better organization
C. To directly dispatch events to the database
D. To handle HTTP requests and responses
Solution
Step 1: Understand event subscribers role
Event subscribers group multiple event handlers in one class to keep code organized.
Step 2: Compare with other options
Options A, B, and D describe unrelated Laravel features like middleware, database dispatch, and HTTP handling.
Final Answer:
To group multiple event handlers in one class for better organization -> Option B
Quick Check:
Event subscribers organize handlers = C [OK]
Hint: Subscribers group handlers in one class for neat code [OK]
Common Mistakes:
Confusing subscribers with middleware
Thinking subscribers dispatch events
Mixing subscribers with HTTP controllers
2. Which method must a Laravel event subscriber class implement to register its event handlers?
easy
A. boot()
B. handle()
C. listen()
D. subscribe()
Solution
Step 1: Recall subscriber method
Laravel event subscribers use the subscribe() method to register event handlers.
Step 2: Eliminate other methods
handle() is for event listeners, listen() is used in EventServiceProvider, boot() is for service providers.
Final Answer:
subscribe() -> Option D
Quick Check:
subscribe() registers handlers = A [OK]
Hint: Subscribers use subscribe() to register handlers [OK]
Common Mistakes:
Using handle() instead of subscribe()
Confusing listen() with subscribe()
Thinking boot() is for subscribers
3. Given this subscriber class, what will happen when the UserRegistered event is fired?
class UserEventSubscriber {
public function subscribe($events) {
$events->listen('UserRegistered', [self::class, 'onUserRegistered']);
}
public function onUserRegistered($event) {
echo 'User registered: ' . $event->user->name;
}
}
medium
A. Nothing happens because subscribe is not called automatically
B. It will throw a syntax error
C. It will echo the registered user's name
D. It will echo 'User registered:' without the name
Solution
Step 1: Understand event firing and subscriber listening
The subscriber listens for 'UserRegistered' and calls onUserRegistered which echoes the user's name.
Step 2: Confirm subscribe method usage
Laravel calls subscribe() automatically when registered, so the handler runs and echoes the message with the name.
Final Answer:
It will echo the registered user's name -> Option C
Quick Check:
Event triggers echo with name = A [OK]
Hint: subscribe() auto-registers handlers; echo shows user name [OK]
Common Mistakes:
Thinking subscribe() must be called manually
Assuming syntax error due to self::class
Ignoring the event object passed to handler
4. Identify the error in this subscriber class:
class OrderSubscriber {
public function subscribe($events) {
$events->listen('OrderPlaced', 'handleOrderPlaced');
}
public function handleOrderPlaced($event) {
// process order
}
}
medium
A. The listener callback should be an array with class and method
B. The handleOrderPlaced method must be static
C. The subscribe method must return a value
D. The event name should be lowercase
Solution
Step 1: Check listener callback format
Laravel expects the listener callback as an array with class and method when used in subscribers.
Step 2: Analyze given code
The code uses a string 'handleOrderPlaced' instead of [self::class, 'handleOrderPlaced'], causing a runtime error.
Final Answer:
The listener callback should be an array with class and method -> Option A
Quick Check:
Listener callback must be array = D [OK]
Hint: Use [ClassName::class, 'method'] for subscriber callbacks [OK]
Common Mistakes:
Passing method name as string only
Thinking subscribe must return a value
Assuming method must be static
5. You want to create a subscriber that listens to OrderPlaced and OrderShipped events. Which is the correct way to register both handlers in the subscribe method?
hard
A. public function subscribe($events) {
$events->listen('OrderPlaced', [self::class, 'handleOrderPlaced']);
$events->listen('OrderShipped', [self::class, 'handleOrderShipped']);
}
B. public function subscribe($events) {
$events->listen(['OrderPlaced', 'OrderShipped'], [self::class, 'handleOrder']);
}
C. public function subscribe($events) {
$events->listen('OrderPlaced', 'handleOrderPlaced');
$events->listen('OrderShipped', 'handleOrderShipped');
}
D. public function subscribe($events) {
$events->listen('OrderPlaced', self::handleOrderPlaced);
$events->listen('OrderShipped', self::handleOrderShipped);
}
Solution
Step 1: Understand correct listener registration
Each event must be registered separately with an array callback [Class, method].
Step 2: Evaluate options
public function subscribe($events) {
$events->listen('OrderPlaced', [self::class, 'handleOrderPlaced']);
$events->listen('OrderShipped', [self::class, 'handleOrderShipped']);
} correctly registers both events with proper callbacks. public function subscribe($events) {
$events->listen(['OrderPlaced', 'OrderShipped'], [self::class, 'handleOrder']);
} wrongly groups events in one call. public function subscribe($events) {
$events->listen('OrderPlaced', 'handleOrderPlaced');
$events->listen('OrderShipped', 'handleOrderShipped');
} uses strings instead of array callbacks. public function subscribe($events) {
$events->listen('OrderPlaced', self::handleOrderPlaced);
$events->listen('OrderShipped', self::handleOrderShipped);
} uses invalid syntax without quotes.
Final Answer:
public function subscribe($events) {
$events->listen('OrderPlaced', [self::class, 'handleOrderPlaced']);
$events->listen('OrderShipped', [self::class, 'handleOrderShipped']);
} -> Option A
Quick Check:
Separate listen calls with array callbacks = B [OK]
Hint: Register each event separately with [Class::class, 'method'] [OK]
Common Mistakes:
Grouping multiple events in one listen call
Using string method names without array
Using invalid syntax without quotes
Recommended
Ready to prove it?
Pass the test and this pattern moves unknownstrongwhile earning +1 Grip toward your certificate.