It cannot be denied that the capabilities of developing efficient, flexible, and scalable systems are coming more and more in handy for software development talents like never before. The need for change is further exacerbated by the fact that as the application grows to more complexity, the traditional monolithic architectures tend to encumber the systems, resulting in coalesced components with serious bottlenecks that impede performance and motion. Enter Event-Driven Architecture (EDA) which changes this static view into a more flexible and dynamic approach in building the system.
Think of an e-commerce portal that registers every action of the customer that triggers various actions such as updating the stock, confirming the order, processing the payment and sending a notification for shipping. Looking at it this way, executing these tasks in such a limited manner in a monolithic system could be overwhelming. But what if each unit of the task could be executed independently, called by events (triggers) and done simultaneously? That is the advantage of EDA.
This is a very detailed tutorial, and you will learn how event-driven architecture can be implemented using PHP and Symfony Event Dispatcher. We will then show in detail how EDA can be applied on the order processing of an e-commerce site, providing for decoupled components, scalability and robustness of the system.
Table of Contents
What is Event-Driven Architecture?
Event-Driven Architecture (EDA) is a design pattern that describes how a program operates where events take control of its execution. These events can be user actions, outputs from the sensor, or communications from other programs. When compared to the object-oriented software paradigm , EDA’s positions are morsely centered on data activity where systems are composed of peers sharing messages more than coupling so closely.
Key Components of EDA
- Event Producers: developers who create and produce events.
- Event consumers: developers who act on these events.
- Event Channels: These channels carry events to and from producers and their consumers.
- Event Processors: high-level components that handle input events and generate output events, frequently changing the event attributes in one way or another.
Take an example of an e-commerce marketplace where there are multiple different activities that take place when a customer makes an order. For example
- Data has to be updated.
- A customer needs to be sent order acknowledgment.
- Payment can be processed.
- Notification of the postage service has to be given.
In a system using Event Driven Architecture, every action has a discreet element within the system that gets configured to respond to the action of an order being placed.
Why Use Event-Driven Architecture?
- Scalability: Deal with varying loads with ease, such as by increasing the number of components on web servers as web users increase over time.
- Flexibility: Change of elements does not involve other elements.
- Resilience: Failures can be contained, which increases system availability and durability.
Real-World Example: E-Commerce Order Processing
Consider an e-commerce platform where multiple actions happen when a customer places an order. For instance
- Inventory needs to be updated.
- An order confirmation email must be sent.
- Payment processing should be initiated.
- Shipping service must be notified.
Traditional Approach vs. Event-Driven Approach
These entities have often made progress with so-called sequential tasks in traditional monolithic application so that components which are so interdependent sometimes lead to bottlenecks.
However, an event driven approach especially in this case enables barriers to be lifted between these processes enhancing performance of the system and its maintainability.
Implementing Event-Driven Architecture in PHP
We will look at how to implement this EDA in PHP using a dramatized version of an e-commerce order processing system.
Step 1: Set Up the Project
This returns a directory with all the framework files. Make a new php project and install composer if it’s not installed already. We will be utilizing the Symfony Event Dispatcher component to manage the events.
composer require symfony/event-dispatcherStep 2: Define Events
Create a folder for events and create the event order process placement.
// src/Events/OrderPlacedEvent.php
namespace App\Events;
use Symfony\Contracts\EventDispatcher\Event;
/**
* Class representing the event triggered when an order is placed.
*/
class OrderPlacedEvent extends Event {
public const NAME = 'order.placed';
protected $order;
/**
* Constructor to initialize the order data.
*
* @param array $order The order details.
*/
public function __construct($order) {
$this->order = $order;
}
/**
* Gets the order details.
*
* @return array The order details.
*/
public function getOrder() {
return $this->order;
}
} Step 3: Create Event Listeners
Listeners are classes which listen to a certain event and carry out a specific task. Now, create the listeners to update the inventory, to send email confirmation and to initiate the payment processing.
// src/Listeners/InventoryUpdateListener.php
namespace App\Listeners;
use App\Events\OrderPlacedEvent;
/**
* Listener for updating inventory when an order is placed.
*/
class InventoryUpdateListener {
/**
* Handles the event of an order being placed.
*
* @param OrderPlacedEvent $event The event object.
*/
public function onOrderPlaced(OrderPlacedEvent $event) {
// Logic to update inventory
$order = $event->getOrder();
echo "Inventory updated for order: " . $order['id'] . PHP_EOL;
}
}
// src/Listeners/EmailNotificationListener.php
namespace App\Listeners;
use App\Events\OrderPlacedEvent;
/**
* Listener for sending email notifications when an order is placed.
*/
class EmailNotificationListener {
/**
* Handles the event of an order being placed.
*
* @param OrderPlacedEvent $event The event object.
*/
public function onOrderPlaced(OrderPlacedEvent $event) {
// Logic to send email
$order = $event->getOrder();
echo "Email sent for order: " . $order['id'] . PHP_EOL;
}
}
// src/Listeners/PaymentProcessingListener.php
namespace App\Listeners;
use App\Events\OrderPlacedEvent;
/**
* Listener for processing payment when an order is placed.
*/
class PaymentProcessingListener {
/**
* Handles the event of an order being placed.
*
* @param OrderPlacedEvent $event The event object.
*/
public function onOrderPlaced(OrderPlacedEvent $event) {
// Logic to process payment
$order = $event->getOrder();
echo "Payment processed for order: " . $order['id'] . PHP_EOL;
}
}Step 4: Register Event Listeners
Now you have to associate these listeners with Event Dispatcher. Make sure there is an event to be dispatched that the order was placed.
// src/EventDispatcher.php
namespace App;
use Symfony\Component\EventDispatcher\EventDispatcher;
use App\Events\OrderPlacedEvent;
use App\Listeners\InventoryUpdateListener;
use App\Listeners\EmailNotificationListener;
use App\Listeners\PaymentProcessingListener;
/**
* Registering event listeners with the Event Dispatcher.
*/
$dispatcher = new EventDispatcher();
$dispatcher->addListener(OrderPlacedEvent::NAME, [new InventoryUpdateListener(), 'onOrderPlaced']);
$dispatcher->addListener(OrderPlacedEvent::NAME, [new EmailNotificationListener(), 'onOrderPlaced']);
$dispatcher->addListener(OrderPlacedEvent::NAME, [new PaymentProcessingListener(), 'onOrderPlaced']);Step 5: Dispatch Events
Last, when a new order is created, the event should be dispatched.
// src/OrderService.php
namespace App;
use App\Events\OrderPlacedEvent;
/**
* Service class for handling order-related operations.
*/
class OrderService {
protected $dispatcher;
/**
* Constructor to initialize the event dispatcher.
*
* @param EventDispatcher $dispatcher The event dispatcher.
*/
public function __construct($dispatcher) {
$this->dispatcher = $dispatcher;
}
/**
* Places an order and dispatches the order placed event.
*
* @param array $order The order details.
*/
public function placeOrder($order) {
// Logic to place order
echo "Order placed: " . $order['id'] . PHP_EOL;
// Dispatch event
$event = new OrderPlacedEvent($order);
$this->dispatcher->dispatch($event, OrderPlacedEvent::NAME);
}
}
// index.php
require 'vendor/autoload.php';
use App\OrderService;
use App\EventDispatcher;
/**
* Main script to place an order and trigger the event-driven process.
*/
$dispatcher = new EventDispatcher();
$orderService = new OrderService($dispatcher);
$order = ['id' => 123, 'items' => ['item1', 'item2']];
$orderService->placeOrder($order);Common Questions about Event-Driven Architecture
What is an Example of Event-Driven Architecture?
An example of event driven architecture is a world-wide web based ecommerce website. When a customer gives the order, certain processes such as modifying the stock, sending order confirmation, commencing the payment, and contacting the couriers must be done. In an EDA, these processes above are embedded within different components and each is activated by the event of an order being placed.
Which is an Event-Driven Architecture Solution Design Pattern?
EDA itself is a solution design pattern. It is particularly effective for systems that need to handle a large number of simultaneous events and require high scalability and flexibility. It decouples the components, making the system more maintainable and robust.
Conclusion
Applying the Event-Driven Architecture in PHP can improve the scalability, flexibility and resilience of your application. This is achieved by providing the ability to decouple components and engage them through events making the architecture more manageable and robust. And while the case provided in this blog is a basic example, it is possible to take its principles further to more complex cases, which is very effective for the development of modern software.
Do remember that the most important aspect of EDA implementation is determining the right events and decomposition of your components. Happy coding!