So verwenden Sie JavaFX und WebSockets in Java 9, um eine grafische Schnittstelle für die Echtzeitkommunikation zu implementieren

So verwenden Sie JavaFX und WebSockets in Java 9, um eine grafische Schnittstelle für Echtzeitkommunikation zu implementieren

Einführung:
Im heutigen Internetzeitalter ist Echtzeitkommunikation eine der sehr wichtigen Funktionen. Zum Beispiel Echtzeit-Updates der Börsenbedingungen, Echtzeit-Chat usw. In diesem Artikel wird erläutert, wie Sie JavaFX und WebSockets in Java 9 verwenden, um eine grafische Schnittstelle für die Echtzeitkommunikation zu implementieren.

Teil Eins: Einführung in JavaFX
JavaFX ist eine Java-Bibliothek zum Erstellen von Rich-Client-Anwendungen. Es bietet eine leistungsstarke grafische Oberfläche zum einfachen Erstellen verschiedener visueller Effekte.

Teil 2: Einführung in WebSockets
WebSockets ist eine Technologie, die für die bidirektionale Echtzeitkommunikation zwischen Clients und Servern verwendet wird. Es ermöglicht Servern, proaktiv Nachrichten an Clients zu senden und bietet ein einfaches Protokoll für die Abwicklung der Echtzeitkommunikation.

Teil 3: Kombination von JavaFX und WebSockets
Lassen Sie uns nun einen Blick darauf werfen, wie man JavaFX und WebSockets kombiniert, um eine grafische Oberfläche für die Echtzeitkommunikation zu erhalten. Zuerst müssen wir eine JavaFX-Anwendung erstellen und die WebSockets-Bibliothek zu den Abhängigkeiten des Projekts hinzufügen.

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

Im obigen Code haben wir eine JavaFX-Anwendung namens „RealTimeApplication“ erstellt und eine TextArea zum Anzeigen von Nachrichten und ein TextField zum Eingeben von Nachrichten hinzugefügt. Wenn der Benutzer die Eingabetaste im TextField drückt, verwenden wir die WebSockets-Sitzung, um eine Nachricht an den Server zu senden. Wenn eine Nachricht vom Server empfangen wird, zeigen wir sie im TextArea an.

Teil 4: Serverseitige Einrichtung
Als Nächstes müssen wir die Serverseite so einrichten, dass sie Nachrichten von Clients verarbeitet und an alle verbundenen Clients sendet. Hier verwenden wir Spring Boot, um einen einfachen WebSockets-Server zu erstellen.

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

Im obigen Code erstellen wir einen WebSocket-Server mit dem Namen „WebSocketServer“ und binden ihn mithilfe der Annotation @ServerEndpoint an den Endpunkt „/ws“. Wenn eine Nachricht von einem Client empfangen wird, sendet der Server sie an alle verbundenen Clients.

Fazit:
Durch die Kombination von JavaFX und WebSockets können wir ganz einfach eine grafische Oberfläche für die Echtzeitkommunikation implementieren. Egal, ob Sie Börsenaktualisierungen in Echtzeit oder einen Live-Chat suchen, diese Technologie kann äußerst nützlich sein. Ich hoffe, dieser Artikel hat Ihnen bei der Implementierung einer grafischen Schnittstelle für die Echtzeitkommunikation mithilfe von JavaFX und WebSockets in Java 9 geholfen.

Referenzlink:

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

Das obige ist der detaillierte Inhalt vonSo verwenden Sie JavaFX und WebSockets in Java 9, um eine grafische Schnittstelle für die Echtzeitkommunikation zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!