To implement a real-time notification system, the core is to establish a long connection between the server and the client. 1. Use the WebSocket protocol to realize two-way real-time communication, PHP can be implemented through Ratchet and other libraries; 2. The front-end uses JavaScript to establish connections and process messages; 3. Optional message queues such as Redis Pub/Sub decoupling high concurrency pressure; 4. Passing tokens through URL parameters to achieve user identity authentication; 5. Optimizing performance can be achieved through Swoole, message compression, connection pooling and other means; 6. The front-end realizes the disconnection mechanism, and uses an exponential backoff algorithm to control the reconnect frequency.

PHP implements a real-time notification system. Simply put, it is to enable your website or application to know new news like WeChat. The core is to establish a long connection between the server and the client, so that the server can push messages to the client at any time.

Solution

To implement PHP real-time notification system, it mainly relies on the following technical points:

1. WebSocket : This is the key to real-time communication. The WebSocket protocol allows servers and clients to establish persistent connections, and data can be transmitted in real time in both directions. PHP itself does not directly support WebSocket, and requires extensions or third-party libraries.

   

2. Message queue (optional) : When the concurrency is large, the message queue can decouple the sending and receiving of messages to avoid excessive server pressure. Commonly used message queue services include RabbitMQ, Redis Pub/Sub, etc.

3. Front-end technology : The front-end needs to use JavaScript to establish a WebSocket connection and process the received messages.

   

Specific steps:

• Choose WebSocket Server: The more popular choice is Ratchet. Ratchet is a pure PHP implementation WebSocket library, which is easy to use. You can also choose Socket.IO for Node.js, but this means you need to maintain both PHP and Node.js environments.

• Install Ratchet (if selected): Install through Composer: composer require cboden/ratchet

• Write WebSocket server-side code (PHP):

   <?php
  use Ratchet\Server\IoServer;
  use Ratchet\Http\HttpServer;
  use Ratchet\WebSocket\WsServer;
  use MyApp\MessageHandler;
  
  require __DIR__ . &#39;/vendor/autoload.php&#39;;
  
  // Create a class that handles messages MessageHandler implements Ratchet\MessageComponentInterface {
      protected $clients;
  
      public function __construct() {
          $this->clients = new \SplObjectStorage;
      }
  
      public function onOpen(\Ratchet\ConnectionInterface $conn) {
          $this->clients->attach($conn);
          echo "New connection! ({$conn->resourceId})\n";
      }
  
      public function onMessage(\Ratchet\ConnectionInterface $from, $msg) {
          $numRecv = count($this->clients) - 1;
          echo sprintf(&#39;Connection %d sending message "%s" to %d other connection%s&#39; . "\n"
              , $from->resourceId, $msg, $numRecv, $numRecv == 1 ? &#39;&#39; : &#39;s&#39;);
  
          foreach ($this->clients as $client) {
              if ($from !== $client) {
                  // The sender is not the receiver, send to each client connected
                  $client->send($msg);
              }
          }
      }
  
      public function onClose(\Ratchet\ConnectionInterface $conn) {
          $this->clients->detach($conn);
          echo "Connection {$conn->resourceId} has disconnected\n";
      }
  
      public function onError(\Ratchet\ConnectionInterface $conn, \Exception $e) {
          echo "An error has occurred: {$e->getMessage()}\n";
          $conn->close();
      }
  }
  
  // Start WebSocket server $server = IoServer::factory(
      new HttpServer(
          new WsServer(
              new MessageHandler()
          )
      ),
      8080 // Listen to port);
  
  $server->run();

• Write front-end code (JavaScript):

   var conn = new WebSocket('ws://localhost:8080'); // Connect to WebSocket server conn.onopen = function(e) {
      console.log("Connection established!");
  };
  
  conn.onmessage = function(e) {
      console.log(e.data); // Process the received message// Display the message on the page, for example:
      var message = document.createElement("p");
      message.textContent = e.data;
      document.body.appendChild(message);
  };
  
  // Send message function sendMessage() {
      var messageInput = document.getElementById("messageInput");
      var message = messageInput.value;
      conn.send(message);
      messageInput.value = ""; // Clear the input box}
  
  conn.onclose = function(e) {
      console.log("Connection closed.");
  };

• Integrated message queue (optional): If you need to handle high concurrency, you can send messages to the message queue first, and then a specialized process reads the messages from the message queue and pushes them to the client. For example, use Redis's PUBLISH and SUBSCRIBE commands.

How to handle user authentication and authorization?

Authentication and authorization are important components of the real-time notification system. WebSocket itself does not provide an authentication mechanism and needs to be implemented by itself. A common practice is to pass the token through the URL parameter when the WebSocket connection is established, and then verify the validity of the token on the server side.

• front end:

   // Get the user token (assuming it has been stored in localStorage)
  const token = localStorage.getItem('userToken');
  var conn = new WebSocket('ws://localhost:8080?token=' token);

• Backend (PHP):

   public function onOpen(\Ratchet\ConnectionInterface $conn) {
      $uri = $conn->httpRequest->getUri();
      parse_str($uri->getQuery(), $parameters);
  
      $token = $parameters['token'] ?? null;
  
      // Verify token
      if (!$this->isValidToken($token)) {
          $conn->close(); // Close the connection return;
      }
  
      // Get the user ID or other user information and store it in the connection object $userId = $this->getUserIdByToken($token);
      $conn->userId = $userId; // Store user ID
  
      $this->clients->attach($conn);
      echo "New connection! User ID: {$userId} ({$conn->resourceId})\n";
  }
  
  private function isValidToken($token) {
      // Implement token verification logic, such as querying the database // Return true to indicate that the token is valid, otherwise return false
      // ...
      return true; // Example, always return true
  }
  
  private function getUserIdByToken($token) {
      // Get the user ID based on the token, for example querying the database // ...
      return 123; // Example, return fixed user ID
  }

After verification is passed, the user ID or other user information can be stored in the connection object $conn for easier subsequent use. When sending a message, it can be filtered according to the user ID and sent to only specific users.

How to optimize the performance of PHP real-time notification system?

Performance optimization is the key to any real-time system. Here are some optimization measures that can be considered:

1. Using a high-performance WebSocket server: Ratchet is a good choice, but if you have higher performance requirements, you can consider Swoole extensions. Swoole is a PHP extension based on C language, providing asynchronous and multi-threaded network programming capabilities, and its performance is much higher than that of traditional PHP environments.

2. Use message queue: Message queue can decouple the sending and receiving of messages, avoiding excessive server pressure.

3. Optimize database query: Avoid frequent database query on the WebSocket server side. Commonly used data can be cached into memory, for example using Redis.

4. Compressed messages: Compress sent messages to reduce the bandwidth of network transmission.

5. Connection pool: If you need to connect to a database or other service, you can use the connection pool to reuse the connection to avoid the overhead of frequent creation and destruction of connections.

6. Load balancing: When the concurrency is large, you can use a load balancer to distribute requests to multiple servers to improve the overall throughput of the system.

7. Heartbeat detection: send heartbeat packets regularly to detect whether the client is still online. If the client does not respond for a long time, close the connection and free the resource.

How to deal with disconnection and reconnection?

Network instability is common, so disconnection and reconnection are issues that must be considered in real-time notification systems.

• front end:

   conn.onclose = function(e) {
      console.log("Connection closed. Reconnecting in 5 seconds...");
      setTimeout(function() {
          // Reconnect to the WebSocket server conn = new WebSocket('ws://localhost:8080?token=' token);
          //Re-register the event handler function (onopen, onmessage, onerror)
          // ...
      }, 5000); // Reconnect after 5 seconds};

• Backend (PHP):

  The backend does not need to do special processing, because after the WebSocket connection is disconnected, the server will automatically trigger the onClose event, which can clean up resources in this event. What is important is that the front end is responsible for reconnection.

In practical applications, an exponential backoff algorithm can be used to control the frequency of reconnection to avoid frequent reconnection when the network is in poor condition.

The above is the detailed content of How to use PHP to implement real-time notification system PHP message push and subscription. For more information, please follow other related articles on the PHP Chinese website!