Panduan Lengkap Spring Boot 4 · Pelajaran

Aliran Pembaca-Pemproses-Penulis Berorientasikan Ketulan

Sambungkan komponen ItemReader, ItemProcessor dan ItemWriter untuk pemprosesan ketulan yang boleh diskalakan.

Pelajaran 2 daripada 413 langkah

Aliran Pembaca-Pemproses-Penulis Berorientasikan Ketulan ialah pelajaran Panduan Lengkap Spring Boot 4 percuma di CoddyKit. Ini ialah pelajaran 2 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 Pemprosesan Berorientasikan Kelompok?

Spring Batch membaca, memproses dan menulis data dalam kelompok, bukannya satu rekod pada satu masa. Kelompok ialah bilangan item yang boleh dikonfigurasi (commit-interval) dan dikendalikan dalam satu transaksi.

Baca N item satu demi satu dengan ItemReader.
Proses setiap item dengan ItemProcessor.
Tulis seluruh kelompok yang mengandungi N item sekali gus dengan ItemWriter.

Penulisan secara pukal dan commit bagi setiap kelompok membolehkan job kelompok diskalakan sehingga jutaan baris tanpa menghabiskan memori.

Tiga Antara Muka Teras

Setiap step kelompok dibina daripada tiga antara muka dengan satu method. Memahami kontraknya ialah asas keseluruhan corak ini.

ItemReader<I> → I read() mengembalikan item seterusnya, atau null apabila input telah habis.
ItemProcessor<I, O> → O process(I item) mengubah input menjadi output; pengembalian null akan menapis keluar item tersebut.
ItemWriter<O> → void write(Chunk<? extends O> chunk) menyimpan kelompok yang telah dikumpulkan.

public interface ItemReader<I> {
    I read() throws Exception; // null = end of input
}

public interface ItemProcessor<I, O> {
    O process(I item) throws Exception; // null = filter
}

public interface ItemWriter<O> {
    void write(Chunk<? extends O> chunk) throws Exception;
}

Menentukan Jenis Domain

Step kelompok mengalirkan data yang ditaip daripada pembaca kepada pemproses dan seterusnya kepada penulis. Mari kita modelkan input dan output yang ringkas. Pembaca menghasilkan rekod Customer mentah dan penulis menyimpan rekod yang telah dinormalkan.

Penggunaan record Java menjadikan jenis nilai tidak boleh ubah ini ringkas. Petikan kod ini ialah Java biasa tanpa rangka kerja, jadi ia boleh dijalankan secara kendiri.

public class DomainDemo {
    record Customer(String name, String email) {}

    public static void main(String[] args) {
        Customer c = new Customer("  Ada ", "ADA@MAIL.COM");
        Customer normalized = new Customer(
                c.name().trim(),
                c.email().toLowerCase());
        System.out.println(normalized);
    }
}

Membina ItemReader

Untuk input pangkalan data, JdbcCursorItemReader menstrim baris satu demi satu supaya penggunaan memori kekal rendah. Anda memberikannya DataSource, pertanyaan SQL dan RowMapper untuk menukar setiap baris kepada objek domain.

Spring Batch memanggil read() berulang kali sehingga ia mengembalikan null, sambil menggerakkan kursor setiap kali.

@Bean
public JdbcCursorItemReader<Customer> reader(DataSource dataSource) {
    return new JdbcCursorItemReaderBuilder<Customer>()
            .name("customerReader")
            .dataSource(dataSource)
            .sql("SELECT name, email FROM customers WHERE active = true")
            .rowMapper((rs, rowNum) ->
                    new Customer(rs.getString("name"), rs.getString("email")))
            .build();
}

Membina ItemProcessor

Pemproses ialah tempat logik perniagaan dilaksanakan: pengesahan, pengayaan, transformasi atau penapisan. Jenis input dan outputnya boleh berbeza.

Kembalikan objek yang telah diubah untuk meneruskannya ke komponen seterusnya.
Kembalikan null untuk melangkau item tersebut sepenuhnya — item itu tidak akan sampai kepada penulis.

Pastikan pemproses tidak mempunyai keadaan dan bersifat idempoten supaya ia berfungsi dengan betul apabila kelompok dicuba semula.

@Bean
public ItemProcessor<Customer, Customer> processor() {
    return customer -> {
        if (customer.email() == null || !customer.email().contains("@")) {
            return null; // filter invalid records out of the chunk
        }
        return new Customer(
                customer.name().trim(),
                customer.email().toLowerCase());
    };
}

Membina ItemWriter

Penulis menerima seluruh kelompok yang telah diproses sekali gus melalui Chunk<O>. Penulisan secara pukal — satu INSERT berkelompok bagi setiap kelompok dan bukannya satu bagi setiap baris — ialah peningkatan prestasi yang utama.

JdbcBatchItemWriter menggunakan pernyataan SQL berparameter dan sumber parameter sifat bean untuk memetakan medan secara automatik.

@Bean
public JdbcBatchItemWriter<Customer> writer(DataSource dataSource) {
    return new JdbcBatchItemWriterBuilder<Customer>()
            .dataSource(dataSource)
            .sql("INSERT INTO customers_clean (name, email) VALUES (:name, :email)")
            .beanMapped()
            .build();
}

Menyambungkan Step Kelompok

Satu Step menghubungkan ketiga-tiga komponen. Jenis generik <Customer, Customer> mengisytiharkan input dan output kelompok, manakala integer itu ialah selang commit.

Dengan saiz kelompok 100, Spring Batch membaca 100 item, memproses setiap satunya, kemudian menulis semua item yang kekal dalam satu transaksi sebelum melakukan commit.

@Bean
public Step chunkStep(JobRepository jobRepository,
                      PlatformTransactionManager txManager,
                      ItemReader<Customer> reader,
                      ItemProcessor<Customer, Customer> processor,
                      ItemWriter<Customer> writer) {
    return new StepBuilder("chunkStep", jobRepository)
            .<Customer, Customer>chunk(100, txManager)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .build();
}

Menyusun Job

Satu Job ialah set step yang tersusun. Untuk satu step kelompok, job itu hanya bermula dengannya. Spring Boot mengesan bean Job secara automatik dan menjalankannya semasa permulaan.

JobRepository merekodkan metadata pelaksanaan — status, bilangan bacaan/tulisan dan kedudukan commit terakhir — sekali gus membolehkan pelaksanaan dimulakan semula.

@Bean
public Job importCustomersJob(JobRepository jobRepository, Step chunkStep) {
    return new JobBuilder("importCustomersJob", jobRepository)
            .start(chunkStep)
            .build();
}

Memilih Saiz Kelompok

Selang commit ialah tuil penalaan, bukannya nombor ajaib.

Terlalu kecil (contohnya 1): satu transaksi bagi setiap baris — kos overhed commit tinggi dan perlahan.
Terlalu besar (contohnya 100,000): transaksi lebih besar, serta lebih banyak memori dan kos buat asal jika kelompok gagal.
Titik optimum lazim: 100–1000, dilaraskan dengan mengukur daya pemprosesan berdasarkan pangkalan data dan saiz baris anda.

Ingat: item yang gagal akan membuat asal seluruh kelompok, jadi kelompok yang lebih besar bermakna lebih banyak kerja perlu diulangi apabila berlaku kegagalan.

Toleransi Kegagalan: Langkau dan Cuba Semula

Input sebenar tidak sempurna. Balut step dengan .faultTolerant() untuk meneruskan pemprosesan walaupun berlaku kegagalan terpencil.

.skip(...) — benarkan sehingga skipLimit item bermasalah tanpa menggagalkan job.
.retry(...) — cuba semula ralat sementara (contohnya kebuntuan) sehingga retryLimit kali sebelum berputus asa.

Semasa langkau atau cuba semula, Spring Batch mengimbas semula kelompok item demi item untuk mengasingkan rekod yang bermasalah.

@Bean
public Step faultTolerantStep(JobRepository jobRepository,
                              PlatformTransactionManager txManager,
                              ItemReader<Customer> reader,
                              ItemProcessor<Customer, Customer> processor,
                              ItemWriter<Customer> writer) {
    return new StepBuilder("ftStep", jobRepository)
            .<Customer, Customer>chunk(100, txManager)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .faultTolerant()
            .skip(FlatFileParseException.class)
            .skipLimit(20)
            .retry(DeadlockLoserDataAccessException.class)
            .retryLimit(3)
            .build();
}

Kitar Hayat Kelompok Mengikut Turutan

Apabila digabungkan, setiap kelompok mengikuti gelung yang sama dalam satu transaksi:

1. Baca: panggil read() berulang kali sehingga item sebanyak saiz kelompok disimpan dalam penimbal (atau null menandakan input telah habis).
2. Proses: panggil process() pada setiap item; nilai null ditapis keluar.
3. Tulis: hantarkan item yang kekal sebagai satu Chunk kepada write().
4. Commit: lakukan commit transaksi dan rekodkan kemajuan dalam JobRepository.

Kemudian gelung berulang untuk kelompok seterusnya sehingga pembaca kehabisan input.

Semakan Ringkas

Uji pemahaman anda tentang saluran kelompok.

Jawab dalam pelajaran interaktif

Rumusan

Anda telah menyambungkan aliran lengkap berorientasikan kelompok dalam Spring Batch:

ItemReader menstrim input satu item pada satu masa dan mengembalikan null pada penghujung.
ItemProcessor mengubah atau menapis item; null akan menggugurkan item.
ItemWriter menyimpan seluruh kelompok secara pukal untuk meningkatkan prestasi.
Step mengikat kesemuanya dengan selang commit chunk(size, txManager), manakala Job menyelaraskan step tersebut.
Laraskan saiz kelompok untuk daya pemprosesan dan tambahkan .faultTolerant() dengan langkau/cuba semula untuk saluran yang tahan gangguan.

Gelung baca-proses-tulis ini, yang melakukan commit bagi setiap kelompok, ialah tulang belakang pemprosesan kelompok yang boleh diskalakan.

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 “Aliran Pembaca-Pemproses-Penulis Berorientasikan Ketulan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Panduan Lengkap Spring Boot 4, termasuk “Aliran Pembaca-Pemproses-Penulis Berorientasikan Ketulan”, 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 “Aliran Pembaca-Pemproses-Penulis Berorientasikan Ketulan”?

Sambungkan komponen ItemReader, ItemProcessor dan ItemWriter untuk pemprosesan ketulan yang boleh diskalakan. 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 2 daripada 4.

Berapa lamakah pelajaran “Aliran Pembaca-Pemproses-Penulis Berorientasikan Ketulan” 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