Bina aplikasi desktop menggunakan Spring Boot dan JavaFX

Memandangkan teknologi terus berkembang, kami kini boleh menggunakan teknologi yang berbeza untuk membina aplikasi desktop. Spring Boot dan JavaFX adalah salah satu pilihan yang lebih popular sekarang. Artikel ini akan menumpukan pada cara menggunakan kedua-dua rangka kerja ini untuk membina aplikasi desktop yang kaya dengan ciri.

1. Pengenalan kepada Spring Boot dan JavaFX

Spring Boot ialah rangka kerja pembangunan pesat berdasarkan rangka kerja Spring. Ia membantu pembangun membina aplikasi web dengan cepat sambil menyediakan satu set komponen berfungsi yang luar biasa seperti keselamatan, akses pangkalan data, dsb. Spring Boot juga boleh digunakan untuk membina aplikasi desktop, memberikan pembangun dengan lebih banyak pilihan.

JavaFX ialah perpustakaan Java sumber terbuka untuk membina aplikasi klien yang kaya. Ia menyediakan banyak ciri untuk membina aplikasi GUI seperti pengurus susun atur, lukisan grafik, dll. JavaFX juga menyediakan beberapa ciri tambahan, seperti sokongan untuk multimedia, animasi, dsb.

Menggunakan kedua-dua rangka kerja ini boleh membantu kami membina aplikasi desktop dengan lebih mudah dan kualiti kod akan lebih tinggi. Seterusnya kami akan memperkenalkan cara menggunakan Spring Boot dan JavaFX untuk membina aplikasi desktop.

2. Bina aplikasi desktop

1. Buat projek Spring Boot

Pertama, kita perlu mencipta projek Spring Boot. Anda boleh menggunakan mana-mana IDE atau terus menggunakan baris arahan. Selepas penciptaan, kita perlu menambah kebergantungan JavaFX. Di sini kami menggunakan Maven untuk menguruskan kebergantungan projek. Tambahkan kebergantungan berikut dalam fail pom.xml:

<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>

Kebergantungan ini akan menyediakan perpustakaan dan sumber yang diperlukan oleh JavaFX. Selepas menambah kebergantungan ini, kami perlu mencipta kelas permulaan untuk melancarkan aplikasi desktop kami.

2. Mencipta aplikasi JavaFX

Sekarang kita boleh mula membina aplikasi JavaFX. Terdapat dua cara untuk membuat aplikasi JavaFX: menggunakan FXML atau menggunakan kod Java. FXML ialah format XML yang digunakan untuk menerangkan antara muka pengguna JavaFX. Fail FXML menerangkan struktur, reka letak dan kandungan tetingkap. Ia membolehkan kami memisahkan reka bentuk antara muka pengguna dan logik perniagaan.

Contoh yang kami ada di sini akan menggunakan fail FXML untuk mencipta antara muka pengguna. Kita perlu mencipta fail FXML untuk mencipta antara muka pengguna yang ringkas:

<?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>

Fail FXML menerangkan VBox, yang mengandungi dua HBox. Setiap HBox mengandungi label dan butang. Kami akan menggunakan pengawal FXML di sini untuk mengendalikan acara klik butang. Ini bermakna kita perlu mencipta kelas Java untuk mengendalikan peristiwa dalam fail FXML.

3. Tambah Pengawal FXML

Kita perlu mencipta kelas Java untuk mengendalikan acara dalam fail FXML. Di sini kami akan menggunakan anotasi @FXML untuk mengikat kaedah dalam kelas Java kepada peristiwa dalam fail FXML. Di sini kita perlu mencipta kelas MyController:

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

Kelas pengawal kami mengandungi label dan kaedah. Kaedah akan dipanggil apabila butang diklik. Kaedah ini akan mengemas kini teks label untuk memaparkan "Hello, World!"

4. Mulakan aplikasi

Kami telah selesai membina aplikasi JavaFX. Sekarang kita perlu menulis kelas permulaan untuk memulakan aplikasi kita. Di sini, kami akan menggunakan anotasi @SpringBootApplication Spring Boot. Anotasi @SpringBootApplication akan mengimbas semua komponen dalam aplikasi dan secara automatik menetapkan konteks aplikasi Spring.

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

DemoApplication kami mewarisi kelas Aplikasi JavaFX. Apabila memulakan aplikasi, kelas SpringApplicationBuilder Spring Boot akan mengimbas aplikasi kami dan mencipta konteks Spring. Kelas FXMLLoader akan memuatkan fail FXML dan menetapkannya sebagai nod akar graf pemandangan. Kami meletakkan graf tempat kejadian ke peringkat baharu dan memaparkannya. Akhir sekali, apabila aplikasi keluar, kita perlu menutup konteks Spring.

3. Lengkapkan aplikasi

Kami telah berjaya membina aplikasi desktop menggunakan Spring Boot dan JavaFX. Kami boleh menggunakan JavaFX untuk mencipta antara muka pengguna yang sangat cantik dan berkuasa, menggunakan Spring Boot untuk mengendalikan logik perniagaan dan menggunakan Spring Boot untuk mengkonfigurasi aplikasi kami secara automatik. Artikel ini hanya memperkenalkan contoh mudah Jika anda ingin mencuba aplikasi yang lebih kompleks, saya mengesyorkan agar anda melihat dengan lebih dekat pada Spring Boot dan JavaFX.

Atas ialah kandungan terperinci Bina aplikasi desktop menggunakan Spring Boot dan JavaFX. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!