Java et WebSocket : comment implémenter la surveillance des journaux en temps réel

Avec l'avènement de l'ère Internet, la communication en temps réel est devenue un élément indispensable du développement de logiciels modernes. WebSocket est un protocole de communication full-duplex qui permet au front-end et au back-end de communiquer en temps réel, ce qui facilite grandement la mise en œuvre de la fonction importante de surveillance des journaux en temps réel. Dans cet article, je vais vous présenter comment Java et WebSocket implémentent la surveillance des journaux en temps réel et vous fournir des exemples de code pratiques pour vous aider à mieux comprendre.

Première étape : créer un environnement WebSocket

Tout d'abord, vous devez introduire les dépendances pertinentes, notamment Java WebSocket et log4j2. Nous pouvons gérer ces dépendances via Maven, comme suit :

<dependency>
    <groupId>javax.websocket</groupId>
    <artifactId>javax.websocket-api</artifactId>
    <version>1.1</version>
</dependency>

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.11.2</version>
</dependency>

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.11.2</version>
</dependency>

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-web</artifactId>
    <version>2.11.2</version>
</dependency>

Ensuite, créez le code du serveur WebSocket, comme suit :

@ServerEndpoint("/log")
public class WebSocketServer {
    private static final Logger logger = LogManager.getLogger(WebSocketServer.class.getName());

    @OnOpen
    public void onOpen(Session session) {
        logger.info("WebSocket opened: " + session.getId());
    }

    @OnClose
    public void onClose(Session session) {
        logger.info("WebSocket closed: " + session.getId());
    }

    @OnError
    public void onError(Session session, Throwable throwable) {
        logger.error("WebSocket error: " + throwable.getMessage());
    }

    @OnMessage
    public void onMessage(String message) {
        logger.info("WebSocket received message: " + message);
    }

    public void sendMessage(String message) {
        try {
            for (Session session : this.sessions) {
                if (session.isOpen()) {
                    session.getBasicRemote().sendText(message);
                }
            }
        } catch (Exception e) {
            logger.error("WebSocket send message error: " + e.getMessage());
        }
    }
}

Dans le code ci-dessus, nous utilisons l'annotation @ServerEndpoint pour définir un serveur WebSocket qui peut recevoir des connexions client demander . Une fois la connexion établie avec succès, la méthode @OnOpen sera appelée. Lorsque la connexion est fermée, la méthode @OnClose est appelée. Lorsqu'une erreur se produit, la méthode @OnError est appelée. Lorsque le serveur reçoit les informations envoyées par le client, il appelle la méthode @OnMessage pour traitement. De plus, nous avons également implémenté une méthode sendMessage pour envoyer des informations au client.

Étape 2 : Implémenter la surveillance des journaux

Ensuite, nous devons implémenter la fonction spécifique de surveillance des journaux. Ici, nous prenons log4j2 comme exemple pour surveiller le fichier journal spécifié. Tout d'abord, vous devez ajouter un Appender au fichier de configuration log4j2 pour afficher le journal dans un fichier spécifié.

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="INFO">
    <Appenders>
        <RollingFile
            name="RollingFile"
            fileName="logs/app.log"
            filePattern="${sys:logPath}/app-%d{MM-dd-yyyy}-%i.log.gz"
            ignoreExceptions="false">
            <PatternLayout>
                <pattern>%d %p %c{1.} [%t] %m%n</pattern>
            </PatternLayout>
            <Policies>
                <SizeBasedTriggeringPolicy size="64 MB" />
            </Policies>
            <DefaultRolloverStrategy max="10" />
        </RollingFile>
    </Appenders>
    <Loggers>
        <Logger name="com.your.package" level="debug" additivity="false">
            <AppenderRef ref="RollingFile" />
        </Logger>
        <Root level="info">
            <AppenderRef ref="RollingFile" />
        </Root>
    </Loggers>
</Configuration>

Dans Appender, nous définissons le nom du fichier sur logs/app.log, ce qui signifie que le journal sera sorti dans le fichier spécifié. Ensuite, nous devons écrire une classe pour implémenter l'interface FileTailer dans log4j2 et surveiller les modifications des fichiers journaux.

public class FileTailerListener implements FileTailer {
    private static final Logger logger = LogManager.getLogger(FileTailerListener.class.getName());
    private WebSocketServer webSocketServer;

    public FileTailerListener(WebSocketServer webSocketServer) {
        this.webSocketServer = webSocketServer;
    }

    @Override
    public void handle(String line) {
        logger.info(line);
        this.webSocketServer.sendMessage(line);
    }
}

Dans le code ci-dessus, nous avons implémenté l'interface FileTailer et défini la méthode handle pour surveiller le fichier journal. En même temps, nous appelons la méthode sendMessage dans WebSocketServer pour envoyer les informations du journal au client.

Étape 3 : Démarrez le serveur WebSocket et le moniteur de journaux

Après avoir terminé l'écriture du serveur WebSocket et du moniteur de journaux, nous devons les démarrer dans l'application. Nous pouvons démarrer respectivement le serveur WebSocket et FileTailerListener au démarrage, comme suit :

public class Application {
    public static void main(String[] args) {
        try {
            WebSocketServer webSocketServer = new WebSocketServer();
            FileTailerListener fileTailerListener = new FileTailerListener(webSocketServer);

            FileTailerService fileTailerService = new FileTailerService();
            fileTailerService.addListener(fileTailerListener);
            fileTailerService.start(new File("logs/app.log"));

            ServerEndpointConfig.Builder.create(WebSocketServer.class, "/log")
                .configurator(new ServerEndpointConfig.Configurator())
                .build();

            Server server = new Server(8080);
            server.setHandler(new WebSocketHandler(webSocketServer));
            server.start();
            server.join();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Dans le code ci-dessus, nous démarrons le FileTailerService pour surveiller les modifications du fichier journal et enregistrer le FileTailerListener auprès du service. Dans le même temps, un serveur Jetty est démarré pour gérer les demandes de connexion WebSocket.

Étape 4 : Écrire le code front-end

En revenant sur le code précédent, nous avons mis en place un environnement WebSocket et implémenté la surveillance et l'envoi des journaux. Enfin, nous devons écrire du code frontal pour afficher et mettre à jour les informations du journal en temps réel. Ici, nous pouvons utiliser JavaScript pour terminer le développement front-end. Le code spécifique est le suivant :

var webSocket = new WebSocket("ws://localhost:8080/log");

webSocket.onopen = function(event) {
    console.log("WebSocket opened");
};

webSocket.onmessage = function(event) {
    var message = event.data;
    var logContainer = document.getElementById("logContainer");
    var textNode = document.createTextNode(message);
    logContainer.appendChild(textNode);
    logContainer.scrollTop = logContainer.scrollHeight;
};

webSocket.onclose = function(event) {
    console.log("WebSocket closed");
};

webSocket.onerror = function(event) {
    console.error("WebSocket error: " + event);
};

Dans le code, nous utilisons l'objet WebSocket pour établir la connexion et ajouter dynamiquement le message à la page lors de la réception du message envoyé par. le serveur. Dans le même temps, nous utilisons l'attribut scrollTop pour faire défiler les informations du journal.

À ce stade, nous avons terminé le processus de mise en œuvre de la surveillance des journaux en temps réel avec Java et WebSocket. Grâce aux exemples de code ci-dessus, vous pouvez apprendre à utiliser Java et WebSocket pour implémenter la surveillance des journaux en temps réel, ainsi qu'à surveiller les fichiers journaux et à utiliser WebSocket.

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!