Panduan Lengkap Spring Boot 4 · Pelajaran

Toleransi Kerosakan, Langkau dan Dasar Percubaan Semula

Konfigurasikan semantik langkau, percubaan semula dan mula semula untuk menjadikan kerja tahan terhadap ralat data sementara.

Pelajaran 3 daripada 413 langkah

Toleransi Kerosakan, Langkau dan Dasar Percubaan Semula 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 Toleransi Kegagalan Penting

Job kelompok memproses jumlah data yang sangat besar, dan data dunia sebenar tidak sempurna. Satu baris yang rosak, kebuntuan pangkalan data seketika atau panggilan kepada sistem hiliran yang tidak stabil boleh menggagalkan job yang telah memproses jutaan rekod.

Spring Batch memberikan toleransi kegagalan kepada step berorientasikan kelompok supaya step itu dapat mengatasi masalah ini tanpa menghentikan keseluruhan pelaksanaan. Tiga alat terasnya ialah:

Langkau — buang rekod yang menyebabkan ralat yang tidak dapat dipulihkan (contohnya data yang tidak sah) dan teruskan pemprosesan.
Cuba semula — cuba semula operasi yang gagal akibat ralat sementara (contohnya tamat masa kunci).
Mulakan semula — sambung semula instance job yang gagal dari tempat ia berhenti, bukannya bermula dari awal.

Apabila digunakan bersama, ciri-ciri ini mengubah job yang rapuh menjadi job yang tahan gangguan.

Mendayakan Toleransi Kegagalan pada Step

Toleransi kegagalan perlu didayakan secara pilihan. Apabila anda membina step kelompok, panggil .faultTolerant() pada pembina step untuk beralih kepada varian yang tahan kegagalan. Hanya selepas itu anda boleh mengisytiharkan peraturan langkau dan cuba semula.

Tanpa .faultTolerant(), sebarang pengecualian yang dilemparkan oleh pembaca, pemproses atau penulis akan membuat asal kelompok dan menggagalkan step dengan serta-merta.

@Bean
public Step importStep(JobRepository jobRepository,
                        PlatformTransactionManager txManager,
                        ItemReader<Customer> reader,
                        ItemProcessor<Customer, Customer> processor,
                        ItemWriter<Customer> writer) {
    return new StepBuilder("importStep", jobRepository)
            .<Customer, Customer>chunk(100, txManager)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .faultTolerant()   // unlocks skip & retry configuration
            .build();
}

Mengkonfigurasi Polisi Langkau

Langkau membolehkan step membuang satu item yang tidak mungkin berjaya — biasanya akibat kegagalan penghuraian atau pengesahan — dan meneruskan pemprosesan item seterusnya.

Anda mengisytiharkan pengecualian yang boleh dilangkau serta had global:

.skip(Exception.class) — tandakan jenis pengecualian sebagai boleh dilangkau.
.noSkip(Exception.class) — kecualikan subjenis daripada langkau secara jelas.
.skipLimit(n) — jumlah langkau yang dibenarkan sebelum step gagal.

Apabila jumlah langkau terkumpul melebihi skipLimit, step dihentikan. Ini menghalang job daripada menelan ribuan rekod bermasalah secara senyap.

return new StepBuilder("importStep", jobRepository)
        .<Customer, Customer>chunk(100, txManager)
        .reader(reader)
        .processor(processor)
        .writer(writer)
        .faultTolerant()
        .skip(FlatFileParseException.class)   // bad CSV line
        .skip(ValidationException.class)      // failed bean validation
        .noSkip(FileNotFoundException.class)  // never skip this
        .skipLimit(50)                        // fail after 50 skips
        .build();

Cara Langkau Berinteraksi dengan Kelompok

Tingkah laku langkau bergantung pada tempat pengecualian dilemparkan:

Langkau pembaca: item bermasalah dibuang dan bacaan diteruskan — murah, tanpa buat asal.
Langkau pemproses: transaksi kelompok dibuat asal, kemudian Spring Batch memproses semula kelompok item demi item dan hanya melangkau item yang bermasalah.
Langkau penulis: imbas dan cuba semula dengan cara yang sama — kelompok dibuat asal dan item ditulis semula satu demi satu supaya satu item yang bermasalah dapat diasingkan dan dilangkau.

Oleh sebab langkau pada pemproses/penulis mencetuskan buat asal dan main semula satu item, kosnya jauh lebih tinggi berbanding langkau pada pembaca. Letakkan pengesahan dalam pembaca/pemproses jika boleh supaya kegagalan dikesan lebih awal.

SkipPolicy Tersuai

API deklaratif .skip()/.skipLimit() merangkumi kebanyakan kes, tetapi anda boleh melaksanakan SkipPolicy untuk logik yang benar-benar tersuai — contohnya membenarkan lebih banyak langkau bagi satu jenis pengecualian berbanding jenis lain, atau memeriksa mesej pengecualian.

Method shouldSkip menerima Throwable yang dilemparkan dan jumlah langkau semasa; kembalikan true untuk melangkau, atau lemparkan SkipLimitExceededException untuk menggagalkan step.

public class CustomSkipPolicy implements SkipPolicy {

    @Override
    public boolean shouldSkip(Throwable t, long skipCount)
            throws SkipLimitExceededException {
        if (t instanceof FileNotFoundException) {
            return false; // fatal: never skip
        }
        if (t instanceof ValidationException && skipCount < 100) {
            return true;  // tolerate up to 100 bad records
        }
        if (t instanceof FlatFileParseException && skipCount < 20) {
            return true;
        }
        return false;
    }
}

Bila Perlu Cuba Semula berbanding Langkau

Keputusan antara langkau dan cuba semula bergantung pada sifat ralat:

Cuba semula ralat sementara yang mungkin berjaya jika dicuba lagi: mangsa kebuntuan, tamat masa kunci, konflik penguncian optimistik atau gangguan rangkaian singkat.
Langkau ralat deterministik yang akan sentiasa gagal: input rosak, pengesahan perniagaan yang gagal atau kekangan yang dilanggar oleh data itu sendiri.

Mencuba semula ralat deterministik hanya membazirkan percubaan sebelum gagal; melangkau ralat sementara pula membuang data yang sebenarnya boleh berjaya. Kelaskan pengecualian anda dengan betul — inilah keputusan reka bentuk utama dalam pelajaran ini.

Mengkonfigurasi Polisi Cuba Semula

Retry mencuba semula operasi yang gagal sehingga bilangan yang dikonfigurasikan sebelum berhenti. Dalam langkah tahan kesalahan, isytiharkan:

.retry(Exception.class) — jenis pengecualian yang boleh dicuba semula.
.noRetry(Exception.class) — kecualikan subjenis tertentu.
.retryLimit(n) — bilangan maksimum percubaan bagi setiap item (termasuk percubaan pertama).

Apabila item gagal dengan pengecualian yang boleh dicuba semula, transaksi kelompok akan dibuat asal dan item tersebut dimainkan semula sehingga retryLimit kali. Jika masih gagal, pengecualian itu disebarkan — pada ketika itu pengecualian tersebut mungkin dilangkau jika ia juga diisytiharkan sebagai boleh dilangkau.

return new StepBuilder("importStep", jobRepository)
        .<Customer, Customer>chunk(100, txManager)
        .reader(reader)
        .processor(processor)
        .writer(writer)
        .faultTolerant()
        .retry(DeadlockLoserDataAccessException.class)
        .retry(OptimisticLockingFailureException.class)
        .retryLimit(3)            // up to 3 attempts per item
        .skip(ValidationException.class)
        .skipLimit(50)
        .build();

Penangguhan Antara Percubaan Semula

Membebankan sumber yang sedang diperebutkan dengan percubaan semula serta-merta sering menjadikan perebutan lebih teruk. Dasar penangguhan menyelitkan kelewatan antara percubaan. ExponentialBackOffPolicy meningkatkan tempoh menunggu secara darab, lalu menyebarkan beban.

Anda melampirkan RetryPolicy atau BackOffPolicy tersuai melalui .retryPolicy(...) / dengan mengkonfigurasikan RetryTemplate. Di bawah, tempoh menunggu bermula pada 200ms dan digandakan pada setiap percubaan sehingga 5s.

@Bean
public RetryTemplate retryTemplate() {
    ExponentialBackOffPolicy backOff = new ExponentialBackOffPolicy();
    backOff.setInitialInterval(200);   // 200 ms
    backOff.setMultiplier(2.0);        // 200, 400, 800, ...
    backOff.setMaxInterval(5000);      // cap at 5 s

    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(3,
            Map.of(DeadlockLoserDataAccessException.class, true));

    RetryTemplate template = new RetryTemplate();
    template.setBackOffPolicy(backOff);
    template.setRetryPolicy(retryPolicy);
    return template;
}

Pendengar: Memerhati Langkauan dan Percubaan Semula

Melangkau rekod secara senyap adalah berbahaya — anda memerlukan jejak audit. Panggilan balik SkipListener dicetuskan untuk setiap item yang dilangkau supaya anda boleh mencatatnya, menulisnya ke jadual huruf mati atau menghantar amaran.

onSkipInRead — kegagalan membaca telah dilangkau.
onSkipInProcess — memberikan item dan pengecualian kepada anda.
onSkipInWrite — item yang tidak dapat ditulis.

Daftarkannya dengan .listener(skipListener) pada pembina langkah. Terdapat juga RetryListener untuk memerhati percubaan semula.

public class LoggingSkipListener implements SkipListener<Customer, Customer> {

    private static final Logger log =
            LoggerFactory.getLogger(LoggingSkipListener.class);

    @Override
    public void onSkipInRead(Throwable t) {
        log.warn("Skipped unreadable record: {}", t.getMessage());
    }

    @Override
    public void onSkipInProcess(Customer item, Throwable t) {
        log.warn("Skipped {} in process: {}", item.getId(), t.getMessage());
    }

    @Override
    public void onSkipInWrite(Customer item, Throwable t) {
        log.warn("Skipped {} in write: {}", item.getId(), t.getMessage());
    }
}

Keupayaan Mulakan Semula dan Repositori Kerja

Skip dan retry mengendalikan ralat dalam satu pelaksanaan; mulakan semula mengendalikan pelaksanaan yang gagal sepenuhnya. Oleh sebab Spring Batch menyimpan ExecutionContext setiap langkah serta bilangan bacaan/tulisan dalam repositori kerja, pelancaran semula JobInstance yang sama akan menyambung dari kelompok terakhir yang telah dilakukan, bukannya memproses semula semuanya.

Peraturan utama:

JobInstance dikenal pasti melalui parameter kerja pengenalpastian; gunakan semula parameter tersebut untuk memulakan semula, dan ubahnya untuk memulakan tika baharu.
Hanya kerja dalam keadaan bukan-COMPLETED (contohnya FAILED, STOPPED) boleh dimulakan semula.
Tandakan langkah dengan .allowStartIfComplete(true) untuk memaksa langkah yang telah selesai dijalankan semula ketika mula semula.
Hadkan percubaan semula dengan .startLimit(n) supaya langkah yang rosak tidak dilancarkan semula tanpa henti.

Menggabungkan Semuanya

Langkah tahan ralat yang mantap untuk persekitaran pengeluaran menggabungkan ketiga-tiga perkara: cuba semula kegagalan sementara dengan penangguhan, langkau data buruk yang bersifat pasti dalam had yang ditetapkan, audit setiap langkauan, dan bergantung pada repositori kerja untuk mula semula.

Perhatikan lapisannya: item yang gagal mula-mula dicuba semula; jika masih gagal dan pengecualian itu boleh dilangkau, item tersebut dilangkau (dan pendengar merekodkannya). Pengecualian boleh menjadi boleh dicuba semula dan boleh dilangkau pada masa yang sama — percubaan semula dihabiskan dahulu, kemudian langkauan digunakan.

return new StepBuilder("resilientImport", jobRepository)
        .<Customer, Customer>chunk(100, txManager)
        .reader(reader)
        .processor(processor)
        .writer(writer)
        .faultTolerant()
        // transient -> retry with backoff
        .retry(DeadlockLoserDataAccessException.class)
        .retryLimit(3)
        // deterministic bad data -> skip
        .skip(FlatFileParseException.class)
        .skip(ValidationException.class)
        .skipLimit(100)
        // audit + restart safety
        .listener(new LoggingSkipListener())
        .startLimit(3)
        .build();

Semakan Pantas

Uji pemahaman anda tentang semantik langkau berbanding percubaan semula.

Jawab dalam pelajaran interaktif

Ringkasan

Anda telah menjadikan langkah Spring Batch tahan terhadap kegagalan sementara dan pasti:

Dayakan toleransi dengan .faultTolerant() sebelum mengisytiharkan sebarang peraturan langkau/cuba semula.
Langkau data buruk yang pasti dengan .skip() + .skipLimit(); langkauan pemproses/penulis memerlukan pembatalan transaksi dan main semula item tunggal, jadi lakukan pengesahan lebih awal.
Cuba semula ralat sementara dengan .retry() + .retryLimit(), dan tambahkan penangguhan eksponen untuk mengurangkan perebutan.
Klasifikasikan dengan teliti: cuba semula yang sementara (kebuntuan, tamat masa kunci), langkau yang pasti (penghurai/pengesahan). Apabila pengecualian memenuhi kedua-duanya, percubaan semula dijalankan dahulu, kemudian langkauan.
Audit setiap langkauan dengan SkipListener supaya tiada apa-apa hilang secara senyap.
Mulakan semula tika yang gagal dari kelompok terakhir yang telah dilakukan melalui repositori kerja; kawal pelaksanaan semula dengan allowStartIfComplete dan startLimit.

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 “Toleransi Kerosakan, Langkau dan Dasar Percubaan Semula” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Panduan Lengkap Spring Boot 4, termasuk “Toleransi Kerosakan, Langkau dan Dasar Percubaan Semula”, 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 “Toleransi Kerosakan, Langkau dan Dasar Percubaan Semula”?

Konfigurasikan semantik langkau, percubaan semula dan mula semula untuk menjadikan kerja tahan terhadap ralat data sementara. 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 “Toleransi Kerosakan, Langkau dan Dasar Percubaan Semula” 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

Kerja, Langkah dan Model JobRepository
Aliran Pembaca-Pemproses-Penulis Berorientasikan Ketulan
Toleransi Kerosakan, Langkau dan Dasar Percubaan Semula
Pembahagian dan Pelaksanaan Langkah Selari

← Kembali ke Panduan Lengkap Spring Boot 4