Java und WebSocket: So implementieren Sie die Protokollüberwachung in Echtzeit

Mit dem Aufkommen des Internetzeitalters ist Echtzeitkommunikation zu einem unverzichtbaren Bestandteil der modernen Softwareentwicklung geworden. WebSocket ist ein Vollduplex-Kommunikationsprotokoll, das die Kommunikation zwischen Front-End und Back-End in Echtzeit ermöglicht, was die Implementierung der wichtigen Funktion der Echtzeit-Protokollüberwachung erheblich erleichtert. In diesem Artikel werde ich Ihnen vorstellen, wie Java und WebSocket die Protokollüberwachung in Echtzeit implementieren, und praktische Codebeispiele bereitstellen, um Ihnen das Verständnis zu erleichtern.

Schritt eins: Erstellen Sie eine WebSocket-Umgebung

Zuerst müssen Sie relevante Abhängigkeiten einführen, einschließlich Java WebSocket und log4j2. Wir können diese Abhängigkeiten über Maven wie folgt verwalten:

<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>

Als nächstes erstellen Sie den WebSocket-Servercode wie folgt:

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

Im obigen Code verwenden wir die Annotation @ServerEndpoint, um einen WebSocket-Server zu definieren, der Client-Verbindungsanfragen empfangen kann . Nachdem die Verbindung erfolgreich hergestellt wurde, wird die @OnOpen-Methode aufgerufen. Beim Schließen der Verbindung wird die Methode @OnClose aufgerufen. Wenn ein Fehler auftritt, wird die Methode @OnError aufgerufen. Wenn der Server die vom Client gesendeten Informationen empfängt, ruft er die @OnMessage-Methode zur Verarbeitung auf. Darüber hinaus haben wir auch eine sendMessage-Methode zum Senden von Informationen an den Client implementiert.

Schritt 2: Protokollüberwachung implementieren

Als nächstes müssen wir die spezifische Protokollüberwachungsfunktion implementieren. Hier nehmen wir log4j2 als Beispiel, um die angegebene Protokolldatei zu überwachen. Zunächst müssen Sie der log4j2-Konfigurationsdatei einen Appender hinzufügen, um das Protokoll in eine angegebene Datei auszugeben.

<?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>

In Appender setzen wir den Dateinamen auf logs/app.log, was bedeutet, dass das Protokoll in die angegebene Datei ausgegeben wird. Als nächstes müssen wir eine Klasse schreiben, um die FileTailer-Schnittstelle in log4j2 zu implementieren und Protokolldateiänderungen zu überwachen.

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

Im obigen Code haben wir die FileTailer-Schnittstelle implementiert und die Handle-Methode zur Überwachung der Protokolldatei definiert. Gleichzeitig rufen wir die sendMessage-Methode in WebSocketServer auf, um die Protokollinformationen an den Client zu senden.

Schritt 3: WebSocket-Server und Protokollmonitor starten

Nachdem wir das Schreiben von WebSocket-Server und Protokollmonitor abgeschlossen haben, müssen wir sie in der Anwendung starten. Wir können den WebSocket-Server bzw. FileTailerListener beim Start wie folgt starten:

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

Im obigen Code haben wir den FileTailerService gestartet, um Protokolldateiänderungen zu überwachen, und den FileTailerListener beim Dienst registriert. Gleichzeitig wird ein Jetty-Server gestartet, der WebSocket-Verbindungsanfragen verarbeitet.

Schritt 4: Front-End-Code schreiben

Wenn wir auf den vorherigen Code zurückblicken, haben wir eine WebSocket-Umgebung eingerichtet und die Protokollüberwachung und das Senden implementiert. Schließlich müssen wir Front-End-Code schreiben, um Protokollinformationen in Echtzeit anzuzeigen und zu aktualisieren. Hier können wir JavaScript verwenden, um die Front-End-Entwicklung abzuschließen. Der spezifische Code lautet wie folgt:

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

Im Code verwenden wir das WebSocket-Objekt, um die Verbindung herzustellen und die Nachricht dynamisch zur Seite hinzuzufügen, wenn wir die von gesendete Nachricht empfangen der Kellner. Gleichzeitig verwenden wir das scrollTop-Attribut, um die Protokollinformationen weiter zu scrollen.

Zu diesem Zeitpunkt haben wir den Prozess der Implementierung der Echtzeit-Protokollüberwachung mit Java und WebSocket abgeschlossen. Anhand der obigen Codebeispiele können Sie lernen, wie Sie mit Java und WebSocket eine Echtzeit-Protokollüberwachung implementieren und wie Sie Protokolldateien überwachen und WebSocket verwenden.

Das obige ist der detaillierte Inhalt vonJava und WebSocket: So implementieren Sie die Protokollüberwachung in Echtzeit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!