Erstellen Sie Desktop-Anwendungen mit Spring Boot und JavaFX

Durch die kontinuierliche Weiterentwicklung der Technologie können wir jetzt verschiedene Technologien zum Erstellen von Desktop-Anwendungen verwenden. Spring Boot und JavaFX gehören mittlerweile zu den beliebtesten Optionen. Dieser Artikel konzentriert sich auf die Verwendung dieser beiden Frameworks zum Erstellen einer funktionsreichen Desktop-Anwendung.

1. Einführung in Spring Boot und JavaFX

Spring Boot ist ein schnelles Entwicklungsframework, das auf dem Spring-Framework basiert. Es hilft Entwicklern, schnell Webanwendungen zu erstellen und bietet gleichzeitig eine Reihe sofort einsatzbereiter Funktionskomponenten wie Sicherheit, Datenbankzugriff usw. Spring Boot kann auch zum Erstellen von Desktop-Anwendungen verwendet werden, was Entwicklern mehr Auswahlmöglichkeiten bietet.

JavaFX ist eine Open-Source-Java-Bibliothek zum Erstellen von Rich-Client-Anwendungen. Es bietet viele Funktionen zum Erstellen von GUI-Anwendungen wie Layout-Managern, Grafikzeichnungen usw. JavaFX bietet außerdem einige zusätzliche Funktionen, wie z. B. Unterstützung für Multimedia, Animation usw.

Die Verwendung dieser beiden Frameworks kann uns dabei helfen, eine Desktop-Anwendung einfacher zu erstellen und die Codequalität zu verbessern. Als Nächstes stellen wir vor, wie Sie mit Spring Boot und JavaFX eine Desktop-Anwendung erstellen.

2. Erstellen Sie eine Desktop-Anwendung.

1. Erstellen Sie ein Spring Boot-Projekt.

Zuerst müssen wir ein Spring Boot-Projekt erstellen. Sie können eine beliebige IDE verwenden oder direkt die Befehlszeile verwenden. Nach der Erstellung müssen wir die Abhängigkeiten von JavaFX hinzufügen. Hier verwenden wir Maven, um Projektabhängigkeiten zu verwalten. Fügen Sie die folgenden Abhängigkeiten in Ihre pom.xml-Datei ein:

<dependency>
    <groupId>org.openjfx</groupId>
    <artifactId>javafx-controls</artifactId>
    <version>16</version>
</dependency>
<dependency>
    <groupId>org.openjfx</groupId>
    <artifactId>javafx-fxml</artifactId>
    <version>16</version>
</dependency>

Diese Abhängigkeiten stellen die von JavaFX benötigten Bibliotheken und Ressourcen bereit. Nachdem wir diese Abhängigkeiten hinzugefügt haben, müssen wir eine Startup-Klasse erstellen, um unsere Desktop-Anwendung zu starten.

2. Erstellen einer JavaFX-Anwendung

Jetzt können wir mit dem Erstellen einer JavaFX-Anwendung beginnen. Es gibt zwei Möglichkeiten, JavaFX-Anwendungen zu erstellen: mit FXML oder mit Java-Code. FXML ist ein XML-Format, das zur Beschreibung der JavaFX-Benutzeroberfläche verwendet wird. FXML-Dateien beschreiben die Struktur, das Layout und den Inhalt eines Fensters. Es ermöglicht uns, das Design der Benutzeroberfläche und die Geschäftslogik zu trennen.

Das Beispiel, das wir hier haben, verwendet FXML-Dateien, um die Benutzeroberfläche zu erstellen. Wir müssen eine FXML-Datei erstellen, um eine einfache Benutzeroberfläche zu erstellen:

<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.layout.HBox?>
<?import javafx.scene.layout.VBox?>

<VBox xmlns="http://javafx.com/javafx"
      xmlns:fx="http://javafx.com/fxml"
      fx:controller="com.example.MyController">
    <HBox>
        <Label text="Hello, World!"/>
    </HBox>
    <HBox>
        <Button text="Say Hello" onAction="#handleButtonAction"/>
    </HBox>
</VBox>

Die FXML-Datei beschreibt eine VBox, die zwei HBoxes enthält. Jede HBox enthält eine Beschriftung und eine Schaltfläche. Wir werden hier einen FXML-Controller verwenden, um Schaltflächenklickereignisse zu verarbeiten. Das bedeutet, dass wir eine Java-Klasse erstellen müssen, um die Ereignisse in der FXML-Datei zu verarbeiten.

3. FXML-Controller hinzufügen

Wir müssen eine Java-Klasse erstellen, um Ereignisse in der FXML-Datei zu verarbeiten. Hier verwenden wir die @FXML-Annotation, um Methoden in der Java-Klasse an Ereignisse in der FXML-Datei zu binden. Hier müssen wir eine MyController-Klasse erstellen:

package com.example;

import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.scene.control.Label;

public class MyController {

    @FXML
    private Label label;

    @FXML
    protected void handleButtonAction(ActionEvent event) {
        label.setText("Hello, World!");
    }
}

Unsere Controller-Klasse enthält ein Label und eine Methode. Die Methode wird aufgerufen, wenn auf die Schaltfläche geklickt wird. Die Methode aktualisiert den Text des Etiketts, um „Hello, World!“ anzuzeigen.

4. Starten der Anwendung

Wir haben die Erstellung der JavaFX-Anwendung abgeschlossen. Jetzt müssen wir eine Startup-Klasse schreiben, um unsere Anwendung zu starten. Hier verwenden wir die @SpringBootApplication-Annotation von Spring Boot. Die Annotation @SpringBootApplication scannt alle Komponenten in der Anwendung und legt automatisch den Spring-Anwendungskontext fest.

package com.example;

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;

import java.io.IOException;

@SpringBootApplication
public class DemoApplication extends Application {

    private ConfigurableApplicationContext springContext;
    private Parent rootNode;

    @Override
    public void init() throws IOException {
        SpringApplicationBuilder builder = new SpringApplicationBuilder(DemoApplication.class);
        springContext = builder.run(getParameters().getRaw().toArray(new String[0]));

        FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/main.fxml"));
        loader.setControllerFactory(springContext::getBean);
        rootNode = loader.load();
    }

    @Override
    public void start(Stage primaryStage) {
        Scene scene = new Scene(rootNode, 640, 480);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    @Override
    public void stop() {
        springContext.stop();
    }

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

Unsere DemoApplication erbt die Application-Klasse von JavaFX. Beim Starten der Anwendung scannt die SpringApplicationBuilder-Klasse von Spring Boot unsere Anwendung und erstellt einen Spring-Kontext. Die FXMLLoader-Klasse lädt die FXML-Datei und legt sie als Stammknoten des Szenendiagramms fest. Wir fügen das Szenendiagramm in die neue Bühne ein und zeigen es an. Wenn die Anwendung schließlich beendet wird, müssen wir den Spring-Kontext schließen.

3. Vervollständigen Sie die Anwendung

Wir haben erfolgreich eine Desktop-Anwendung mit Spring Boot und JavaFX erstellt. Mit JavaFX können wir sehr schöne und leistungsstarke Benutzeroberflächen erstellen, mit Spring Boot die Geschäftslogik verwalten und mit Spring Boot unsere Anwendungen automatisch konfigurieren. Dieser Artikel stellt nur ein einfaches Beispiel vor. Wenn Sie komplexere Anwendungen ausprobieren möchten, empfehle ich Ihnen, sich Spring Boot und JavaFX genauer anzusehen.

Das obige ist der detaillierte Inhalt vonErstellen Sie Desktop-Anwendungen mit Spring Boot und JavaFX. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!