A Comprehensive Guide to Event-Driven Programming in PHP

"Event-driven" means two different things in PHP. Inside a normal web request, it means your code announces that something happened and separate listeners react to it. In a long-running PHP process, it means an event loop that waits for timers, network connections and messages and runs a callback when each one arrives. This guide covers both, with current code for PHP 8.

1. The core idea: events and listeners

An event is a record that something happened: an order was placed, a user signed up, a timer fired, a socket received data. A listener (or handler) is a function that runs in response. The code that raises the event doesn't know or care which listeners exist.

The trade-off is that the flow is harder to follow: a single "order placed" event may trigger five listeners in different files. Name events clearly and keep a list of who listens to what.

2. Events inside a request: the PSR-14 dispatcher

Most PHP applications run once per HTTP request and exit. They can still be event-driven. PSR-14 is the standard interface for this, and Symfony, Laravel and many other frameworks implement it or something close to it.

A minimal example with the Symfony EventDispatcher component:

<?php
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Contracts\EventDispatcher\Event;

final class OrderPlaced extends Event
{
    public function __construct(public readonly int $orderId, public readonly string $email) {}
}

$dispatcher = new EventDispatcher();

$dispatcher->addListener(OrderPlaced::class, function (OrderPlaced $e) {
    // send the confirmation email
    error_log("Email for order {$e->orderId} to {$e->email}");
});

$dispatcher->addListener(OrderPlaced::class, function (OrderPlaced $e) {
    // reduce stock
    error_log("Stock updated for order {$e->orderId}");
});

// In your checkout code:
$dispatcher->dispatch(new OrderPlaced(1042, '[email protected]'));

Listeners run one after another, in the same request, in the order you registered them (or by priority). If a listener does slow work, such as calling an external API, move that work to a queue so the visitor isn't kept waiting.

3. Event loops: long-running PHP

An event loop is a process that never exits on its own. It keeps a list of timers and open sockets, waits until one of them is ready, runs the matching callback, and goes back to waiting. Because nothing blocks while waiting for the network, one process can handle many connections at once.

4. ReactPHP: timers and concurrent HTTP requests

Install with Composer (composer require react/event-loop react/http react/async). In current ReactPHP versions there is a single global loop, and it starts automatically at the end of your script, so you no longer create it with a factory or call run() yourself.

A timer that fires every second and stops after five ticks:

<?php
require __DIR__ . '/vendor/autoload.php';

use React\EventLoop\Loop;

$count = 0;
$timer = Loop::addPeriodicTimer(1.0, function () use (&$count, &$timer) {
    echo "Tick\n";
    if (++$count === 5) {
        Loop::cancelTimer($timer);
    }
});

Three HTTP requests sent at the same time, awaited together:

<?php
require __DIR__ . '/vendor/autoload.php';

use React\Http\Browser;
use function React\Async\await;
use function React\Promise\all;

$browser = new Browser();

try {
    $responses = await(all([
        $browser->get('https://example.com/1'),
        $browser->get('https://example.com/2'),
        $browser->get('https://example.com/3'),
    ]));
    foreach ($responses as $response) {
        echo $response->getStatusCode(), ' ', strlen((string) $response->getBody()), " bytes\n";
    }
} catch (Throwable $e) {
    echo 'Request failed: ', $e->getMessage(), "\n";
}

The total time is roughly the slowest single request, not the sum of all three. await() uses Fibers under the hood, so the code reads top to bottom while the loop keeps running.

5. Swoole and OpenSwoole: WebSocket servers

Swoole, and its community fork OpenSwoole, are PHP extensions written in C. You install them with PECL or your distribution's packages, not with Composer. They give you coroutine-based servers with many worker processes.

A small WebSocket echo server:

<?php
use Swoole\WebSocket\Server;
use Swoole\WebSocket\Frame;
use Swoole\Http\Request;

$server = new Server('0.0.0.0', 9502);

$server->on('open', function (Server $server, Request $request) {
    echo "Connection opened: {$request->fd}\n";
});

$server->on('message', function (Server $server, Frame $frame) {
    $server->push($frame->fd, json_encode(['received' => $frame->data]));
});

$server->on('close', function (Server $server, int $fd) {
    echo "Connection closed: {$fd}\n";
});

$server->start();

The events here are open, message and close. With OpenSwoole the class names start with OpenSwoole\ instead of Swoole\; check the documentation of the extension you install. In production, put the server behind Nginx or another reverse proxy that terminates TLS, so browsers connect with wss://.

6. Best practices

Blocking I/O is the most common mistake. One slow database query inside a ReactPHP handler freezes every other connection until it finishes. Use async drivers built for your loop, or move the work to a separate process.

7. Running this on Domain India

Shared hosting (cPanel, DirectAdmin, Webuzo) runs PHP once per request. In-request event dispatchers from section 2 work normally there. Long-running event loops and socket servers do not fit shared hosting:

• On cPanel and DirectAdmin, proc_open and popen are disabled, and on cPanel the socket functions fsockopen and stream_socket_client are disabled too, which ReactPHP and AMPHP networking rely on. See PHP disabled functions on shared hosting.
• Composer cannot run on shared hosting. Run composer install on your own computer or in CI, then upload the project with its vendor/ folder.
• You can't install PHP extensions such as Swoole on a shared server.

App Platform. Only Node.js is detected automatically; a PHP event-loop app runs from a Dockerfile you provide, and it must listen on the PORT environment variable. See getting started with the App Platform.

VPS. A Domain India VPS is self-managed with full root access, so you can install PHP, Composer, Swoole or OpenSwoole, run the process under systemd and put Nginx in front for TLS. You are responsible for updates and security on your own server.

Prices on the cards are live and exclude 18% GST.

Ready to build? For an in-request event dispatcher, any PHP host works; for long-running servers, compare the VPS plans or the App Platform. Questions about your setup? Open a support ticket.