Construire une application de messagerie en temps réel avec Redis et JavaScript : comment gérer les connexions des utilisateurs

Créer des applications de communication en temps réel à l'aide de Redis et JavaScript : comment gérer les connexions des utilisateurs

Avec le développement rapide d'Internet, la demande d'applications de communication en temps réel augmente. Les applications de communication en temps réel peuvent être bien construites à l'aide de Redis et de JavaScript pour implémenter des fonctions telles que l'envoi et la réception de messages en temps réel et la gestion des utilisateurs en ligne. Cet article expliquera comment utiliser Redis et JavaScript pour gérer les connexions utilisateur et implémenter des applications de communication en temps réel.

1. Installer et configurer Redis

Tout d'abord, nous devons installer et configurer le serveur Redis. Vous pouvez télécharger le package d'installation Redis adapté à votre système d'exploitation à partir du site Web officiel de Redis (https://redis.io/download), puis l'installer et le configurer conformément à la documentation officielle.

2. Créer un fichier JavaScript

Ensuite, créez un fichier JavaScript pour gérer les connexions des utilisateurs. Nous utilisons Node.js comme environnement backend, nous devons donc d'abord installer Node.js (https://nodejs.org/).

Dans le fichier JavaScript créé, introduisez d'abord les modules requis :

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

Ensuite, créez une application Express pour gérer les requêtes HTTP :

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

3. Gérer les connexions utilisateur

Ensuite, nous devons gérer les connexions utilisateur. Lorsqu'un utilisateur se connecte à l'application, nous devons effectuer une série d'actions.

Tout d'abord, écoutez l'événement de connexion utilisateur :

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

Ensuite, traitez la logique de connexion. Cela inclut les événements d’adhésion/départ des utilisateurs, la messagerie, etc. Dans cet exemple, nous ajoutons une simple fonctionnalité de salle de discussion.

// 存储在线用户的列表
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);
});

Dans le code ci-dessus, nous gérons la logique de connexion en écoutant les événements émis par l'utilisateur. Lorsqu'un utilisateur rejoint, nous l'ajoutons à la liste des utilisateurs en ligne et informons tous les utilisateurs ; lorsqu'un utilisateur quitte, nous le supprimons de la liste des utilisateurs en ligne et informons tous les utilisateurs lorsqu'un utilisateur envoie un message, nous envoyons le message à tous les utilisateurs ; .

4. Utilisez Redis pour stocker les utilisateurs en ligne

Afin de faciliter la gestion des utilisateurs en ligne, nous pouvons utiliser Redis pour stocker la liste des utilisateurs en ligne. Dans la logique de connexion, nous enregistrons la liste des utilisateurs en ligne dans Redis et diffusons les mises à jour de la liste des utilisateurs en ligne à tous les utilisateurs via Redis.

Tout d'abord, installez le module Redis :

npm install redis

Ensuite, ajoutez le code de connexion Redis au début de la logique de connexion :

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

De cette façon, nous pouvons enregistrer la liste des utilisateurs en ligne sur Redis lorsque les utilisateurs rejoignent et quittent, et Obtenez la liste des utilisateurs en ligne via Redis.

5. Exécuter l'application

Enfin, nous devons lancer l'application. Allez dans le répertoire où se trouve le fichier JavaScript dans le terminal et exécutez la commande suivante :

node 文件名.js

Ensuite, l'application s'exécutera sur le serveur local. Le serveur est accessible dans un navigateur et connecté au serveur via du code JavaScript.

Jusqu'à présent, nous avons implémenté une application simple de messagerie en temps réel utilisant Redis et JavaScript, et présenté comment gérer les connexions des utilisateurs. De cette manière, nous pouvons créer des applications de communication en temps réel plus complexes et réaliser davantage de fonctions. J'espère que cet article vous sera utile !

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!