So implementieren Sie eine grafische Schnittstelle für Echtzeitkommunikation mithilfe von JavaFX und WebSocket in Java 9

So implementieren Sie mit JavaFX und WebSocket eine grafische Schnittstelle für Echtzeitkommunikation in Java 9

Einführung:
Mit der Entwicklung des Internets wird der Bedarf an Echtzeitkommunikation immer häufiger. In Java 9 können wir JavaFX- und WebSocket-Technologien verwenden, um Echtzeit-Kommunikationsanwendungen mit grafischen Schnittstellen zu implementieren. In diesem Artikel wird erläutert, wie mithilfe der JavaFX- und WebSocket-Technologie eine grafische Schnittstelle für die Echtzeitkommunikation in Java 9 implementiert wird, und es werden entsprechende Codebeispiele beigefügt.

Teil Eins: JavaFX-Grundlagen
Bevor wir mit der Einführung in die Verwendung von WebSocket zur Erzielung einer Echtzeitkommunikation beginnen, wollen wir zunächst die Grundlagen von JavaFX verstehen. JavaFX ist ein von Oracle eingeführtes Framework zur Entwicklung grafischer Schnittstellen. Es verwendet eine XML-basierte Beschreibungssprache FXML, um das Schnittstellenlayout zu definieren.

Codebeispiel 1:

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.stage.Stage;

public class JavaFXExample extends Application {

    @Override
    public void start(Stage primaryStage) {
        Button btn = new Button("点击我");
        btn.setOnAction(e -> {
            System.out.println("Hello JavaFX");
        });

        Scene scene = new Scene(btn, 300, 200);

        primaryStage.setTitle("JavaFX示例");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

Im obigen Code haben wir ein einfaches JavaFX-Anwendungsfenster erstellt und dem Fenster eine Schaltfläche hinzugefügt. Wenn Sie auf die Schaltfläche klicken, wird „Hallo JavaFX“ an die Konsole ausgegeben.

Teil 2: WebSocket-Grundlagen
WebSocket ist ein Protokoll zur Erzielung einer Echtzeitkommunikation, das bidirektionale Kommunikationsfunktionen bietet. In Java können wir die WebSocket-Klasse in der Java-API verwenden, um die WebSocket-Kommunikation zu implementieren.

Codebeispiel 2:

import java.net.URI;
import java.net.http.WebSocket;
import java.nio.ByteBuffer;
import java.util.concurrent.CompletableFuture;

public class WebSocketExample {

    public static void main(String[] args) {
        String serverURL = "ws://example.com/websocket";

        CompletableFuture<WebSocket> ws = WebSocket.newWebSocketBuilder()
                .buildAsync(URI.create(serverURL), new WebSocket.Listener() {
                    @Override
                    public void onOpen(WebSocket webSocket) {
                        System.out.println("连接已建立");
                    }

                    @Override
                    public CompletionStage<?> onText(WebSocket webSocket, CharSequence data, boolean last) {
                        System.out.println("接收到消息：" + data.toString());
                        return WebSocket.Listener.super.onText(webSocket, data, last);
                    }

                    @Override
                    public CompletionStage<?> onBinary(WebSocket webSocket, ByteBuffer data, boolean last) {
                        System.out.println("接收到二进制数据");
                        return WebSocket.Listener.super.onBinary(webSocket, data, last);
                    }

                    @Override
                    public CompletionStage<?> onClose(WebSocket webSocket, int statusCode, String reason) {
                        System.out.println("连接已关闭，状态码：" + statusCode);
                        return WebSocket.Listener.super.onClose(webSocket, statusCode, reason);
                    }

                    @Override
                    public void onError(WebSocket webSocket, Throwable error) {
                        System.out.println("发生错误：" + error.getMessage());
                    }
                });

        // 向服务器发送消息
        ws.thenAccept(webSocket -> {
            webSocket.sendText("Hello Server", true);
        });

        // 断开连接
        ws.thenAccept(WebSocket::abort);
    }
}

Im obigen Code erstellen wir einen WebSocket, um eine Verbindung zum angegebenen Server herzustellen. Über die Rückrufmethoden von WebSocket können wir Interaktionen mit dem Server abwickeln, einschließlich des Empfangens und Sendens von Nachrichten sowie der Verarbeitung des Verbindungsstatus.

Teil 3: Verwendung von JavaFX und WebSocket zur Implementierung einer grafischen Schnittstelle für Echtzeitkommunikation
Da wir nun die Grundlagen von JavaFX und WebSocket verstanden haben, werden wir diese beiden Technologien kombinieren, um eine Echtzeitkommunikationsanwendung mit einer grafischen Schnittstelle zu implementieren .

Codebeispiel 3:

import javafx.application.Application;
import javafx.application.Platform;
import javafx.scene.Scene;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

import java.net.URI;
import java.net.http.WebSocket;
import java.nio.ByteBuffer;
import java.util.concurrent.CompletableFuture;

public class RealTimeCommunicationApp extends Application {
    private WebSocket webSocket;
    private TextArea messageArea;

    @Override
    public void start(Stage primaryStage) {
        VBox root = new VBox();
        messageArea = new TextArea();
        TextField inputField = new TextField();

        inputField.setOnAction(e -> {
            String message = inputField.getText();
            webSocket.sendText(message, true);
            inputField.clear();
        });

        root.getChildren().addAll(messageArea, inputField);

        Scene scene = new Scene(root, 400, 300);
        primaryStage.setTitle("实时通信应用");
        primaryStage.setScene(scene);
        primaryStage.show();

        connectToServer();
    }

    private void connectToServer() {
        String serverURL = "ws://example.com/websocket";

        CompletableFuture<WebSocket> ws = WebSocket.newWebSocketBuilder()
                .buildAsync(URI.create(serverURL), new WebSocket.Listener() {
                    @Override
                    public void onOpen(WebSocket webSocket) {
                        Platform.runLater(() -> {
                            messageArea.appendText("连接已建立
");
                        });
                    }

                    @Override
                    public CompletionStage<?> onText(WebSocket webSocket, CharSequence data, boolean last) {
                        Platform.runLater(() -> {
                            messageArea.appendText("接收到消息：" + data.toString() + "
");
                        });
                        return WebSocket.Listener.super.onText(webSocket, data, last);
                    }

                    @Override
                    public CompletionStage<?> onBinary(WebSocket webSocket, ByteBuffer data, boolean last) {
                        Platform.runLater(() -> {
                            messageArea.appendText("接收到二进制数据
");
                        });
                        return WebSocket.Listener.super.onBinary(webSocket, data, last);
                    }

                    @Override
                    public CompletionStage<?> onClose(WebSocket webSocket, int statusCode, String reason) {
                        Platform.runLater(() -> {
                            messageArea.appendText("连接已关闭，状态码：" + statusCode + "
");
                        });
                        return WebSocket.Listener.super.onClose(webSocket, statusCode, reason);
                    }

                    @Override
                    public void onError(WebSocket webSocket, Throwable error) {
                        Platform.runLater(() -> {
                            messageArea.appendText("发生错误：" + error.getMessage() + "
");
                        });
                    }
                });

        ws.thenAccept(webSocket -> {
            this.webSocket = webSocket;
        });
    }

    public static void main(String[] args) {
        launch(args);
    }
}

Im obigen Code erstellen wir ein JavaFX-Anwendungsfenster, das einen Textbereich und ein Texteingabefeld enthält. Wenn der Benutzer Text in das Eingabefeld eingibt und die Eingabetaste drückt, sendet das Programm den Text an den Server. Nach dem Empfang der Nachricht vom Server hängt das Programm die Nachricht zur Anzeige an den Textbereich an.

Fazit:
In diesem Artikel wird erläutert, wie Sie mithilfe der JavaFX- und WebSocket-Technologie in Java 9 eine grafische Schnittstelle für die Echtzeitkommunikation implementieren. Durch die Beherrschung der Grundkenntnisse von JavaFX und WebSocket in Kombination mit tatsächlichen Codebeispielen können wir problemlos grafische Schnittstellenanwendungen mit Echtzeitkommunikationsfunktionen in Java 9 implementieren. Ich hoffe, dieser Artikel ist hilfreich für Sie!

Das obige ist der detaillierte Inhalt vonSo implementieren Sie eine grafische Schnittstelle für Echtzeitkommunikation mithilfe von JavaFX und WebSocket in Java 9. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!