Panduan Lengkap Spring Boot 4 · Pelajaran

Perkongsian Data Kelas dan Penalaan Permulaan JVM

Percepat permulaan dalam mod JVM dengan CDS, pemulaan malas dan penalaan penciptaan kacang.

Pelajaran 3 daripada 413 langkah

Perkongsian Data Kelas dan Penalaan Permulaan JVM ialah pelajaran Panduan Lengkap Spring Boot 4 percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Panduan Lengkap Spring Boot 4, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Panduan Lengkap Spring Boot 4 merangkumi sejumlah 4 pelajaran.

Mengapa Permulaan JVM Masih Penting

Imej natif GraalVM memberikan permulaan yang hampir serta-merta, tetapi kebanyakan pasukan masih menghantar binaan JVM biasa untuk sebahagian besar penggunaan. JVM lebih mudah dinyahpepijat, menyokong pantulan penuh dan berfungsi dengan setiap ejen serta pustaka tanpa konfigurasi tambahan.

Berita baiknya: aplikasi Spring Boot 4 dalam mod JVM tidak semestinya lambat untuk bermula. Tiga langkah memberikan kesan paling besar:

Perkongsian Data Kelas (CDS) — elakkan penghuraian semula metadata kelas pada setiap permulaan.
Pemulaan malas — cipta bean hanya apabila digunakan buat kali pertama.
Penalaan penciptaan bean — elakkan kerja mahal dalam pembina dan semasa penyegaran.

Pelajaran ini menerangkan ketiga-tiganya dalam mod JVM, tanpa memerlukan imej natif.

Perkara Sebenar yang Dilakukan oleh Perkongsian Data Kelas

Apabila JVM bermula, ia memuatkan, menghuraikan dan mengesahkan ratusan atau ribuan kelas. Perkongsian Data Kelas (CDS) menulis perwakilan kelas dalam memori yang telah dihuraikan ke dalam fail arkib baca sahaja sekali, kemudian memetakan arkib itu ke dalam memori pada setiap permulaan berikutnya.

Manfaatnya:

Kurang kerja pemuatan dan pengesahan kelas bagi setiap permulaan.
Arkib boleh dikongsi merentas beberapa proses JVM (halaman memori fizikal yang sama).

Dua bentuk penting untuk Spring Boot 4:

CDS Dinamik (AppCDS) — arkibkan kelas aplikasi anda, bukan kelas JDK sahaja.
Project Leyden / cache Ahead-of-Time — evolusi yang dibina berlapis pada CDS dalam JDK yang lebih baharu.

Sokongan CDS Terbina dalam Spring Boot 4

Spring Boot menyediakan sokongan kelas pertama untuk menjana arkib AppCDS. Anda menjalankan aplikasi sekali dalam mod latihan khas, aplikasi menyentuh konteks, keluar dan membuang arkib. Pelaksanaan berikutnya mengarahkan JVM kepada arkib tersebut.

Pelaksanaan latihan menggunakan sifat khas di bawah. Ia melakukan penyegaran konteks dan kemudian ditutup tanpa melayan trafik:

-Dspring.context.exit=onRefresh menghentikan aplikasi sebaik sahaja konteks sedia.
Bendera JVM -XX:ArchiveClassesAtExit menangkap kelas yang dimuatkan.

# Step 1: training run - refresh context, then exit, dumping the archive
java -XX:ArchiveClassesAtExit=app.jsa \
     -Dspring.context.exit=onRefresh \
     -jar target/myapp.jar

# Step 2: every production start reuses the archive
java -XX:SharedArchiveFile=app.jsa \
     -jar target/myapp.jar

Pengoptimuman Susun Atur dengan Jar Mesra CDS

Jar gemuk Spring Boot standard menyarangkan jar kebergantungan di dalamnya. CDS berfungsi paling baik apabila kelas berada sebagai fail biasa pada laluan yang boleh dipetakan terus oleh JVM. Susun atur tools Spring Boot mengekstrak aplikasi ke dalam direktori supaya CDS dapat mengindeksnya dengan kemas.

Ekstrak struktur yang boleh dijalankan menggunakan mod jar terbina dalam, kemudian jalankannya daripada susun atur yang telah dikembangkan:

-Djarmode=tools extract menulis direktori application/ dengan laluan kelas rata.
Menjalankan aplikasi daripada bentuk yang telah dikembangkan menjadikan permulaan latihan dan pengeluaran lebih pantas serta lebih boleh dihasilkan semula.

# Explode the jar into a CDS-friendly directory structure
java -Djarmode=tools -jar target/myapp.jar extract --destination app

# Train against the exploded app
java -XX:ArchiveClassesAtExit=app/app.jsa \
     -Dspring.context.exit=onRefresh \
     -jar app/myapp.jar

# Production start
java -XX:SharedArchiveFile=app/app.jsa -jar app/myapp.jar

Mengesahkan CDS Aktif

Sentiasa sahkan bahawa arkib benar-benar digunakan; kesilapan taip pada laluan akan kembali secara senyap kepada pelaksanaan tanpa CDS. Tambahkan pengelogan pemuatan kelas untuk melihat kelas yang datang daripada arkib kongsi berbanding laluan kelas biasa.

Gunakan bendera diagnostik semasa pemeriksaan sekali sahaja:

-Xlog:class+load:file=cds.log menandakan setiap kelas dengan shared apabila kelas itu dimuatkan daripada arkib.
Gunakan grep pada log: arkib yang sihat menunjukkan sebahagian besar kelas rangka kerja ditandakan sebagai shared.

# Run with class-load logging and inspect the source of each class
java -XX:SharedArchiveFile=app/app.jsa \
     -Xlog:class+load:file=cds.log \
     -jar app/myapp.jar

# Count how many classes were served from the shared archive
grep -c 'source: shared objects file' cds.log

Pemulaan Bean Secara Malas

Secara lalai, Spring mencipta setiap bean tunggal secara bersemangat semasa penyegaran konteks. Dengan banyak bean, kerja ini mendominasi masa permulaan. Pemulaan malas menangguhkan penciptaan setiap bean sehingga bean itu disuntik atau diminta buat kali pertama.

Aktifkannya secara global dengan satu sifat:

spring.main.lazy-initialization=true menjadikan semua bean malas.
Imbangan: ralat dalam pendawaian bean hanya muncul apabila bean digunakan, bukannya semasa permulaan, dan permintaan pertama yang menyentuh bean yang belum dimuatkan perlu menanggung kos pembinaannya.

Utamakan pendekatan ini untuk tugas CLI jangka pendek dan permulaan pembangunan; berhati-hati dalam perkhidmatan yang sentiasa aktif apabila permintaan pertama yang lambat lebih buruk daripada permulaan yang sedikit lebih perlahan.

spring.main.lazy-initialization=true

Kemalasan Terpilih dengan @Lazy

Kemalasan global terlalu kasar. Selalunya anda mahu kebanyakan bean dicipta secara bersemangat supaya kegagalan dapat dikesan semasa permulaan, tetapi beberapa bean berat dicipta secara malas — contohnya klien yang membuka sambungan perlahan atau cache yang pramuat set data besar.

Anotasikan bean atau titik suntikan dengan @Lazy. Spring kemudian menyuntik proksi dan mencipta bean sebenar apabila panggilan pertama dibuat.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

@Configuration
public class ReportingConfig {

    // Heavy bean: only built when something actually needs it
    @Bean
    @Lazy
    public ReportGenerator reportGenerator(DataWarehouse warehouse) {
        return new ReportGenerator(warehouse);
    }
}

Pastikan Pembina Bean Ringkas

Punca terbesar kelembapan permulaan yang disebabkan sendiri ialah melakukan kerja sebenar dalam pembina atau kaedah @PostConstruct: membuka sambungan, memanaskan cache dan memanggil perkhidmatan jauh. Kesemuanya berjalan secara bersiri semasa penyegaran lalu menghalang permulaan.

Peraturan umum:

Pembina hanya patut menyimpan kolaborator, dan tidak pernah melakukan I/O.
Tangguhkan pemanasan yang mahal kepada acara yang berlaku selepas konteks sedia, atau jalankannya secara tak segerak.
Dengarkan ApplicationReadyEvent untuk pemanasan yang tidak sepatutnya menghalang konteks daripada dimulakan.

import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class CacheWarmer {

    private final ProductCache cache;

    public CacheWarmer(ProductCache cache) {
        // cheap: just hold the dependency
        this.cache = cache;
    }

    // Runs after startup, off the critical path
    @Async
    @EventListener(ApplicationReadyEvent.class)
    public void warmUp() {
        cache.preload();
    }
}

Penciptaan Bean di Latar Belakang

Spring Boot boleh mencipta bean yang layak pada kumpulan benang latar belakang sementara benang utama meneruskan penyegaran. Ini menjalankan bean yang bebas dan lambat dicipta secara selari, lalu memendekkan masa permulaan sebenar.

Takrifkan bean bootstrapExecutor; Spring menggunakannya untuk mencipta bean yang memilih untuk menyertainya di latar belakang. Bean yang tidak bergantung pada bean tersebut masih diteruskan pada benang utama.

import java.util.concurrent.Executor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
public class BootstrapConfig {

    // Spring detects a bean named 'bootstrapExecutor' for background init
    @Bean
    public Executor bootstrapExecutor() {
        ThreadPoolTaskExecutor exec = new ThreadPoolTaskExecutor();
        exec.setCorePoolSize(4);
        exec.setThreadNamePrefix("bg-init-");
        exec.initialize();
        return exec;
    }
}

Mengukur Permulaan dengan Aktuator Permulaan

Jangan meneka ke mana perginya masa — ukurlah. Spring merekodkan garis masa permulaan bagi setiap langkah, termasuk penciptaan bean, pemprosesan selepas itu dan konfigurasi automatik, apabila anda membekalkan BufferingApplicationStartup.

Sambungkannya dalam main(), kemudian baca acara yang disimpan daripada titik akhir /actuator/startup untuk mencari langkah yang paling lambat. Isih mengikut tempoh dan tangani punca utama terlebih dahulu.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.metrics.buffering.BufferingApplicationStartup;

@SpringBootApplication
public class ShopApplication {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(ShopApplication.class);
        // capture up to 2048 startup steps for /actuator/startup
        app.setApplicationStartup(new BufferingApplicationStartup(2048));
        app.run(args);
    }
}

Menggabungkan Semuanya: Resipi Permulaan Terlaras

Penalaan realistik dalam mod JVM untuk perkhidmatan Spring Boot 4 menggabungkan teknik mengikut kesan:

1. Ekstrak jar (jarmode=tools extract) dan jana arkib AppCDS dengan pelaksanaan latihan.
2. Gunakan @Lazy pada beberapa bean yang benar-benar berat; kekalkan bean lain secara bersemangat supaya ralat konfigurasi gagal dengan cepat.
3. Alihkan semua pemanasan dan I/O daripada pembina ke pendengar ApplicationReadyEvent.
4. Tambahkan bootstrapExecutor jika anda mempunyai beberapa bean bebas yang lambat.
5. Gunakan BufferingApplicationStartup untuk mengesahkan bahawa setiap perubahan memberikan manfaat.

Perintah pelancaran kemudiannya hanya perlu menunjuk kepada arkib:

java -XX:SharedArchiveFile=app/app.jsa \
     -Dspring.threads.virtual.enabled=true \
     -jar app/myapp.jar

Semakan Pantas: Memilih Langkah yang Betul

Anda mempunyai perkhidmatan web Spring Boot 4 yang sentiasa aktif. Pemprofilan menunjukkan bahawa masa but bermula banyak digunakan untuk menghuraikan semula dan mengesahkan kelas rangka kerja pada setiap mula semula, dan beberapa permintaan mencapai bean yang tidak pernah dipanaskan. Anda mahukan permulaan berulang yang konsisten dengan lebih pantas tanpa menyebabkan permintaan pengguna pertama menjadi ketara perlahan.

Jawab dalam pelajaran interaktif

Ringkasan

Spring Boot 4 dalam mod JVM boleh dimulakan dengan pantas tanpa menjadi natif. Perkara utama:

CDS memetakan arkib kelas yang telah dihuraikan ke memori; ciptakannya dengan proses latihan (-XX:ArchiveClassesAtExit + spring.context.exit=onRefresh) dan gunakannya dengan -XX:SharedArchiveFile. Ekstrak jar terlebih dahulu untuk susun atur yang serasi dengan CDS.
Permulaan malas menangguhkan penciptaan bean: secara global melalui spring.main.lazy-initialization, atau secara terpilih melalui @Lazy. Pendekatan ini menukar kegagalan segera dan kependaman permintaan pertama dengan but yang lebih pantas.
Penalaan bean: pastikan pembina ringan, pindahkan proses pemanasan ke ApplicationReadyEvent, dan jalankan bean perlahan yang tidak bergantung antara satu sama lain secara selari dengan bootstrapExecutor.
Ukur semuanya dengan BufferingApplicationStartup dan /actuator/startup — tala langkah yang paling perlahan, bukan andaian anda.

Percuma untuk bermula

Pelajari Java dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 21
Pelajaran: 84

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Perkongsian Data Kelas dan Penalaan Permulaan JVM” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Panduan Lengkap Spring Boot 4, termasuk “Perkongsian Data Kelas dan Penalaan Permulaan JVM”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Panduan Lengkap Spring Boot 4 merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Perkongsian Data Kelas dan Penalaan Permulaan JVM”?

Percepat permulaan dalam mod JVM dengan CDS, pemulaan malas dan penalaan penciptaan kacang. Anda berlatih Panduan Lengkap Spring Boot 4 menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Panduan Lengkap Spring Boot 4?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Panduan Lengkap Spring Boot 4 di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Perkongsian Data Kelas dan Penalaan Permulaan JVM” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Panduan Lengkap Spring Boot 4 ini?

Ya. Setiap pelajaran Panduan Lengkap Spring Boot 4 menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Pemprosesan AOT dan Saluran Binaan Asli
Petunjuk Masa Jalan untuk Refleksi dan Sumber
Perkongsian Data Kelas dan Penalaan Permulaan JVM
Mendiagnosis dan Membetulkan Isu Keserasian Asli

← Kembali ke Panduan Lengkap Spring Boot 4