Une méthode d'implémentation de l'application instantanée Laravel

Applications d'interaction instantanée

Dans les applications Web modernes, de nombreux scénarios nécessitent l'utilisation de la messagerie instantanée, tels que les rappels de paiement les plus courants et la connexion à trois. Ces scénarios métier doivent essentiellement suivre le processus suivant :

● Le client déclenche les activités associées et génère des opérations d'application tierces (telles que le paiement)

● Le client attend le résultat de la réponse du serveur (l'utilisateur termine l'opération de l'application tierce)

● L'application tierce informe le serveur du résultat du traitement (le paiement est terminé)

● Le serveur informe le client du résultat du traitement

● Base client Retour sur le résultat (accéder à la page de réussite du paiement)

Dans le passé, afin d'obtenir ce type de messagerie instantanée et de permettre au client de répondre correctement à Pour les résultats du traitement, la technologie la plus couramment utilisée était l'interrogation, car le protocole HTTP est à orientation unique, le client ne peut que demander activement au serveur les résultats du traitement, encore et encore. Cette méthode présente des défauts évidents. Non seulement elle occupe des ressources côté serveur, mais elle ne peut pas non plus obtenir les résultats du traitement côté serveur en temps réel.

Désormais, nous pouvons utiliser le protocole WebSocket pour gérer les interactions en temps réel. Il s'agit d'un protocole bidirectionnel qui permet au serveur de transmettre activement des informations au client. Dans cet article, nous utiliserons le puissant système d'événements de Laravel pour créer des interactions en temps réel. Vous aurez besoin des connaissances suivantes :

● Laravel Event

● Redis

● Socket.io

● Node.js

Redis

Avant de commencer, nous devons ouvrir un service Redis, le configurer et l'activer dans l'application Laravel, car tout au long du processus, nous devons utiliser le mécanisme d'abonnement et de publication de Redis pour activer la messagerie instantanée.

Redis est un système de stockage clé-valeur open source et efficace. Il est généralement utilisé comme serveur de structure de données pour stocker des paires clé-valeur et peut prendre en charge des chaînes, des hachages, des listes, des ensembles et des combinaisons ordonnées. Pour utiliser Redis dans Laravel, vous devez installer le fichier du package predis/predis via Composer.

Configuration

Le fichier de configuration de Redis dans l'application est stocké dans config/database.php Dans ce fichier, vous pouvez voir un fichier contenant des informations sur le service Redis. tableau redis :

'redis' => [
  'cluster' => false,
  'default' => [
    'host' => '127.0.0.1',
    'port' => 6379,
    'database' => 0,
  ],
]

Si vous modifiez le port du service redis, veuillez conserver la cohérence du port dans le fichier de configuration.

Événement Laravel

Ici, nous devons utiliser les puissantes capacités de diffusion d'événements de Laravel :

Événement de diffusion

De nombreuses applications modernes utilisent Web Sockets pour implémenter des interfaces utilisateur interactives en temps réel. Lorsque certaines données changent sur le serveur, un message est transmis au client pour traitement via la connexion WebSocket.

Pour vous aider à construire ce type d'application. Laravel facilite la diffusion d'événements via une connexion WebSocket. Laravel vous permet de diffuser des événements pour partager le nom de l'événement sur vos frameworks JavaScript côté serveur et côté client.

Configuration

Toutes les options de configuration de diffusion d'événements sont stockées dans le fichier de configuration config/broadcasting.php. Laravel est livré avec plusieurs pilotes disponibles tels que Pusher, Redis et Log. Nous utiliserons Redis comme pilote de diffusion, qui nécessite la bibliothèque de classes predis/predis.

Étant donné que le pilote de diffusion par défaut utilise le pusher, nous devons définir BROADCAST_DRIVER=redis dans le fichier .env.

Nous créons une classe d'événements WechatLoginedEvent à diffuser après que l'utilisateur ait scanné WeChat pour se connecter :

<?php
namespace App\Events;
use App\Events\Event;
use Illuminate\Queue\SerializesModels;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
class WechatLoginedEvent extends Event implements ShouldBroadcast
{
    use SerializesModels;
    public $token;
    protected $channel;
    /**
     * Create a new event instance.
     *
     * @param  string $token
     * @param  string $channel
     * @return void
     */
    public function __construct($token, $channel)
    {
        $this->token = $token;
        $this->channel = $channel;
    }
    /**
     * Get the channels the event should be broadcast on.
     *
     * @return array
     */
    public function broadcastOn()
    {
        return [$this->channel];
    }
    /**
     * Get the name the event should be broadcast on.
     *
     * @return string
     */
    public function broadcastAs()
    {
        return &#39;wechat.login&#39;;
    }
}

Vous devez noter que la méthode BroadcastOn doit renvoyer un tableau, qui représente la chaîne à diffuser. , et BroadcastAs renvoie une chaîne, qui représente l'événement déclenché par la diffusion. Laravel renvoie par défaut le nom complet de la classe d'événement. Voici AppEventsWechatLoginedEvent.

La chose la plus importante est que vous devez l'implémenter manuellement. ce contrat de classe ShouldBroadcast. Laravel a automatiquement ajouté cet espace de noms lors de la génération d'événements, et ce contrat ne contraint que la méthode BroadcastOn.

Une fois l'événement terminé, l'étape suivante consiste à déclencher l'événement. Une simple ligne de code suffit :

event(new WechatLoginedEvent($token, $channel));

Cette opération déclenchera automatiquement l'exécution de l'événement et diffusera l'information. . L'opération de diffusion sous-jacente repose sur le mécanisme d'abonnement et de publication de Redis. RedisBroadcaster publiera les données accessibles au public lors de l'événement via le canal indiqué. Si vous souhaitez avoir plus de contrôle sur les données exposées, vous pouvez ajouter la méthode BroadcastWith à l'événement, qui devrait renvoyer un tableau :

/**
 * Get the data to broadcast.
 *
 * @return array
 */
 public function broadcastWith() 
 {
   return ['user' => $this->user->id];
 }

Node.js et Socket.io

Pour les informations publiées, nous avons besoin d'un service pour nous connecter afin qu'il puisse s'abonner à la publication redis et transmettre les informations en utilisant le protocole WebSocket. Ici, nous pouvons emprunter Node.js et socket.io. construire ce service :

// server.js
var app = require('http').createServer(handler);
var io = require('socket.io')(app);
var Redis = require('ioredis');
var redis = new Redis();
app.listen(6001, function () {
  console.log('Server is running!') ;
});
function handler(req, res) {
  res.writeHead(200);
  res.end('');
}
io.on('connection', function (socket) {
  socket.on('message', function (message) {
    console.log(message)
  })
  socket.on('disconnect', function () {
    console.log('user disconnect')
  })
});
redis.psubscribe('*', function (err, count) {
});
redis.on('pmessage', function (subscrbed, channel, message) {
  message = JSON.parse(message);
  io.emit(channel + ':' + message.event, message.data);
});

Ici, nous utilisons Node.js pour introduire le serveur socket.io et écouter le port 6001. Nous empruntons la commande psubscribe de redis pour utiliser des caractères génériques pour nous abonner rapidement par lots, puis quand. le message est déclenché, les messages sont transmis via WebSocket.

Client Socket.io

Dans le front-end Web, nous devons introduire le client Socket.io pour ouvrir la communication avec le port 6001 du serveur et nous abonner au canal événements :

// client.js
let io = require('socket.io-client')
var socket = io(':6001')
      socket.on($channel + ':wechat.login', (data) => {
        socket.close()
        // save user token and redirect to dashboard
})

La boucle fermée de communication est désormais terminée et le processus de développement ressemble à ceci :

● Créez un événement dans Laravel qui prend en charge les notifications de diffusion

● Définissez le nom de la chaîne et de l'événement qui doivent être diffusés

● Définissez la diffusion pour utiliser le pilote Redis

● Fournir un service continu d'abonnement aux publications Redis et transmettre le contenu publié au client via le protocole WebSocket

● Le client ouvre le tunnel WebSocket du serveur, s'abonne aux événements et transmet les événements spécifiés à répondre.

Pour plus d'articles techniques liés à Laravel, veuillez visiter la colonne Tutoriel d'introduction au framework Laravel pour apprendre !

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!