Comment utiliser PHP pour implémenter le système de notification en temps réel PHP PUSH ET ABONNEMENT

Pour implémenter un système de notification en temps réel, le noyau consiste à établir une longue connexion entre le serveur et le client. 1. Utilisez le protocole WebSocket pour réaliser une communication bidirectionnelle en temps réel, PHP peut être implémenté via Ratchet et d'autres bibliothèques; 2. Le frontal utilise JavaScript pour établir des connexions et des messages de traitement; 3. Files d'attente de messages facultatives telles que Redis Pub / sous-découplage de pression de concurrence élevée; 4. Passer les jetons via des paramètres d'URL pour atteindre l'authentification de l'identité utilisateur; 5. Optimisation des performances peut être réalisée via Swoole, la compression de messages, la mise en commun des connexions et d'autres moyens; 6. Le front-end réalise le mécanisme de déconnexion et utilise un algorithme de backoff exponentiel pour contrôler la fréquence de reconnexion.

PHP implémente un système de notification en temps réel. Autrement dit, c'est pour permettre à votre site Web ou à votre application de connaître de nouvelles nouvelles comme WeChat. Le noyau est d'établir une longue connexion entre le serveur et le client, afin que le serveur puisse appuyer sur les messages au client à tout moment.

Solution

Pour implémenter le système de notification en temps réel PHP, il repose principalement sur les points techniques suivants:

1. WebSocket : Ceci est la clé de la communication en temps réel. Le protocole WebSocket permet aux serveurs et aux clients d'établir des connexions persistantes et les données peuvent être transmises en temps réel dans les deux sens. PHP lui-même ne prend pas directement en charge WebSocket et nécessite des extensions ou des bibliothèques tierces.

   

2. File d'attente de message (facultative) : Lorsque la concurrence est grande, la file d'attente de messages peut découpler l'envoi et la réception de messages pour éviter une pression excessive du serveur. Les services de file d'attente de messages couramment utilisés comprennent RabbitMQ, Redis Pub / Sub, etc.

3. Technologie frontale : le frontal doit utiliser JavaScript pour établir une connexion WebSocket et traiter les messages reçus.

   

Étapes spécifiques:

• Choisissez WebSocket Server: le choix le plus populaire est le cliquet. Ratchet est une bibliothèque WebSocket d'implémentation PHP pure, qui est facile à utiliser. Vous pouvez également choisir Socket.io pour Node.js, mais cela signifie que vous devez maintenir les environnements PHP et Node.js.

• Installer Ratchet (si sélectionné): Installer via Composer: composer require cboden/ratchet

• Écrivez le code de côté serveur (PHP):

   <? Php
  Utilisez Ratchet \ Server \ ioServer;
  Utilisez Ratchet \ http \ httpServer;
  Utilisez Ratchet \ WebSocket \ WSServer;
  Utilisez MyApp \ MessageHandler;
  
  exiger __dir__. «/ vendeur/autoload.php»;
  
  // Créer une classe qui gère les messages MessageHandler implémente Ratchet \ MessageComponentInterface {
      Protégé des clients $;
  
      fonction publique __construct () {
          $ this-> Clients = new \ spobjectStorage;
      }
  
      Fonction publique OnOpen (\ Ratchet \ ConnectionInterface $ Conn) {
          $ this-> Clients-> attach ($ Conn);
          echo "Nouvelle connexion! ({$ con-> ResourceId}) \ n";
      }
  
      Fonction publique OnMessage (\ Ratchet \ ConnectionInterface $ From, $ msg) {
          $ numRecv = count ($ this-> clients) - 1;
          Echo Sprintf (&#39;Connexion% D Envoi du message "% s" à% d Autre connexion% s&#39;. "\ n"
              , $ From-> ResourceID, $ msg, $ numRecv, $ numRecv == 1? &#39;&#39;: &#39;s&#39;);
  
          foreach ($ this-> clients en tant que client $) {
              if ($ from! == $ client) {
                  // l&#39;expéditeur n&#39;est pas le récepteur, envoyé à chaque client connecté
                  $ client-> Send ($ msg);
              }
          }
      }
  
      Fonction publique OnClose (\ Ratchet \ ConnectionInterface $ Conn) {
          $ this-> clients-> détach ($ Conn);
          echo "Connection {$ con-> ResourceID} a déconnecté \ n";
      }
  
      Fonction publique OnError (\ Ratchet \ ConnectionInterface $ Conn, \ Exception $ e) {
          Echo "Une erreur s&#39;est produite: {$ e-> getMessage ()} \ n";
          $ Conn-> close ();
      }
  }
  
  // Démarrer WebSocket Server $ server = iOServer :: Factory (
      Nouveau httpSserver (
          Nouveau wsserver (
              nouveau messagehandler ()
          )
      ),
      8080 // écouter le port);
  
  $ server-> run ();

• Écrivez le code frontal (JavaScript):

   var conn = new WebSocket ('ws: // localhost: 8080'); // Connectez-vous à WebSocket Server Conn.onOpen = fonction (E) {
      console.log ("Connexion établie!");
  };
  
  conn.onMessage = fonction (e) {
      console.log (e.data); // Traitez le message reçu // Affichez le message sur la page, par exemple:
      var message = document.CreateElement ("p");
      Message.TextContent = E.Data;
      document.body.appendChild (message);
  };
  
  // Envoi de la fonction de message sendMessage () {
      var messageInput = document.getElementById ("messageInput");
      var message = messageInput.Value;
      Conn.Send (message);
      messageInput.value = ""; // efface la boîte d'entrée}
  
  Conn.OnClose = fonction (e) {
      console.log ("Connexion fermée.");
  };

• Fitre de messages intégrée (facultatif): Si vous avez besoin de gérer une concurrence élevée, vous pouvez d'abord envoyer des messages à la file d'attente de messages, puis un processus spécialisé lit les messages de la file d'attente de messages et les pousse au client. Par exemple, utilisez les commandes PUBLISH et SUBSCRIBE de Redis.

Comment gérer l'authentification et l'autorisation des utilisateurs?

L'authentification et l'autorisation sont des composantes importantes du système de notification en temps réel. WebSocket lui-même ne fournit pas de mécanisme d'authentification et doit être mis en œuvre par lui-même. Une pratique courante consiste à passer le jeton via le paramètre URL lorsque la connexion WebSocket est établie, puis à vérifier la validité du jeton côté serveur.

• l'extrémité avant:

   // Obtenez le jeton utilisateur (en supposant qu'il a été stocké dans LocalStorage)
  const token = localStorage.getItem ('usertoken');
  var conn = new WebSocket ('ws: // localhost: 8080? token =' token);

• Backend (PHP):

   Fonction publique OnOpen (\ Ratchet \ ConnectionInterface $ Conn) {
      $ uri = $ con-> httprequest-> getUri ();
      parse_str ($ uri-> getQuery (), $ paramètres);
  
      $ token = $ Paramètres ['Token'] ?? nul;
  
      // Vérifiez le jeton
      if (! $ this-> isvalidtoken ($ token)) {
          $ Conn-> close (); // Fermez le retour de la connexion;
      }
  
      // Obtenez l'ID utilisateur ou d'autres informations utilisateur et les stocker dans l'objet de connexion $ userId = $ this-> getUserIdByToken ($ token);
      $ Conn-> userId = $ userId; // Stockez l'ID utilisateur
  
      $ this-> Clients-> attach ($ Conn);
      echo "Nouvelle connexion! ID utilisateur: {$ userId} ({$ con-> ResourceId}) \ n";
  }
  
  fonction privée isValidToken (token $) {
      // Implémentez la logique de vérification du jeton, telles que la question de l'interrogation de la base de données // renvoie true pour indiquer que le jeton est valide, sinon renvoyez false
      // ...
      Retour Vrai; // Exemple, renvoie toujours vrai
  }
  
  fonction privée getUserIdByToken (token $) {
      // Obtenez l'ID utilisateur basé sur le jeton, par exemple en interrogeant la base de données // ...
      retour 123; // Exemple, renvoyer l'ID utilisateur fixe
  }

Une fois la vérification passée, l'ID utilisateur ou d'autres informations utilisateur peuvent être stockées dans l'objet de connexion $conn pour une utilisation ultérieure plus facile. Lors de l'envoi d'un message, il peut être filtré en fonction de l'ID utilisateur et envoyé uniquement à des utilisateurs spécifiques.

Comment optimiser les performances du système de notification en temps réel PHP?

L'optimisation des performances est la clé de tout système en temps réel. Voici quelques mesures d'optimisation qui peuvent être prises en compte:

1. En utilisant un serveur WebSocket haute performance: Ratchet est un bon choix, mais si vous avez des exigences de performances plus élevées, vous pouvez envisager des extensions Swoole. Swoole est une extension PHP basée sur le langage C, fournissant des capacités de programmation de réseau asynchrones et multithreads, et ses performances sont beaucoup plus élevées que celles des environnements PHP traditionnels.

2. Utiliser la file d'attente de messages: la file d'attente de messages peut découpler l'envoi et la réception de messages, en évitant une pression excessive du serveur.

3. Optimiser la requête de la base de données: évitez les requêtes de base de données fréquentes du côté du serveur WebSocket. Les données couramment utilisées peuvent être mises en cache dans la mémoire, par exemple en utilisant Redis.

4. Messages compressés: compressez les messages envoyés pour réduire la bande passante de la transmission du réseau.

5. Pool de connexion: Si vous devez vous connecter à une base de données ou à un autre service, vous pouvez utiliser le pool de connexions pour réutiliser la connexion afin d'éviter les frais généraux de création et de destruction fréquentes des connexions.

6. Équilibrage de charge: lorsque la concurrence est grande, vous pouvez utiliser un équilibreur de charge pour distribuer des demandes à plusieurs serveurs pour améliorer le débit global du système.

7. Détection du rythme cardiaque: Envoyez régulièrement des paquets de battements cardiaques pour détecter si le client est toujours en ligne. Si le client ne répond pas longtemps, fermez la connexion et libérez la ressource.

Comment gérer la déconnexion et la reconnexion?

L'instabilité du réseau est courante, donc la déconnexion et la reconnexion sont des problèmes qui doivent être pris en compte dans les systèmes de notification en temps réel.

• l'extrémité avant:

   Conn.OnClose = fonction (e) {
      Console.log ("Connexion fermée. Reconnecte en 5 secondes ...");
      setTimeout (function () {
          // reconnecter le serveur WebSocket Conn = new WebSocket ('ws: // localhost: 8080? Token =' token);
          // Register la fonction du gestionnaire d'événements (Onopen, OnMessage, OnError)
          // ...
      }, 5000); // reconnecter après 5 secondes};

• Backend (PHP):

  Le backend n'a pas besoin de faire un traitement spécial, car une fois la connexion WebSocket déconnectée, le serveur déclenchera automatiquement l'événement onClose , qui peut nettoyer les ressources de cet événement. Ce qui est important, c'est que le frontal est responsable de la reconnexion.

Dans les applications pratiques, un algorithme de backoff exponentiel peut être utilisé pour contrôler la fréquence de reconnexion pour éviter la reconnexion fréquente lorsque le réseau est en mauvais état.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!