🏾 👋🏻 🛎️ Tutorial: Boot Musim Semi Reaktif 🔌 🥂 👩🏽‍🏭

Bulan lalu, Trisha Gee (JetBrains) menghadirkan di SpringOne sebuah demo untuk membuat aplikasi harga saham real-time menggunakan Spring Boot, Kotlin, dan JavaFX. Demo langsung direkam dan tersedia dalam video 70 menit .

Pada 18 Desember, Trisha menyelesaikan publikasi di dzone.com dari tutorial reaktif Spring Boot berdasarkan video, sebagai serangkaian video pendek dengan posting blog yang menyertai menjelaskan setiap langkah lebih lambat dan lebih terinci.

Saya punya ide untuk menerjemahkan tutorial ini ke dalam bahasa Rusia. Namun, Trisha menanggapi dengan sopan dengan pertanyaan saya tentang ini:

"Biarkan saya periksa dengan organisasi saya. Saya ingin terjemahannya tetapi kami mungkin memiliki cara yang lebih disukai untuk menerjemahkannya. ”

Jadi saya memutuskan untuk membatasi diri pada ikhtisar tutorial ini, yang mencakup serangkaian pelajaran berikut:

Tutorial ini adalah serangkaian pelajaran di mana Anda akan membuat aplikasi Spring Boot penuh dengan antarmuka internal Kotlin, klien Java dan antarmuka pengguna JavaFX.

Bagian 1. Membuat layanan REST di Kotlin

Bagian pertama tutorial ini menjelaskan cara membuat aplikasi Spring Boot di Kotlin, yang berfungsi sebagai sisi server dari aplikasi tersebut. Layanan REST reaktif akan dibuat, yang dapat Anda sambungkan di bagian manual berikut.

Entri blog ini berisi video yang menunjukkan proses langkah demi langkah dan panduan teks (diadaptasi dari transkrip video) bagi mereka yang lebih suka format tertulis.

Bagian tutorial ini mencakup langkah-langkah berikut:

Membuat Proyek Layanan Boot Musim Semi
Struktur proyek Boot Spring
Membuat Kontroler REST
Membuat kelas data untuk harga saham
Harga dan pengembalian harga
Peluncuran aplikasi

Setelah menyelesaikan langkah-langkah ini di bagian 1 dari tutorial, aplikasi Boot Kotlin sederhana Spring akan dibuat yang menggunakan Reactive Streams untuk mengeluarkan harga saham yang dihasilkan secara acak sekali per detik.

Kode lengkap untuk bagian 1 tutorial ini tersedia di GitHub .

Bagian 2. REST client untuk aliran reaktif

Bagian 2 dari tutorial ini menunjukkan cara membuat klien Java reaktif di Spring yang terhubung ke layanan REST yang menyiarkan harga saham sekali per detik. Klien ini akan digunakan di bagian selanjutnya dari manual ini. Selama pengembangan, proses berbasis TDD akan digunakan untuk membuat klien dan mengujinya.

Entri blog ini berisi video yang menunjukkan proses langkah demi langkah dan panduan teks (diadaptasi dari transkrip video) bagi mereka yang lebih suka format tertulis.

Bagian tutorial ini mencakup langkah-langkah berikut:

Membuat proyek untuk klien
Menciptakan kelas pelanggan
Membuat tes pelanggan
Membuat metode harga dasar pelanggan
Buat kelas untuk menahan harga saham
Menambahkan Pernyataan ke Tes
Hubungkan klien ke layanan REST
Jalankan Uji Integrasi
Pernyataan yang lebih menyeluruh dalam tes integrasi

Menguji aplikasi reaktif bukanlah keterampilan yang mudah, dan tentu saja ada cara yang jauh lebih baik untuk melakukan ini daripada dalam contoh sederhana ini. Namun, tes integrasi berhasil digunakan untuk menentukan API dan fungsionalitas klien untuk harga saham.

Klien ini terhubung ke titik akhir, yang menghasilkan peristiwa yang dikirim oleh server dan mengembalikan aliran objek StockPrice yang dapat digunakan oleh layanan lain. Cara melakukan ini akan ditampilkan di video berikutnya dari seri ini.

Kode 2 bagian lengkap tersedia di GitHub .

Bagian 3. Aplikasi JavaFX Spring Boot

Demonstrasi ketiga menunjukkan cara membuat aplikasi JavaFX yang diluncurkan dan dikelola melalui Spring Boot untuk menggunakan fitur Spring, seperti Pembalikan Kontrol dan Injeksi Ketergantungan, di aplikasi JavaFX kami.

Entri blog ini juga berisi video yang menunjukkan proses langkah-demi-langkah dan panduan teks (diadaptasi dari transkrip video) bagi mereka yang lebih suka format tertulis.

Bagian tutorial ini mencakup langkah-langkah berikut:

Pengaturan modul
Mengubah Kelas Aplikasi Boot Musim Semi
Mengedit Pengaturan Boot Musim Semi
Membuat Kelas Aplikasi JavaFX
Menyiapkan kelas Aplikasi Spring Boot
Mempublikasikan acara melalui konteks aplikasi
Buat konteks aplikasi
Menutup konteks aplikasi
Mendengarkan Acara Aplikasi

Setelah menyelesaikan langkah 3 tutorial, jendela utama aplikasi JavaFX akan dibuat (Tahap - lihat bagian 2 dari Tutorial JavaFX ), yang memungkinkan Anda untuk mengkonfigurasi antarmuka pengguna. Selanjutnya, Anda dapat menjalankan aplikasi StockUIA kami dan melihat bahwa itu dimulai dengan sukses sebagai aplikasi Spring Boot. Itu juga meluncurkan proses Java yang akan menampilkan antarmuka pengguna jika kita membuatnya. Saat ini, aplikasi JavaFX telah berhasil dibuat, yang diluncurkan dan dikelola menggunakan Spring dan memungkinkan Anda untuk menggunakan fungsi-fungsi praktis dari aplikasi Spring.

Kode tutorial 3 bagian lengkap tersedia di GitHub.

Bagian 4. Bagan garis JavaFX

Pada langkah tutorial ini, kita akan melihat cara membuat aplikasi JavaFX yang memperlihatkan diagram garis. Aplikasi ini menggunakan Spring untuk fungsi-fungsi penting seperti inversi kontrol.

Entri blog ini berisi video yang menunjukkan proses langkah demi langkah dan panduan teks (diadaptasi dari transkrip video) bagi mereka yang lebih suka format tertulis.

Bagian tutorial ini mencakup langkah-langkah berikut:

Membuat adegan (Scene - lihat bagian 2 dari Tutorial JavaFX )
Menggunakan FXML
Membuat File FXML
Setel Header Aplikasi
Pengaturan header aplikasi dari application.properties
Mendapatkan pengontrol JavaFX dari Spring
Buat bagan garis

Setelah menyelesaikan langkah-langkah di atas, bagian 4 dari tutorial akan membuat aplikasi JavaFX. Setelah meluncurkan aplikasi, kita akan melihat garis besar diagram garis yang ditunjukkan di jendela kita, dengan angka untuk harga sepanjang sumbu Y dan waktu di sepanjang sumbu X.

Aplikasi JavaFX yang diintegrasikan ke dalam Boot Musim Semi dibuat yang menggunakan FXML untuk menyatakan apa yang harus ditampilkan dalam tampilan.

Kode lengkap untuk bagian tutorial ini tersedia di GitHub.

Bagian 5. Konfigurasi otomatis untuk kacang yang dibagikan

Pelajaran 5 menunjukkan cara menggunakan kacang Spring dari satu modul dalam modul lain menggunakan konfigurasi otomatis.

Entri blog ini juga berisi video yang menunjukkan proses langkah-demi-langkah dan panduan teks (diadaptasi dari transkrip video) bagi mereka yang lebih suka format tertulis.

Dalam pelajaran terakhir, aplikasi JavaFX Spring Boot dibuat yang menunjukkan diagram garis kosong. Dalam video ini kita akan melihat cara mengkonfigurasi konfigurasi otomatis untuk Spring Beans sehingga kita dapat menggunakan komponen bean yang didefinisikan dalam modul stock-client dalam modul stock-ui.

Bagian tutorial ini mencakup langkah-langkah berikut:

Menambahkan ketergantungan pada modul lain
Membuat Bean WebClientStockClient
Aktifkan konfigurasi otomatis

Ini adalah bagian yang cukup kecil dari tutorial, tetapi memungkinkan kita untuk membuat modul yang dapat digunakan kembali oleh berbagai aplikasi Spring Boot. Sekarang kita dapat menggunakan klien di ChartController untuk terhubung ke layanan harga dan mulai menampilkan harga secara real time pada grafik garis.

Kode lengkap untuk bagian ini tersedia di GitHub.

Bagian 6. Tampilan Data Reaktif

Pelajaran ini membahas menghubungkan diagram JavaFX ke layanan Boot Musim Semi Kotlin kami untuk menampilkan harga secara real time. Entri blog ini berisi video yang menunjukkan proses langkah demi langkah dan panduan teks (diadaptasi dari transkrip video) bagi mereka yang lebih suka format tertulis.

Di bagian keempat , aplikasi JavaFX Spring Boot dibuat, yang menunjukkan diagram garis kosong. Rilis terbaru ( bagian kelima ) menggunakan WebClientStockClient untuk terhubung ke layanan harga. Pada bagian ini, grafik garis diperoleh yang menunjukkan harga yang datang dari layanan Boot Musim Semi Kotlin kami secara real time.

Bagian tutorial ini mencakup langkah-langkah berikut:

Mengkonfigurasi data bagan
Berlangganan data harga
Tampilan Data Harga
Peluncuran aplikasi
Tampilan Nama Karakter
Pembersihan kode

Beberapa baris kode di bagian tutorial ini membuat aplikasi JavaFX yang menggunakan SpringClient untuk terhubung ke layanan Spring Boot, berlangganan aliran harga reaktif dan menarik harga pada bagan garis secara real time.

Kode lengkap untuk bagian ini tersedia di GitHub.

Bagian 7. Berlangganan beberapa pelanggan

Pada bagian sebelumnya , kami berlangganan diagram garis JavaFX untuk harga dari layanan Boot Musim Semi Reaktif kami dan menampilkannya secara real time.

Dalam pelajaran ini, jadwal pembaruan waktu-nyata akan diselesaikan untuk menunjukkan harga lebih dari satu saham, yang mengharuskan lebih dari satu konsumen untuk berlangganan aliran harga reaktif kami.

Di blog Anda akan menemukan video yang menunjukkan proses langkah-demi-langkah dan deskripsi teks (diadaptasi dari transkrip video) bagi mereka yang lebih suka format tertulis.

Bagian tutorial ini mencakup langkah-langkah berikut:

Kami menyadari harga pelanggan
Mentransfer tugas ke pelanggan harga
Menambahkan Pelanggan Kedua
Pembersihan kode
Bonus Refactoring (bukan di video!)

Di akhir bagian tutorial ini, Anda akan membuat aplikasi JavaFX yang berlangganan lebih dari satu harga dari layanan Spring Boot kami dan menampilkan setiap set data harga waktu-nyata dalam beberapa seri pada bagan garis.

Kode lengkap untuk bagian ini tersedia di GitHub.

Bagian 8. Server RSlin Kotlin

Dalam pelajaran ini , layanan internal baru akan ditambahkan ke Kotlin, yang mengirimkan harga melalui RSocket, sebuah protokol untuk aliran reaktif. Entri blog ini berisi video yang menunjukkan proses langkah demi langkah dan panduan teks (diadaptasi dari transkrip video) bagi mereka yang lebih suka format tertulis.

Pada tahap seri tutorial ini, sebuah aplikasi komprehensif berhasil dibuat yang menerbitkan harga dari layanan Boot Musim Kotlin dan menampilkannya pada grafik garis JavaFX. Ini menggunakan protokol HTTP untuk mengirim acara ke server. Namun, karena ini adalah aplikasi reaktif, kita dapat memilih protokol yang paling cocok untuk streaming data.

Di bagian tutorial ini, sebuah layanan akan dibuat yang menghasilkan data harga menggunakan protokol RSocket.

Bagian tutorial ini mencakup langkah-langkah berikut:

Membuat Pengendali RSocket
Kami menyadari layanan harga
Porting kode umum ke PriceService
Kurangi duplikasi kode
Refactoring untuk Mengurangi Boilerplate
Pengaturan Tampilan Pesan
Konfigurasi Server RSocket

Pada akhir bagian tutorial ini, port 7000 akan meluncurkan layanan penetapan harga, siap untuk menghubungkan klien untuk menerima harga saham melalui RSocket.

Kode sumber lengkap untuk bagian ini tersedia di GitHub.

Bagian 9. Java RSocket Client

Dalam pelajaran ini, kami akan menambahkan klien RSocket yang dapat berkomunikasi dengan server RSocket yang kami buat dalam pelajaran terakhir .

Entri blog ini berisi video yang menunjukkan proses langkah demi langkah dan panduan teks (diadaptasi dari transkrip video) bagi mereka yang lebih suka format tertulis.

Saat ini, kami memiliki aplikasi yang berfungsi dari awal hingga selesai menggunakan Spring's WebClient . Dalam pelajaran terakhir, kami memperkenalkan server RSocket baru, yang saat ini berfungsi, dan dalam pelajaran ini kita akan melihat cara membuat klien untuk terhubung.

Bagian tutorial ini mencakup langkah-langkah berikut:

Buat tes integrasi
Membuat Klien Saham RSocket
Memperkenalkan Antarmuka StockClient
Implementasi Koneksi RSocket
Membuat RSocketRequester
Tes Lulus Integrasi
Menguji dengan StepVerifier
Menambahkan rollback dan strategi penanganan kesalahan

Pada akhir bagian tutorial ini, kita akan memiliki server RSocket yang menghasilkan harga saham, dan klien RSocket yang dapat terhubung dengannya dan melihat harga-harga ini. Dalam pelajaran berikutnya, kita akan melihat bagaimana cara beralih dari menggunakan WebClientStockClient ke RSocketStockClient baru kami.

Kode sumber lengkap untuk bagian ini tersedia di GitHub.

Bagian 10. Profil pegas untuk berpindah klien

Bagian terakhir dari tutorial menggunakan pengaturan Profil Musim Semi sehingga aplikasi dapat menentukan yang mana dari dua klien kami (acara yang dikirim oleh server melalui WebClient atau RSocket) untuk digunakan untuk terhubung ke layanan penetapan harga Kotlin Spring Boot kami.

Seperti biasa, posting blog ini berisi video yang menunjukkan proses langkah-demi-langkah dan panduan teks (diadaptasi dari transkrip video) bagi mereka yang lebih suka format tertulis.

Untuk tahap seri tutorial ini, kami memiliki klien RSocket yang memungkinkan kami untuk terhubung ke server RSocket kami, kami ingin menggunakan fitur-fitur ini dari aplikasi JavaFX kami.

Bagian tutorial ini mencakup langkah-langkah berikut:

Membuat Bean RSocketStockClient
Memilih Kacang untuk Digunakan
Pemilihan profil aktif
Logging untuk debugging
Dapatkan harga melalui RSocket

Pada akhir bagian tutorial ini, kita akan memiliki aplikasi bagan garis JavaFX yang lengkap dan komprehensif yang berlangganan aliran harga reaktif dari aplikasi Boot Musim Kotlin. Selain itu, aplikasi dapat dikonfigurasi untuk menerima harga-harga ini baik melalui peristiwa yang dikirim oleh server atau melalui protokol RSocket baru.

Kode lengkap tersedia di GitHub:

Proyek klien (stok-klien dan modul-ui-modul).
Proyek server (aplikasi Kotlin Spring Boot)

Bacaan tambahan

Fully Reactive: Spring, Kotlin, dan JavaFX Playing Together [Tautan]
Kotlin Microservice Dengan Tutorial Boot Musim Semi
Pemrograman Reaktif Musim Semi di Jawa

Tutorial: Boot Musim Semi Reaktif