Comment utiliser Java pour écrire la fonction en ligne en temps réel de l'utilisateur du système CMS

Comment écrire des fonctions utilisateur en ligne en temps réel d'un système CMS à l'aide de Java

Avec le développement rapide d'Internet, les systèmes de gestion de contenu (CMS) sont devenus le cœur de nombreux sites Web et applications. Afin d'offrir une meilleure expérience utilisateur, la fonctionnalité en ligne en temps réel est un élément important. Cet article explique comment utiliser Java pour écrire la fonction en ligne en temps réel de l'utilisateur du système CMS et fournit des exemples de code.

1. Introduire les dépendances

Tout d'abord, ajoutez les dépendances suivantes dans le fichier pom.xml du projet Java :

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>
</dependencies>

Cela introduira la prise en charge WebSocket de Spring Boot.

2. Configurez WebSocket

Ajoutez la configuration suivante dans le fichier de configuration Spring Boot (tel que application.properties) :

# WebSocket配置
spring.mvc.websocket.enabled=true
spring.messages.suffix=message

Cela activera la fonction WebSocket et configurera le suffixe du message sur "message".

3. Créez un processeur WebSocket

Créez un processeur WebSocket pour gérer les connexions WebSocket et les messages du client. Ceci peut être réalisé en écrivant une classe qui implémente l'interface WebSocketHandler.

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.springframework.stereotype.Component;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.WebSocketMessage;
import org.springframework.web.socket.WebSocketSession;

@Component
public class CMSWebSocketHandler implements WebSocketHandler {

    private static final Map<String, WebSocketSession> SESSIONS = new HashMap<>();

    // 连接建立时触发
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        SESSIONS.put(session.getId(), session);
    }

    // 收到消息时触发（此处假设消息为用户ID）
    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
        String userId = message.getPayload().toString();
        // 处理用户上线逻辑
        // ...
    }

    // 连接关闭时触发
    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        SESSIONS.remove(session.getId());
    }

    // 发生错误时触发
    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        // 处理错误逻辑
        // ...
    }
}

Dans le code ci-dessus, nous utilisons une carte statique pour stocker toutes les sessions WebSocket connectées. Lorsque la connexion est établie, la session est ajoutée à la Map ; lorsque la connexion est fermée, elle est supprimée de la Map. En remplaçant la méthode handleMessage, les messages reçus du client peuvent être traités.

4. Configurez le processeur WebSocket

Dans la classe de configuration Spring Boot, configurez le processeur WebSocket :

import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    private final CMSWebSocketHandler cmsWebSocketHandler;

    public WebSocketConfig(CMSWebSocketHandler cmsWebSocketHandler) {
        this.cmsWebSocketHandler = cmsWebSocketHandler;
    }

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(cmsWebSocketHandler, "/ws").setAllowedOrigins("*");
    }
}

Dans le code ci-dessus, nous enregistrons le processeur WebSocket en tant que gestionnaire WebSocket et le mappons au chemin "/ws". Autorisez les connexions WebSocket depuis n'importe quelle origine en définissant setAllowedOrigins("*").

5. Intégration front-end

Dans la page front-end, utilisez JavaScript ou d'autres technologies connexes pour établir une connexion avec le back-end via WebSocket et transmettre l'ID utilisateur.

const socket = new WebSocket("ws://localhost:8080/ws");
const userId = "12345";
socket.onopen = () => {
    socket.send(userId);
};

socket.onclose = () => {
    // 连接关闭逻辑
};

Comme le montre le code ci-dessus, lorsque la connexion WebSocket est établie, l'ID utilisateur est envoyé via socket.send(userId).

6. Implémentation de la fonction en ligne en temps réel

Dans le système CMS, la fonction en ligne en temps réel peut être réalisée via les méthodes afterConnectionEstablished et afterConnectionClosed dans le processeur WebSocket.

// 连接建立时触发
@Override
public void afterConnectionEstablished(WebSocketSession session) throws Exception {
    SESSIONS.put(session.getId(), session);
    // 用户上线逻辑
    String userId = getUserIdFromSession(session);
    // 处理用户上线逻辑
}

// 连接关闭时触发
@Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
    SESSIONS.remove(session.getId());
    // 用户下线逻辑
    String userId = getUserIdFromSession(session);
    // 处理用户下线逻辑
}

// 辅助方法：从会话中获取用户ID
private String getUserIdFromSession(WebSocketSession session) {
    Map<String, Object> attributes = session.getAttributes();
    // 从attributes中获取用户ID
    // ...
}

Lorsque la connexion utilisateur est établie, placez la session dans la carte SESSIONS, obtenez l'ID utilisateur de la session et effectuez le traitement logique en ligne de l'utilisateur correspondant. Lorsque la connexion utilisateur est fermée, la session est supprimée de la carte SESSIONS et la logique hors ligne de l'utilisateur correspondante est traitée.

7. Résumé

Cet article présente comment utiliser Java pour écrire la fonction utilisateur en ligne en temps réel du système CMS. En introduisant des dépendances, en configurant WebSocket, en créant des processeurs WebSocket et en intégrant l'avant-plan, nous pouvons réaliser la fonction en ligne en temps réel de l'utilisateur et effectuer le traitement correspondant. Dans les applications réelles, d'autres extensions fonctionnelles et optimisations peuvent être réalisées en fonction des besoins réels.

Ce qui précède est une introduction sur la façon d'utiliser Java pour écrire la fonction utilisateur en ligne en temps réel du système CMS. J'espère que cela 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!