PHP alone cannot handle WebSockets due to its request-response nature, but it can support real-time features by handling authentication, business logic, and data management; 2. Use Ratchet, a PHP WebSocket library built on ReactPHP, to create a persistent server for bidirectional communication; 3. Set up a basic WebSocket server with Ratchet via Composer, implement the MessageComponentInterface to manage connections, messages, and closures, and run the server on a designated port; 4. Connect to the WebSocket server from the client-side using JavaScript’s WebSocket API to send and receive real-time messages; 5. Integrate the WebSocket server with traditional PHP apps (e.g., Laravel or Symfony) by sharing sessions and authentication through tokens like JWT or session IDs passed during connection; 6. Improve scalability by using Redis with Pub/Sub to decouple the PHP app and WebSocket server, allowing the web app to publish events and the server to broadcast them; 7. Consider performance limitations of Ratchet under high load and opt for alternatives like Swoole for better concurrency, or use Node.js, Go, or managed services like Pusher or Ably for production-grade scalability; 8. Swoole offers high-performance async capabilities and built-in WebSocket support, making it a superior choice for large-scale real-time applications compared to Ratchet; 9. Ultimately, PHP can effectively contribute to real-time applications when combined with a persistent WebSocket server and scalable infrastructure, but should not be used standalone for real-time communication.

Real-time features—like live chat, notifications, or live updates—are increasingly expected in modern web apps. While PHP is traditionally used for request-response workflows, it can power real-time functionality when paired with WebSockets. Here’s how to build real-time applications using PHP and WebSockets effectively.

Why PHP Isn’t Enough on Its Own

PHP, by design, runs per HTTP request and terminates after sending a response. This makes it unsuitable for maintaining persistent connections needed for WebSockets. However, PHP can still play a key role in real-time apps by:

• Handling authentication and initial setup
• Feeding data to a WebSocket server
• Managing business logic and database interactions

To enable real-time communication, you need a persistent WebSocket server. PHP alone can’t do this, but it can work alongside a WebSocket server.

Using Ratchet: PHP’s WebSocket Library

Ratchet is a popular PHP library that lets you create WebSocket servers directly in PHP. It allows PHP to maintain long-lived connections and communicate with clients in real time.

Setting Up a Basic WebSocket Server

1. Install Ratchet via Composer:

   

   composer require ratchet/rfc6455 react/http react/socket

2. Create a WebSocket server (e.g., server.php):

   use Ratchet\MessageComponentInterface;
   use Ratchet\ConnectionInterface;
   use Ratchet\Server\IoServer;
   use Ratchet\Http\HttpServer;
   use Ratchet\WebSocket\WsServer;
   
   class Chat implements MessageComponentInterface {
       protected $clients;
   
       public function __construct() {
           $this->clients = new \SplObjectStorage;
       }
   
       public function onOpen(ConnectionInterface $conn) {
           $this->clients->attach($conn);
           echo "New connection! ({$conn->resourceId})\n";
       }
   
       public function onMessage(ConnectionInterface $from, $msg) {
           foreach ($this->clients as $client) {
               if ($from !== $client) {
                   $client->send($msg);
               }
           }
       }
   
       public function onClose(ConnectionInterface $conn) {
           $this->clients->detach($conn);
           echo "Connection {$conn->resourceId} closed\n";
       }
   
       public function onError(ConnectionInterface $conn, \Exception $e) {
           echo "Error: {$e->getMessage()}\n";
           $conn->close();
       }
   }
   
   $server = IoServer::factory(
       new HttpServer(new WsServer(new Chat())),
       8080
   );
   
   echo "WebSocket server started on port 8080...\n";
   $server->run();

3. Run the server:

   php server.php

4. Connect from JavaScript:

   <script>
     const conn = new WebSocket('ws://localhost:8080');
     conn.onopen = function(e) {
       console.log("Connected!");
     };
     conn.onmessage = function(e) {
       console.log("Message:", e.data);
     };
     conn.send("Hello Server!");
   </script>

This gives you a working bidirectional channel.

Integrating with Traditional PHP Apps

Your main web app (login, pages, forms) can still run on Laravel, Symfony, or plain PHP. The WebSocket server runs separately but can access the same database or APIs.

Share Sessions and Authentication

To authenticate WebSocket connections:

• Pass a token from the logged-in user to the client

• Validate it when the WebSocket connects

• Example: Send a JWT or session ID when connecting:

  const token = 'user-jwt-or-session-id';
  const conn = new WebSocket(`ws://localhost:8080?token=${token}`);

• In the onOpen method, verify the token against your PHP app’s session or auth system.

Performance Considerations

• PHP WebSocket servers (like Ratchet) are single-threaded and may not scale to thousands of connections without additional infrastructure.
• Use ReactPHP under the hood—Ratchet is built on it, enabling async, non-blocking I/O.
• For high-load apps, consider:
  • Offloading WebSockets to Node.js or Go
  • Using a message broker like Redis with Pub/Sub to decouple components

Using Redis for Scalability

You can use Redis to allow your PHP app and WebSocket server to communicate indirectly:

// In your web app (e.g., when a notification is created)
$redis = new Predis\Client();
$redis->publish('notifications', json_encode(['user_id' => 123, 'msg' => 'New message!']));

// In your Ratchet server, subscribe to Redis
$loop = React\EventLoop\Factory::create();
$redis = new Clue\React\Redis\Client('localhost', $loop);

$redis->subscribe('notifications')->then(function ($subscription) {
    $subscription->on('message', function ($channel, $data) {
        $payload = json_decode($data, true);
        // Forward to relevant clients via WebSocket
        foreach ($this->clients as $client) {
            $client->send($payload['msg']);
        }
    });
});

This way, your regular PHP pages can trigger real-time events without talking directly to the WebSocket server.

Alternatives and Hybrid Approaches

While Ratchet works, consider:

• Node.js Socket.IO: More mature real-time ecosystem
• Pusher, Pusher Channels, or Ably: Managed WebSocket services—great for production
• Swoole: A PHP extension that enables async programming and built-in WebSocket servers with better performance than Ratchet

Example with Swoole:

$server = new Swoole\WebSocket\Server("0.0.0.0", 8080);

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

$server->on('message', function ($server, $frame) {
    foreach ($server->connections as $fd) {
        $server->push($fd, $frame->data);
    }
});

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

$server->start();

Swoole is faster and handles concurrency better than Ratchet.

Final Thoughts

Yes, you can build real-time apps with PHP and WebSockets—especially using Ratchet or Swoole. But it’s important to understand the trade-offs:

• Use PHP for business logic and traditional web handling
• Use a persistent WebSocket server (Ratchet, Swoole, or external service) for real-time comms
• Integrate via Redis or message queues for scalability

For small to medium apps, Ratchet is fine. For larger systems, consider managed services or switching the real-time layer to a more scalable runtime.

Basically, PHP can be part of the real-time stack—it just shouldn’t be the only piece.

The above is the detailed content of Building Real-time Applications with PHP and WebSockets. For more information, please follow other related articles on the PHP Chinese website!