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

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

Introduction :
À l'ère Internet d'aujourd'hui, la communication en temps réel est l'une des fonctions très importantes. Par exemple, des mises à jour en temps réel des conditions boursières, un chat en temps réel, etc. Cet article explique comment utiliser JavaFX et WebSockets dans Java 9 pour implémenter une interface graphique pour la communication en temps réel.

Première partie : Introduction à JavaFX
JavaFX est une bibliothèque Java permettant de créer des applications client riches. Il fournit une interface graphique puissante pour créer facilement divers effets visuels.

Partie 2 : Introduction aux WebSockets
WebSockets est une technologie utilisée pour la communication bidirectionnelle en temps réel entre les clients et les serveurs. Il permet aux serveurs d'envoyer des messages aux clients de manière proactive et fournit un protocole simple pour gérer la communication en temps réel.

Partie 3 : Combinaison de JavaFX et WebSockets
Voyons maintenant comment combiner JavaFX et WebSockets pour obtenir une interface graphique pour une communication en temps réel. Tout d'abord, nous devons créer une application JavaFX et ajouter la bibliothèque WebSockets aux dépendances du projet.

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import javax.websocket.ClientEndpoint;
import javax.websocket.ContainerProvider;
import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.WebSocketContainer;

@ClientEndpoint
public class RealTimeApplication extends Application {

    private Session session;
    private TextArea messageArea;

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

    @Override
    public void start(Stage primaryStage) {
        primaryStage.setTitle("Real Time Application");

        VBox vbox = new VBox();

        messageArea = new TextArea();
        messageArea.setEditable(false);

        TextField inputField = new TextField();
        inputField.setOnAction(event -> {
            String message = inputField.getText();
            session.getAsyncRemote().sendText(message);
            inputField.setText("");
        });

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

        primaryStage.setScene(new Scene(vbox, 400, 300));
        primaryStage.show();

        connect();
    }

    @Override
    public void stop() {
        try {
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @OnMessage
    public void onMessage(String message) {
        messageArea.appendText(message + "
");
    }

    private void connect() {
        try {
            WebSocketContainer container = ContainerProvider.getWebSocketContainer();
            session = container.connectToServer(this, new URI("ws://localhost:8080/ws"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Dans le code ci-dessus, nous avons créé une application JavaFX appelée "RealTimeApplication" et ajouté une TextArea pour afficher les messages et un TextField pour saisir des messages. Lorsque l'utilisateur appuie sur la touche Entrée dans TextField, nous utilisons la session WebSockets pour envoyer un message au serveur. Lorsqu'un message est reçu du serveur, nous l'afficherons dans une TextArea.

Partie 4 : Configuration côté serveur
Ensuite, nous devons configurer le côté serveur pour gérer les messages des clients et les diffuser à tous les clients connectés. Ici, nous utilisons Spring Boot pour créer un simple serveur WebSockets.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketTransportRegistration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Configuration
    @EnableWebSocketMessageBroker
    public static class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

        @Override
        public void configureWebSocketTransport(WebSocketTransportRegistration registration) {
            registration.setMessageSizeLimit(1024000);
        }

        @Override
        public void registerStompEndpoints(StompEndpointRegistry registry) {
            registry.addEndpoint("/ws").withSockJS();
        }
    }

    @ServerEndpoint(value = "/ws")
    public static class WebSocketServer {

        @OnMessage
        public void onMessage(Session session, String message) throws IOException, EncodeException {
            for (Session client : session.getOpenSessions()) {
                client.getBasicRemote().sendText(message);
            }
        }
    }
}

Dans le code ci-dessus, nous créons un serveur WebSocket nommé "WebSocketServer" et le lions au point de terminaison "/ws" à l'aide de l'annotation @ServerEndpoint. Lorsqu'un message est reçu d'un client, le serveur le diffuse à tous les clients connectés.

Conclusion :
En combinant JavaFX et WebSockets, nous pouvons facilement implémenter une interface graphique pour une communication en temps réel. Que vous recherchiez des mises à jour boursières en temps réel ou un chat en direct, cette technologie peut être extrêmement utile. J'espère que cet article vous a été utile pour implémenter une interface graphique pour la communication en temps réel à l'aide de JavaFX et WebSockets dans Java 9.

Lien de référence :

• Documentation officielle JavaFX : https://openjfx.io/javadoc/12/
• Documentation officielle WebSocket : https://www.w3.org/TR/websockets/
• Documentation officielle Spring Boot ：https://spring.io/projects/spring-boot

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!