Pratique de développement Java Websocket : comment gérer les connexions simultanées à grande échelle

Java Websocket est un protocole utilisé pour établir une communication bidirectionnelle en temps réel entre un navigateur Web et un serveur Web. Dans les applications Internet d'aujourd'hui, le temps réel devient de plus en plus important, et l'un des scénarios qui nécessitent une communication en temps réel est le chat social. Dans les scénarios de chat, des connexions simultanées à grande échelle doivent être gérées. Et Java Websocket est un excellent choix.

Dans cet article, nous présenterons comment utiliser Java Websocket pour gérer les connexions simultanées à grande échelle à travers des exemples de code.

Jetons d’abord un coup d’œil aux idées communes. Dans Java Websocket, le Servlet et le WebSocketEndpoint de Java EE sont souvent utilisés. Dans quelques exemples simples, nous utiliserons ces classes, mais lorsque le nombre de connexions augmente, l'utilisation directe de ces classes peut facilement provoquer des goulots d'étranglement en termes de performances, et nous devons utiliser des outils plus efficaces pour gérer les connexions.

Ici, nous utiliserons la bibliothèque netty-socketio de JavaTreasureChest pour gérer les connexions Java Websocket. Netty est un framework de programmation réseau hautes performances et SocketIO est un protocole permettant d'implémenter des applications en temps réel.

Exemple de code

Tout d'abord, nous devons ajouter la dépendance de la bibliothèque netty-socketio. Dans le projet Maven, nous pouvons ajouter les dépendances suivantes dans le fichier pom.xml :

<dependency>
    <groupId>com.corundumstudio.socketio</groupId>
    <artifactId>netty-socketio</artifactId>
    <version>1.7.17</version>
</dependency>

Ensuite, nous devons implémenter une classe Java en tant que serveur WebSocket et écouter les demandes de connexion. L'exemple de code est le suivant :

import com.corundumstudio.socketio.*;
import com.corundumstudio.socketio.listener.*;

public class WebSocketServer {
    public static void main(String[] args) {
        // 创建配置对象
        Configuration config = new Configuration();
        config.setHostname("localhost");
        config.setPort(9092);

        // 创建SocketIO服务器
        SocketIOServer server = new SocketIOServer(config);

        // 添加连接事件监听器
        server.addConnectListener(new ConnectListener() {
            @Override
            public void onConnect(SocketIOClient client) {
                System.out.println("连接成功：" + client.getSessionId().toString());
            }
        });

        // 启动服务器
        server.start();

        // 等待连接关闭
        System.in.read();
        server.stop();
    }
}

Dans ce code, nous utilisons la classe SocketIOServer de la bibliothèque SocketIO pour créer un serveur WebSocket. Lorsque la connexion est réussie, le message de réussite de la connexion sera imprimé.

Ensuite, nous devons enregistrer l'écouteur auprès du serveur afin qu'il puisse être traité lorsque le client se connecte. Le code est le suivant :

// 添加事件监听器
server.addEventListener("client_msg", String.class, new DataListener<String>() {
    @Override
    public void onData(SocketIOClient client, String data, AckRequest ackRequest) {
        System.out.println("收到消息：" + data + "，sessionId=" + client.getSessionId());
    }
});

Dans cet extrait de code, nous avons enregistré un événement appelé "client_msg" et ajouté un DataListener pour gérer les messages reçus.

Parfois, nous pouvons également avoir besoin d'authentifier la connexion. La bibliothèque SocketIO fournit une interface AuthorizationListener, que nous pouvons implémenter pour gérer l'authentification. L'exemple de code est le suivant :

// 添加身份验证监听器
server.addAuthorizationListener(new AuthorizationListener() {
    @Override
    public boolean isAuthorized(HandshakeData handshakeData) {
        // 验证用户是否具有连接权限
        return true;
    }
});

Dans cet extrait de code, nous avons ajouté un AuthorizationListener pour gérer la demande d'authentification. La logique ici est d'authentifier toutes les connexions.

Enfin, nous devons démarrer le serveur WebSocket et attendre que la connexion soit fermée. Le code est le suivant :

// 启动服务器
server.start();

// 等待连接关闭
System.in.read();
server.stop();

Il s'agit d'une simple implémentation de serveur Java Websocket, mais elle ne peut pas gérer les connexions simultanées à grande échelle. Dans la section suivante, nous expliquerons comment utiliser la bibliothèque netty-socketio pour gérer les connexions simultanées à grande échelle.

Utilisez l'espace de noms et l'espace pour gérer les connexions simultanées

Afin de gérer un grand nombre de connexions simultanées, nous devons regrouper les connexions. Dans la bibliothèque netty-socketio, nous pouvons utiliser l'espace de noms et l'espace pour le regroupement. Un espace de noms est un canal logique qui contient un groupe de salles. Une salle est une salle qui contient un groupe d’utilisateurs.

L'utilisation spécifique est la suivante :

// 创建SocketIO服务器
SocketIOServer server = new SocketIOServer(config);

// 创建namespace
SocketIONamespace chatNamespace = server.addNamespace("/chat");

// 设置连接事件监听器
chatNamespace.addConnectListener(new ConnectListener() {
    @Override
    public void onConnect(SocketIOClient client) {
        // 加入默认房间
        client.joinRoom("default");
    }
});

// 设置事件监听器
chatNamespace.addEventListener("client_msg", String.class, new DataListener<String>() {
    @Override
    public void onData(SocketIOClient client, String data, AckRequest ackRequest) {
        String sessionId = client.getSessionId().toString();
        System.out.println("收到消息：" + data + "，sessionId=" + sessionId);
        
        // 广播消息到房间的所有用户
        chatNamespace.getRoomOperations("default").sendEvent("server_msg", sessionId + ":" + data);
    }
});

// 启动服务器
server.start();

Dans cet extrait de code, nous utilisons l'espace de noms et la salle pour gérer la connexion. Tout d’abord, nous avons créé un canal logique appelé « chat » et ajouté une salle par défaut. Ensuite, lors de la gestion des connexions clients, nous ajoutons la connexion à la salle par défaut.

À la réception d'un message du client, nous diffusons le message à tous les utilisateurs de la salle par défaut. La méthode getRoomOperations est utilisée ici pour obtenir les objets d'opération dans la pièce.

De cette façon, nous pouvons gérer des connexions simultanées à grande échelle en utilisant l'espace de noms et la salle.

Optimisation des performances

Afin de garantir les performances sous des connexions simultanées à grande échelle, nous devons effectuer une optimisation des performances. Nous répertorions ici plusieurs méthodes d'optimisation courantes.

1. Utiliser le pool de threads

Lorsque le nombre de connexions simultanées augmente, nous pouvons utiliser le pool de threads pour améliorer les performances. Dans netty-socketio, nous pouvons créer un pool de threads en :

// 创建配置对象
Configuration config = new Configuration();
...
// 创建线程池
config.setWorkerThreads(100);

2. Mise en cache des connexions à la base de données

Dans les opérations de base de données, nous pouvons mettre en cache les connexions pour éviter la création fréquente de connexions. Dans netty-socketio, nous pouvons mettre en cache la connexion à la base de données dans ConnectListener et l'utiliser dans DataListener. L'exemple de code est le suivant :

chatNamespace.addConnectListener(new ConnectListener() {
    @Override
    public void onConnect(SocketIOClient client) {
        // 加入默认房间
        client.joinRoom("default");
        // 缓存数据库连接
        client.set("conn", getDBConnection());
    }
});

chatNamespace.addEventListener("client_msg", String.class, new DataListener<String>() {
    @Override
    public void onData(SocketIOClient client, String data, AckRequest ackRequest) {
        String sessionId = client.getSessionId().toString();
        System.out.println("收到消息：" + data + "，sessionId=" + sessionId);

        // 使用缓存的数据库连接
        Connection conn = (Connection)client.get("conn");
        ...
    }
});

Ici, nous utilisons la méthode set de SocketIOClient pour mettre en cache la connexion à la base de données et l'utiliser dans DataListener.

3. Utiliser la file d'attente des messages en cache

Lorsque le nombre de messages simultanés est important, nous pouvons stocker les messages dans la file d'attente des messages en cache et attendre le traitement ultérieur. Cela peut atténuer la pression simultanée de la concurrence. L'exemple de code est le suivant :

private Queue<String> messageQueue = new ConcurrentLinkedDeque<>();

chatNamespace.addEventListener("client_msg", String.class, new DataListener<String>() {
    @Override
    public void onData(SocketIOClient client, String data, AckRequest ackRequest) {
        String sessionId = client.getSessionId().toString();
        System.out.println("收到消息：" + data + "，sessionId=" + sessionId);

        // 将消息放入缓存队列
        messageQueue.offer(sessionId + ":" + data);
    }
});

// 消息处理线程
new Thread(new Runnable() {
    @Override
    public void run() {
        while (true) {
            try {
                // 从队列取出消息并处理
                String message = messageQueue.poll();
                processMessage(message);
            
                // 睡眠1秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}).start();

Ici, nous définissons une file d'attente ConcurrentLinkedDeque pour stocker les messages. Dans DataListener, placez le message dans la file d'attente. Dans le thread de traitement, le message est extrait de la file d'attente et traité. Notez que le temps de veille du thread doit être défini ici pour éviter une utilisation excessive du processeur.

Résumé

Dans cet article, nous avons présenté comment utiliser netty-socketio pour gérer les connexions simultanées à grande échelle. L'utilisation de l'espace de noms et de l'espace pour regrouper les connexions et optimiser les performances peut nous aider à gérer un grand nombre de connexions dans des scénarios de communication synchrones.

De plus, il convient de noter que le protocole WebSocket est généralement utilisé pour mettre en œuvre des connexions longues dans des scénarios de communication en temps réel, mais il peut également présenter des risques de sécurité. Par conséquent, dans les applications pratiques, nous devons l’utiliser avec prudence et prendre en compte la sécurité.

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!