Erstellen einer Echtzeit-Messaging-Anwendung mit Redis und JavaScript: Umgang mit Benutzerverbindungen

Erstellung von Echtzeit-Kommunikationsanwendungen mit Redis und JavaScript: Umgang mit Benutzerverbindungen

Mit der rasanten Entwicklung des Internets steigt die Nachfrage nach Echtzeit-Kommunikationsanwendungen. Mit Redis und JavaScript können Echtzeit-Kommunikationsanwendungen gut erstellt werden, um Funktionen wie das Senden und Empfangen von Nachrichten in Echtzeit sowie die Online-Benutzerverwaltung zu implementieren. In diesem Artikel wird erläutert, wie Sie Redis und JavaScript verwenden, um Benutzerverbindungen zu verwalten und Echtzeit-Kommunikationsanwendungen zu implementieren.

1. Redis installieren und konfigurieren

Zuerst müssen wir den Redis-Server installieren und konfigurieren. Sie können das für Ihr Betriebssystem geeignete Redis-Installationspaket von der offiziellen Redis-Website (https://redis.io/download) herunterladen und es dann gemäß der offiziellen Dokumentation installieren und konfigurieren.

2. JavaScript-Datei erstellen

Als Nächstes erstellen Sie eine JavaScript-Datei, um Benutzerverbindungen zu verarbeiten. Wir verwenden Node.js als Backend-Umgebung, daher müssen wir zuerst Node.js (https://nodejs.org/) installieren.

Führen Sie in der erstellten JavaScript-Datei zunächst die erforderlichen Module ein:

const express = require('express');
const http = require('http');
const socketio = require('socket.io');

Erstellen Sie dann eine Express-Anwendung zur Verarbeitung von HTTP-Anfragen:

const app = express();
const server = http.createServer(app);
const io = socketio(server);

3. Benutzerverbindungen verarbeiten

Als nächstes müssen wir Benutzerverbindungen verwalten. Wenn ein Benutzer eine Verbindung zur App herstellt, müssen wir eine Reihe von Aktionen ausführen.

Hören Sie sich zunächst das Benutzerverbindungsereignis an:

io.on('connection', (socket) => {
  // 处理连接逻辑
});

Verarbeiten Sie dann die Verbindungslogik. Dazu gehören Ereignisse zum Beitreten/Verlassen von Benutzern, Nachrichten und mehr. In diesem Beispiel fügen wir eine einfache Chatroom-Funktionalität hinzu.

// 存储在线用户的列表
let onlineUsers = [];

// 监听用户加入事件
socket.on('join', (user) => {
  onlineUsers.push(user);
  io.emit('userJoined', onlineUsers);
});

// 监听用户离开事件
socket.on('disconnect', () => {
  onlineUsers = onlineUsers.filter((user) => user.id !== socket.id);
  io.emit('userLeft', onlineUsers);
});

// 监听消息发送事件
socket.on('sendMessage', (message) => {
  io.emit('newMessage', message);
});

Im obigen Code handhaben wir die Verbindungslogik, indem wir auf vom Benutzer ausgegebene Ereignisse hören. Wenn ein Benutzer beitritt, fügen wir ihn der Online-Benutzerliste hinzu und benachrichtigen alle Benutzer. Wenn ein Benutzer die Online-Benutzerliste verlässt, benachrichtigen wir alle Benutzer. Wenn ein Benutzer eine Nachricht sendet, senden wir die Nachricht an alle Benutzer .

4. Verwenden Sie Redis zum Speichern von Online-Benutzern

Um die Verwaltung von Online-Benutzern zu erleichtern, können wir Redis zum Speichern der Online-Benutzerliste verwenden. In der Verbindungslogik speichern wir die Online-Benutzerliste in Redis und senden Aktualisierungen der Online-Benutzerliste über Redis an alle Benutzer.

Installieren Sie zunächst das Redis-Modul:

npm install redis

Dann fügen Sie den Redis-Verbindungscode am Anfang der Verbindungslogik hinzu:

const redis = require('redis');
const client = redis.createClient();

client.on('error', (err) => {
  console.error(err);
});

// 连接Redis服务器后执行的操作
client.on('connect', () => {
  // 从Redis中获取在线用户列表
  client.smembers('onlineUsers', (err, reply) => {
    if (err) throw err;
    onlineUsers = reply;
    io.emit('userJoined', onlineUsers);
  });
});

// 监听用户加入事件
socket.on('join', (user) => {
  onlineUsers.push(user);
  // 将在线用户列表保存到Redis中
  client.sadd('onlineUsers', user, (err, reply) => {
    if (err) throw err;
    io.emit('userJoined', onlineUsers);
  });
});

// 监听用户离开事件
socket.on('disconnect', () => {
  onlineUsers = onlineUsers.filter((user) => user.id !== socket.id);
  // 从Redis中删除离线用户
  client.srem('onlineUsers', socket.id, (err, reply) => {
    if (err) throw err;
    io.emit('userLeft', onlineUsers);
  });
});

Auf diese Weise können wir die Online-Benutzerliste in Redis speichern, wenn Benutzer beitreten und gehen und Erhalten Sie die Online-Benutzerliste über Redis.

5. App ausführen

Zuletzt müssen wir die App starten. Gehen Sie im Terminal in das Verzeichnis, in dem sich die JavaScript-Datei befindet, und führen Sie den folgenden Befehl aus:

node 文件名.js

Anschließend wird die Anwendung auf dem lokalen Server ausgeführt. Der Server kann in einem Browser aufgerufen und über JavaScript-Code mit dem Server verbunden werden.

Bisher haben wir eine einfache Echtzeit-Messaging-Anwendung mit Redis und JavaScript implementiert und den Umgang mit Benutzerverbindungen vorgestellt. Auf diese Weise können wir komplexere Echtzeit-Kommunikationsanwendungen erstellen und mehr Funktionen erreichen. Ich hoffe, dieser Artikel ist hilfreich für Sie!

Das obige ist der detaillierte Inhalt vonErstellen einer Echtzeit-Messaging-Anwendung mit Redis und JavaScript: Umgang mit Benutzerverbindungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!