Pengembangan yang Dipercepat dengan Dev Boot Musim Semi

Bagaimana mempercepat pengembangan di Boot Spring dengan DevTools dan membuat proses ini lebih menyenangkan dan produktif?

Kustomisasi

Seperti biasa ketika berkembang di Spring Boot, pengaturannya cukup sederhana. Yang harus Anda lakukan adalah menambahkan ketergantungan yang benar dan Anda selesai. Spring Boot menemukannya dan secara otomatis mengkonfigurasi DevTools sesuai.

Jika Anda menggunakan Maven:

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional> </dependency> 

Jika menggunakan Gradle:

 configurations { developmentOnly runtimeClasspath { extendsFrom developmentOnly } } dependencies { developmentOnly("org.springframework.boot:spring-boot-devtools") } 

Harap dicatat bahwa ketergantungan dinyatakan sebagai opsional. Ini penting karena deklarasi ketergantungan seperti itu mencegah ketergantungan DevTools dari diterapkan secara transitif ke modul lain tergantung pada proyek Anda.

Mulai ulang otomatis

Setiap kali perubahan file terjadi di classpath Anda, DevTools akan secara otomatis memulai kembali aplikasi Anda yang bekerja dengan perubahan baru. Untuk pengembangan lokal, ini dapat bermanfaat karena Anda tidak perlu menggunakan kembali aplikasi secara manual.

Ini saja tidak akan begitu berguna, karena memulai ulang masih dapat mengambil terlalu banyak waktu. Untungnya, restart seperti itu jauh lebih cepat daripada restart biasa karena trik rumit yang digunakan DevTools.

Faktanya adalah ketika mengembangkan aplikasi, Anda biasanya mengubah satu atau beberapa kelas dan ingin memeriksa hasilnya di aplikasi Anda yang sedang berjalan untuk mendapatkan umpan balik. Anda membuat perubahan kecil pada aplikasi Anda, sementara sebagian besar kelas yang dimuat berasal dari frameworks dan perpustakaan pihak ketiga.

Di bawah tenda Spring DevTools, dua loader kelas digunakan - dudukan dan mulai ulang . Kelas yang tidak berubah dimuat oleh basis loader dasar . Kelas Anda bekerja dengan dimuat menggunakan restart loader. Setiap kali Anda memulai ulang, boot loader diciptakan kembali. Dengan demikian, memulai ulang aplikasi jauh lebih cepat dari biasanya, dan dapat menjadi alternatif nyata untuk memuat ulang kelas dinamis menggunakan alat seperti JRebel.

Inisialisasi restart di IDE

Restart dipicu setiap kali file berubah di classpath Anda. Namun, proses ini tergantung pada IDE Anda. Ini berarti bahwa hanya mengubah file java Anda tidak cukup. Yang penting adalah ketika IDE Anda benar-benar memperbarui file .class di classpath Anda.

Saat menggunakan IntelliJ IDEA, Anda perlu menjalankan perintah build di proyek Anda ( Ctrl + F9 atau Build → Build Project ). Anda juga dapat mengkonfigurasi perintah build untuk berjalan secara otomatis di IDEA . Selain itu, Anda dapat membuka konfigurasi startup Boot Musim Semi dan menentukan apa yang terjadi ketika pembaruan aplikasi dimulai ( Ctrl + F10 ):



Di kotak kombo pertama, Anda dapat memilih Perbarui file pemicu untuk memulai DevTools restart setiap kali tindakan Pembaruan dilakukan. Atau, Anda bahkan dapat memilih opsi Hot Swap dan mencoba memulai kembali aplikasi menggunakan DevTools hanya jika eksekusi Hot Swap gagal.

Di kotak kombo kedua, Anda dapat mengonfigurasi reboot semua sumber daya statis dan templat ketika jendela IDEA kehilangan fokus (misalnya, saat beralih ke jendela peramban).

Di Eclipse, cukup mudah untuk menyimpan file Anda.

Hanya Pengembangan

Spring Boot DevTools dimaksudkan hanya untuk pengembangan, dan bukan untuk operasi produksi aplikasi. Jika aplikasi Anda mendeteksi bahwa Anda bekerja di lingkungan produksi, DevTools otomatis dinonaktifkan.

Untuk tujuan ini, setiap kali Anda meluncurkan aplikasi Anda sebagai artefak yang dikemas penuh, seperti tabung dengan server aplikasi terintegrasi, itu dianggap sebagai aplikasi produksi:

 java -jar devtools-example-1.0.0.jar 

Hal yang sama berlaku ketika aplikasi Anda diluncurkan melalui loader kelas khusus, misalnya, pada server aplikasi.

Sebaliknya, ketika Anda menjalankan artefak yang tidak dibongkar (misalnya, dalam IDE Anda), aplikasi Anda dipertimbangkan dalam mode pengembangan. Hal yang sama berlaku untuk menggunakan spring-boot-plugin untuk menjalankan aplikasi:

Maven:

 mvn spring-boot:run 

Gradle:

 gradle bootRun 

LiveReload

LiveReload adalah alat yang berguna yang memungkinkan Anda untuk me-refresh halaman di browser secara instan setiap kali Anda membuat perubahan pada file seperti HTML, CSS, gambar, dan banyak lagi. Ia bahkan memproses ulang file sesuai kebutuhan - ini berarti kompilasi otomatis file SASS atau KURANG.



Spring DevTools secara otomatis memulai instance lokal dari server LiveReload yang melacak file Anda. Yang harus Anda lakukan adalah menginstal ekstensi untuk browser , dan Anda selesai. Ini tidak hanya berguna untuk mengembangkan antarmuka eksternal aplikasi Anda (jika Anda mendistribusikannya sebagai bagian dari artefak aplikasi Spring), tetapi juga dapat digunakan untuk memantau dan memuat ulang output dari REST API Anda.

Properti Override

Ketika mengembangkan aplikasi secara lokal, Anda biasanya memiliki kebutuhan konfigurasi yang berbeda daripada ketika bekerja di lingkungan produksi. Salah satu contohnya adalah caching. Dalam lingkungan produksi, ketergantungan pada berbagai cache (seperti cache templat mesin, header cache untuk sumber daya statis, dll.) Sangat penting. Selama pengembangan, ini mungkin menggunakan data lama dan tidak mencerminkan perubahan terbaru Anda. Contoh lain adalah logging tingkat lanjut, yang mungkin berguna dalam pengembangan tetapi terlalu rinci untuk lingkungan produksi.

Terlalu sulit untuk mengelola dua jenis konfigurasi sendiri. Berita baiknya adalah Spring Boot DevTools, secara default, mengatur banyak properti untuk pengembangan lokal Anda.

 spring.thymeleaf.cache=false spring.freemarker.cache=false spring.groovy.template.cache=false spring.mustache.cache=false server.servlet.session.persistent=true spring.h2.console.enabled=true spring.resources.cache.period=0 spring.resources.chain.cache=false spring.template.provider.cache=false spring.mvc.log-resolved-exception=true server.servlet.jsp.init-parameters.development=true spring.reactor.stacktrace-mode.enabled=true 

Anda dapat menemukan daftar semua properti di kelas DevToolsPropertyDefaultsPostProcessor .

Koneksi jarak jauh

Selain pengembangan lokal, Anda juga dapat terhubung ke aplikasi jarak jauh yang menjalankan DevTools. Alat ini tidak ditujukan untuk lingkungan produksi karena dapat menimbulkan risiko keamanan yang serius. Namun, ini bisa sangat berguna dalam lingkungan pra-produksi.

Mengaktifkan Koneksi Jarak Jauh

Koneksi jarak jauh tidak diaktifkan secara default. Anda harus mengaktifkannya secara eksplisit dengan memodifikasi file pom:

 <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <excludeDevtools>false</excludeDevtools> </configuration> </plugin> </plugins> </build> 

Atau dengan gradle, Anda perlu mengatur excludeDevtools = false :

 bootWar { excludeDevtools = false } 

Maka Anda perlu mengatur kata sandi yang akan digunakan untuk otentikasi ketika menghubungkan ke aplikasi jarak jauh:

 spring.devtools.remote.secret=somesecret 

Sambungkan ke aplikasi jarak jauh

Setelah memulai aplikasi jarak jauh, Anda dapat memulai sesi koneksi jarak jauh. Sekarang yang harus Anda lakukan adalah menjalankan org.springframework.boot.devtools.RemoteSpringApplication dengan URL aplikasi jarak jauh Anda sebagai argumen. Harap perhatikan bahwa Anda harus menggunakan https jika memungkinkan.

Memulai koneksi jarak jauh mudah di IDE Anda. Di IDEA, Anda hanya perlu membuat konfigurasi peluncuran baru. Pergi ke Jalankan → Edit Konfigurasi ... dan buat konfigurasi baru dengan ikon + di sudut kiri atas. Pilih jenis aplikasi.

Untuk kelas Utama, pilih RemoteSpringApplication dari modul DevTools dan berikan URL aplikasi jarak jauh Anda sebagai argumen ke program.



Setelah memulai konfigurasi ini, Anda akan melihat output yang serupa jika koneksi ke aplikasi jarak jauh berhasil.



Setelah terhubung ke aplikasi jarak jauh, DevTools memonitor perubahan jalur kelas dengan cara yang sama seperti untuk pengembangan lokal. Namun, alih-alih restart lokal, transfer perubahan ke server jauh dan memulai restart di sana. Ini bisa jauh lebih cepat daripada membuat aplikasi dan menggunakannya untuk mesin jarak jauh.

Konfigurasi global

Anda dapat mengkustomisasi DevTools menggunakan properti konfigurasi, seperti dengan aplikasi Spring lainnya. Ini biasanya berarti mengedit properti aplikasi . Dari proyek Anda. Konfigurasi ini terpisah untuk setiap aplikasi.

Namun, dalam beberapa skenario mungkin nyaman untuk memiliki konfigurasi global untuk SEMUA aplikasi yang berjalan di komputer yang sama. Anda dapat membuat file properti bernama .spring-boot-devtools.properties yang terletak di direktori $ HOME Anda . Deklarasi yang dinyatakan dalam file ini berlaku untuk semua aplikasi menggunakan DevTools.

Keterbatasan

Muat ulang secara langsung

Aplikasi Spring menggunakan DevTools secara otomatis memulai server LiveReload. Sayangnya, hanya satu instance dari server ini yang dapat dimulai pada suatu waktu. Lebih tepatnya, hanya instance pertama yang akan bekerja. Ini berlaku tidak hanya untuk beberapa contoh aplikasi Spring dengan DevTools, tetapi juga untuk aplikasi lain yang juga menggunakan LiverReload di bawah tenda, seperti Gatsby dalam mode pengembangan.

Jika Anda ingin mengonfigurasi aplikasi Spring agar tidak memulai server LiveReload, maka ini dapat dilakukan di file application.properties Anda:

 spring.devtools.livereload.enabled=false 

Shutdown hook

DevTools bergantung pada atribut kait shutdown dari kelas SpringApplication . Kelas tidak akan berfungsi dengan benar jika Anda menonaktifkan atribut secara manual menggunakan:

 springApplication.setRegisterShutdownHook(false); 

Atribut diaktifkan secara default, jadi Anda tidak perlu khawatir tentang hal itu kecuali jika Anda menonaktifkannya secara eksplisit.

Tabrakan dengan perpustakaan pihak ketiga

Meskipun DevTools biasanya harus bekerja dengan benar, mereka mungkin memiliki konflik dengan perpustakaan pihak ketiga. Secara khusus, ada masalah yang diketahui dengan deserialization menggunakan ObjectInputStream standar.

Jika terjadi konflik seperti itu, Anda dapat menonaktifkan mulai ulang otomatis dengan menetapkan:

 spring.devtools.restart.enabled=false 

Restart tidak akan berfungsi lagi. Namun, restart classloader masih akan digunakan. Jika Anda perlu menonaktifkan pemuat kelas sepenuhnya, Anda harus melakukan ini sebelum memulai aplikasi:

 public static void main(String[] args) { System.setProperty("spring.devtools.restart.enabled", "false"); SpringApplication.run(MyApp.class, args); } 

Bahkan jika Anda tidak menggunakan restart otomatis, Anda masih dapat menggunakan fitur DevTools lainnya.

Mengaktifkan Inisialisasi Tertunda

Anda dapat menandai setiap komponen sebagai malas diinisialisasi menggunakan anotasi $$$@ Malas$. Fitur ini telah tersedia selama beberapa waktu. Dimulai dengan Spring Boot 2.2, Anda dapat mengganti inisialisasi tertunda untuk semua komponen kacang Anda menggunakan spring.main.lazy-inisialisasi = true .

Ini dapat digunakan sendiri atau dikombinasikan dengan DevTools untuk memulai ulang yang lebih cepat .

DevTools memungkinkan Anda untuk me-restart aplikasi Anda di JVM yang sama. Keuntungan penting dari restart panas adalah memberikan JIT lebih banyak opsi untuk mengoptimalkan kode yang digunakan untuk meluncurkan aplikasi Anda. Setelah beberapa restart, waktu awal 2500 ms berkurang hampir 80% dan mendekati 500 ms. Dengan inisialisasi malas, kita dapat mencapai hasil yang lebih baik. Saat memasang spring.main.lazy-inisialisasi, aplikasi kami restart setelah 400 ms langsung di IDE.

Menggunakan inisialisasi tertunda untuk semua kacang Anda dalam aplikasi produksi diragukan. Prosedur ini memberikan keuntungan kinerja awal yang lebih baik karena permintaan yang lebih lama untuk komponen kacang tunggal. Lebih penting lagi, aplikasi Anda tidak berhenti bekerja dengan cepat. Tetapi alih-alih crash segera setelah memulai aplikasi, itu akan gagal hanya setelah langsung meminta komponen yang salah dikonfigurasi. Ini bisa sangat berbahaya karena Anda tidak akan menemukan banyak kesalahan sampai terlambat. Namun, inisialisasi tertunda massal dapat berguna untuk mempercepat waktu pengembangan, karena ketika bekerja dengan fungsi tertentu, Anda biasanya hanya bekerja pada bagian dari aplikasi Anda, dan tidak menggunakan sisanya. Kompromi yang ideal adalah mengaktifkan inisialisasi tertunda massal hanya untuk pengembangan lokal (misalnya, menggunakan profil pegas) dan menonaktifkannya untuk lingkungan yang lebih tinggi digunakan.

Kesimpulan

DevTools mempercepat dan menyederhanakan pengembangan aplikasi Boot Spring dengan menyediakan fungsi restart otomatis dan LiveReload. Selain itu, ia menetapkan berbagai properti untuk nilai yang lebih cocok untuk pengembangan lokal. Selain itu, ini memungkinkan Anda untuk terhubung dari jarak jauh ke aplikasi Anda dan pada saat yang sama menggunakan sebagian besar fungsinya. Saat memulai aplikasi dalam produksi, DevTools tidak digunakan. Lihat dokumentasi resmi untuk perinciannya.