Comment implémenter une interface graphique pour la communication en temps réel à l'aide de JavaFX et WebSocket dans Java 9

Comment utiliser JavaFX et WebSocket pour implémenter une interface graphique pour la communication en temps réel dans Java 9

Introduction :
Avec le développement d'Internet, le besoin de communication en temps réel devient de plus en plus courant. Dans Java 9, nous pouvons utiliser les technologies JavaFX et WebSocket pour implémenter des applications de communication en temps réel avec des interfaces graphiques. Cet article expliquera comment utiliser la technologie JavaFX et WebSocket pour implémenter une interface graphique pour la communication en temps réel dans Java 9, et joindra des exemples de code correspondants.

Première partie : les bases de JavaFX
Avant de commencer à présenter comment utiliser WebSocket pour établir une communication en temps réel, comprenons d'abord les bases de JavaFX. JavaFX est un framework lancé par Oracle pour développer des interfaces graphiques. Il utilise un langage de description basé sur XML FXML pour définir la disposition de l'interface.

Exemple de code 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);
    }
}

Dans le code ci-dessus, nous avons créé une simple fenêtre d'application JavaFX et ajouté un bouton à la fenêtre. Lorsque vous cliquez sur le bouton, "Bonjour JavaFX" sera affiché sur la console.

Partie 2 : Bases de WebSocket
WebSocket est un protocole utilisé pour établir une communication en temps réel, qui fournit une fonctionnalité de communication bidirectionnelle. En Java, nous pouvons utiliser la classe WebSocket dans l'API Java pour implémenter la communication WebSocket.

Exemple de code 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);
    }
}

Dans le code ci-dessus, nous créons un WebSocket et nous connectons au serveur spécifié. Grâce à la méthode de rappel de WebSocket, nous pouvons gérer l'interaction avec le serveur, y compris la réception et l'envoi de messages, et la gestion de l'état de la connexion.

Partie 3 : Utiliser JavaFX et WebSocket pour implémenter une interface graphique pour une communication en temps réel
Maintenant que nous avons compris les bases de JavaFX et WebSocket, nous allons combiner ces deux technologies pour implémenter une application de communication en temps réel avec une interface graphique .

Exemple de code 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);
    }
}

Dans le code ci-dessus, nous créons une fenêtre d'application JavaFX qui contient une zone de texte et une zone de saisie de texte. Lorsque l'utilisateur saisit du texte dans la zone de saisie et appuie sur la touche Entrée, le programme envoie le texte au serveur. Après avoir reçu le message du serveur, le programme ajoutera le message à la zone de texte pour l'afficher.

Conclusion :
Cet article explique comment utiliser la technologie JavaFX et WebSocket dans Java 9 pour implémenter une interface graphique pour la communication en temps réel. En maîtrisant les connaissances de base de JavaFX et WebSocket, combinées à des exemples de code réels, nous pouvons facilement implémenter des applications d'interface graphique avec des capacités de communication en temps réel dans Java 9. J'espère que cet article 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!