Eine Implementierungsmethode der Laravel-Sofortanwendung

Anwendungen zur sofortigen Interaktion

In modernen Webanwendungen erfordern viele Szenarien die Verwendung von Instant Messaging, wie z. B. die häufigsten Zahlungsrückrufe und die Drei-Parteien-Anmeldung. Diese Geschäftsszenarien müssen grundsätzlich dem folgenden Prozess folgen:

● Der Client löst zugehörige Geschäfte aus und generiert Drittanbieter-Anwendungsvorgänge (z. B. Zahlungen)

● Der Client wartet auf das Serverantwortergebnis (Benutzer schließt den Vorgang der Drittanbieteranwendung ab)

● Die Drittanbieteranwendung benachrichtigt den Server über das Verarbeitungsergebnis (Zahlung ist abgeschlossen)

● Der Server benachrichtigt den Client darüber Bearbeitungsergebnis

● Kundenbasis Feedback zum Ergebnis (Springe zur Zahlungserfolgsseite)

In der Vergangenheit, um diese Art von Instant Messaging zu erreichen und dem Kunden eine korrekte Reaktion zu ermöglichen Die am häufigsten verwendete Technologie zur Verarbeitung von Ergebnissen ist die Abfrage, da das HTTP-Protokoll eine einzige Ausrichtung hat und der Client den Server nur immer wieder aktiv nach den Verarbeitungsergebnissen fragen kann. Diese Methode weist offensichtliche Mängel auf und belegt nicht nur serverseitige Ressourcen, sondern kann auch keine serverseitigen Verarbeitungsergebnisse in Echtzeit erzielen.

Jetzt können wir das WebSocket-Protokoll verwenden, um Echtzeitinteraktionen abzuwickeln. Es handelt sich um ein Zwei-Wege-Protokoll, das es dem Server ermöglicht, aktiv Informationen an den Client zu übertragen. In diesem Artikel werden wir das leistungsstarke Ereignissystem von Laravel verwenden, um Echtzeitinteraktionen aufzubauen. Sie benötigen folgende Kenntnisse:

● Laravel Event

● Redis

● Socket.io

● Node.js

Redis

Bevor wir beginnen, müssen wir einen Redis-Dienst öffnen und ihn in der Laravel-Anwendung konfigurieren und aktivieren, da wir während des gesamten Prozesses den Abonnement- und Veröffentlichungsmechanismus von Redis verwenden müssen um Instant Messaging zu aktivieren.

Redis ist ein Open-Source- und effizientes Schlüsselwertspeichersystem. Es wird normalerweise als Datenstrukturserver zum Speichern von Schlüssel-Wert-Paaren verwendet und kann Zeichenfolgen, Hashes, Listen, Mengen und geordnete Kombinationen unterstützen. Um Redis in Laravel verwenden zu können, müssen Sie die Paketdateien predis/predis über Composer installieren.

Konfiguration

Die Konfigurationsdatei von Redis in der Anwendung wird in config/database.php gespeichert. In dieser Datei können Sie eine Datei mit Redis-Dienstinformationen sehen. Redis-Array:

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

Wenn Sie den Port des Redis-Dienstes ändern, achten Sie darauf, dass der Port in der Konfigurationsdatei konsistent bleibt.

Laravel Event

Hier müssen wir die leistungsstarken Event-Übertragungsfunktionen von Laravel nutzen:

Broadcast Event

Viele moderne Anwendungen nutzen Web Sockets, um interaktive Echtzeit-Benutzeroberflächen zu implementieren. Wenn sich einige Daten auf dem Server ändern, wird eine Nachricht zur Verarbeitung über die WebSocket-Verbindung an den Client weitergeleitet.

Um Ihnen bei der Erstellung dieser Art von Anwendung zu helfen. Laravel erleichtert die Übertragung von Ereignissen über eine WebSocket-Verbindung. Mit Laravel können Sie Ereignisse übertragen, um den Ereignisnamen an Ihre serverseitigen und clientseitigen JavaScript-Frameworks weiterzugeben.

Konfiguration

Alle Event-Broadcast-Konfigurationsoptionen werden in der Konfigurationsdatei config/broadcasting.php gespeichert. Laravel wird mit mehreren verfügbaren Treibern wie Pusher, Redis und Log geliefert. Wir werden Redis als Broadcast-Treiber verwenden, der die Klassenbibliothek predis/predis erfordert.

Da der Standard-Broadcast-Treiber Pusher verwendet, müssen wir BROADCAST_DRIVER=redis in der .env-Datei festlegen.

Wir erstellen eine WechatLoginedEvent-Ereignisklasse, die gesendet wird, nachdem der Benutzer WeChat gescannt hat, um sich anzumelden:

<?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;;
    }
}

Sie müssen beachten, dass die BroadcastOn-Methode ein Array zurückgeben sollte, das den zu sendenden Kanal darstellt , und BroadcastAs gibt eine Zeichenfolge zurück, die das durch die Übertragung ausgelöste Ereignis darstellt. Standardmäßig gibt Laravel den vollständigen Klassennamen der Ereignisklasse zurück.

Das Wichtigste ist, dass Sie es manuell implementieren müssen Diese Klasse ShouldBroadcast-Vertrag. Laravel hat diesen Namespace beim Generieren von Ereignissen automatisch hinzugefügt, und dieser Vertrag schränkt nur die BroadcastOn-Methode ein.

Nachdem das Ereignis abgeschlossen ist, besteht der nächste Schritt darin, das Ereignis auszulösen. Eine einfache Codezeile reicht aus:

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

Dieser Vorgang löst automatisch die Ausführung des Ereignisses aus und sendet die Informationen . Der zugrunde liegende Broadcast-Vorgang basiert auf dem Abonnement- und Veröffentlichungsmechanismus von Redis. RedisBroadcaster wird die öffentlich zugänglichen Daten der Veranstaltung über den angegebenen Kanal veröffentlichen. Wenn Sie mehr Kontrolle über die offengelegten Daten haben möchten, können Sie dem Ereignis die Methode „broadcastWith“ hinzufügen, die ein Array zurückgeben sollte:

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

Node.js und Socket.io

Für die veröffentlichten Informationen benötigen wir eine Verbindung, damit dieser die Redis-Veröffentlichung abonnieren und die Informationen mithilfe des WebSocket-Protokolls weiterleiten kann. Dies ist sehr praktisch Erstellen Sie diesen Dienst:

// 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);
});

Hier verwenden wir Node.js, um den socket.io-Server einzuführen und den 6001-Port abzuhören. Wir leihen uns den psubscribe-Befehl von redis aus, um Platzhalter zu verwenden, um schnell stapelweise zu abonnieren die Nachricht wird ausgelöst, Nachrichten werden über WebSocket weitergeleitet.

Socket.io-Client

Im Web-Frontend müssen wir den Socket.io-Client einführen, um die Kommunikation mit dem Server-Port 6001 zu öffnen und den Kanal zu abonnieren Ereignisse:

// 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
})

Die gesamte geschlossene Kommunikationsschleife ist nun vorbei und der Entwicklungsprozess sieht folgendermaßen aus:

● Erstellen Sie ein Ereignis in Laravel, das Broadcast-Benachrichtigungen unterstützt

● Legen Sie den Kanal und den Ereignisnamen fest, der gesendet werden soll

● Stellen Sie die Übertragung so ein, dass der Redis-Treiber verwendet wird

● Stellen Sie einen kontinuierlichen Dienst zum Abonnieren von Redis-Veröffentlichungen bereit und übertragen Sie die veröffentlichten Inhalte über das WebSocket-Protokoll an den Client.

● Der Client öffnet den WebSocket-Tunnel des Servers, abonniert Ereignisse und sendet die angegebenen Ereignisse an ihn antworten.

Weitere technische Artikel zu Laravel finden Sie in der Spalte Einführungs-Tutorial zum Laravel-Framework, um mehr darüber zu erfahren!

Das obige ist der detaillierte Inhalt vonEine Implementierungsmethode der Laravel-Sofortanwendung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!