Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka) · Pelajaran

Melakukan Komit Offset Secara Manual

Laksanakan kawalan manual terhadap komit offset untuk mendapatkan kawalan tepat ke atas jaminan pemprosesan mesej serta mengelakkan kehilangan atau penduaan data.

Pelajaran 1 daripada 412 langkah

Melakukan Komit Offset Secara Manual ialah pelajaran Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka) percuma di CoddyKit. Ini ialah pelajaran 1 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 Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka), dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka) merangkumi sejumlah 4 pelajaran.

Mengapa Commit Manual?

Dalam Kafka, offset menandakan mesej terakhir yang berjaya diproses oleh kumpulan pengguna daripada partisyen topik. Melakukan commit pada offset memberitahu Kafka: "Saya telah mengendalikan mesej sehingga titik ini."

Secara lalai, Spring Kafka menggunakan commit automatik, yang offsetnya dilakukan secara berkala di latar belakang. Walaupun mudah, kaedah ini kadangkala boleh menyebabkan kehilangan atau penduaan data jika aplikasi anda ranap ketika pemprosesan sedang berlangsung.

Commit offset secara manual memberikan kawalan tepat kepada anda, membolehkan anda menentukan masa sebenar offset ditandakan sebagai telah diproses. Hal ini penting untuk memastikan jaminan pemprosesan mesej.

Commit Automatik: Pandangan Ringkas

Dengan commit automatik, Kafka melakukan commit offset secara automatik pada selang masa tertentu (contohnya setiap 5 saat). Ini bermaksud:

Mesej diproses.
Offset dilakukan commit kemudian oleh Kafka.

Jika aplikasi anda memproses mesej tetapi ranap *sebelum* selang commit automatik Kafka berlalu, offset mesej itu mungkin belum dilakukan commit. Apabila aplikasi dimulakan semula, mesej tersebut akan dibaca dan diproses semula, lalu berpotensi menghasilkan pendua (pemprosesan sekurang-kurangnya sekali).

Beralih kepada Mod Manual

Untuk mengawal pengurusan offset, anda perlu melumpuhkan commit automatik dalam konfigurasi Kafka aplikasi Spring Boot anda. Hal ini biasanya dilakukan dengan menetapkan AckMode.

AckMode menentukan masa pengguna mengakui mesej. Untuk kawalan manual, kita akan menggunakan MANUAL_IMMEDIATE atau MANUAL.

Berikut ialah cara anda boleh mengkonfigurasikannya dalam application.properties:

spring.kafka.consumer.enable-auto-commit=false
spring.kafka.listener.ack-mode=MANUAL_IMMEDIATE

Objek Pengakuan

Apabila ack-mode ditetapkan kepada pilihan manual, kaedah @KafkaListener anda boleh menerima parameter tambahan: objek Acknowledgment.

Objek ini ialah antara muka terus anda untuk memberitahu Kafka bahawa anda telah berjaya memproses mesej (atau sekumpulan mesej) dan offsetnya kini boleh dilakukan commit.

Anda akan memanggil kaedah acknowledge() apabila sudah bersedia.

Contoh Commit Manual Asas

Mari lihat contoh mudah yang melakukan commit offset secara manual selepas setiap mesej diproses. Perhatikan parameter Acknowledgment acknowledgment.

Jalankan kod ini, kemudian hentikan dan mulakan semula aplikasi. Anda akan melihat bahawa mesej yang telah dilakukan commit tidak diproses semula.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;

@SpringBootApplication
public class ManualCommitApp implements CommandLineRunner {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public static void main(String[] args) {
        SpringApplication.run(ManualCommitApp.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println("Sending message...");
        kafkaTemplate.send("my-topic", "Hello CoddyKit!");
        System.out.println("Message sent.");
    }

    @KafkaListener(topics = "my-topic", groupId = "manual-group")
    public void listen(String message, Acknowledgment acknowledgment) {
        System.out.println("Received: " + message);
        // Simulate processing
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Processed: " + message + ", committing offset.");
        acknowledgment.acknowledge(); // Manual commit
    }
}

Mengkonfigurasi Contoh

Supaya contoh sebelumnya berfungsi, anda memerlukan fail src/main/resources/application.properties dengan butiran broker Kafka dan mod pengakuan manual:

spring.kafka.bootstrap-servers=localhost:9092 (atau broker Kafka anda)
spring.kafka.consumer.enable-auto-commit=false
spring.kafka.listener.ack-mode=MANUAL_IMMEDIATE
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer

Pastikan Kafka tempatan sedang berjalan!

Bila Perlu Mengakui?

Prinsip teras untuk melakukan commit secara manual ialah: lakukan commit hanya selepas logik perniagaan anda berjaya diselesaikan.

Selepas setiap mesej: Seperti yang ditunjukkan dalam contoh sebelumnya. Sesuai untuk kadar pemprosesan rendah atau mesej kritikal.
Selepas satu kelompok: Proses beberapa mesej, kemudian lakukan commit sekali untuk keseluruhan kelompok. Ini lebih cekap untuk kadar pemprosesan tinggi.
Selepas interaksi luaran: Jika anda menulis data ke pangkalan data, lakukan commit offset *hanya selepas* transaksi pangkalan data berjaya.

Pemilihan strategi yang betul bergantung pada keperluan aplikasi anda dari segi prestasi dan ketekalan data.

Pemprosesan Kelompok & Commit Manual

Apabila pendengar anda menggunakan satu kelompok mesej (contohnya, List<String>), anda hendaklah melakukan commit offset hanya selepas *semua* mesej dalam kelompok tersebut berjaya diproses. Objek Acknowledgment masih berfungsi untuk keseluruhan kelompok.

Ini sering digabungkan dengan AckMode.BATCH, walaupun MANUAL_IMMEDIATE juga berfungsi.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import java.util.List;

@SpringBootApplication
public class BatchManualCommitApp implements CommandLineRunner {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public static void main(String[] args) {
        SpringApplication.run(BatchManualCommitApp.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println("Sending 3 messages...");
        kafkaTemplate.send("my-batch-topic", "Batch Msg 1");
        kafkaTemplate.send("my-batch-topic", "Batch Msg 2");
        kafkaTemplate.send("my-batch-topic", "Batch Msg 3");
        System.out.println("Messages sent.");
    }

    // Ensure spring.kafka.listener.ack-mode=MANUAL_IMMEDIATE in properties
    @KafkaListener(topics = "my-batch-topic", groupId = "batch-manual-group")
    public void listenBatch(List<String> messages, Acknowledgment acknowledgment) {
        System.out.println("Received batch of " + messages.size() + " messages.");
        for (String msg : messages) {
            System.out.println("  Processing: " + msg);
            // Simulate processing each message in the batch
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        System.out.println("Finished processing batch. Committing offset.");
        acknowledgment.acknowledge(); // Commit once for the entire batch
    }
}

Mengendalikan Ralat & Memproses Semula

Apakah yang berlaku jika ralat berlaku semasa pemprosesan mesej *sebelum* acknowledgment.acknowledge() dipanggil?

Memandangkan offset belum dilakukan commit, Kafka menganggap mesej (atau kelompok) tersebut belum diproses. Apabila aplikasi dimulakan semula atau pengimbangan semula berlaku, pengguna akan mengambil semula dan memproses semula mesej tersebut. Inilah asas semantik pemprosesan sekurang-kurangnya sekali.

Walaupun ini menjamin tiada kehilangan data, logik pemprosesan mesej anda perlu idempoten, iaitu pemprosesan mesej yang sama beberapa kali memberikan kesan yang sama seperti memprosesnya sekali.

Pertukaran & Amalan Terbaik

Commit offset secara manual memberikan kawalan, tetapi disertai beberapa pertimbangan:

Overhed: Melakukan commit terlalu kerap boleh menambah overhed rangkaian dan broker Kafka.
Skop Pemprosesan Semula: Melakukan commit terlalu jarang bermakna lebih banyak mesej mungkin diproses semula jika berlaku kegagalan.
Keidempotenan: Sentiasa reka bentuk pengguna anda supaya idempoten apabila menggunakan commit manual bagi mengendalikan pendua yang mungkin berlaku dengan baik.
Pengendalian Ralat: Gabungkan commit manual dengan pengendalian pengecualian yang kukuh (contohnya, percubaan semula dan Topik Surat Mati) untuk mengurus kegagalan dengan berkesan.

Semakan Pantas: Commit Manual

Anda menggunakan commit offset secara manual dalam pengguna Spring Kafka anda. Jika ralat berlaku semasa memproses mesej dan kaedah acknowledgment.acknowledge() TIDAK dipanggil untuk mesej tersebut, apakah yang akan berlaku?

Jawab dalam pelajaran interaktif

Imbas Kembali: Kawalan Offset Manual

Kami telah meneroka commit offset secara manual, iaitu teknik berkuasa untuk mengawal pemprosesan mesej dengan tepat dalam Spring Kafka.

Teknik ini melumpuhkan commit automatik dan memberikan kawalan kepada anda.
Anda menggunakan objek Acknowledgment untuk melakukan commit offset secara jelas.
Commit hendaklah dilakukan hanya selepas pelaksanaan logik perniagaan berjaya.
Teknik ini membolehkan pemprosesan sekurang-kurangnya sekali, tetapi memerlukan pengguna yang idempoten.

Kawalan terperinci ini penting untuk membina aplikasi dipacu peristiwa yang kukuh dan boleh dipercayai.

Percuma untuk bermula

Pelajari Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka) 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: 12
Pelajaran: 48

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Melakukan Komit Offset Secara Manual” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka), termasuk “Melakukan Komit Offset Secara Manual”, 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 Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka) merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Melakukan Komit Offset Secara Manual”?

Laksanakan kawalan manual terhadap komit offset untuk mendapatkan kawalan tepat ke atas jaminan pemprosesan mesej serta mengelakkan kehilangan atau penduaan data. Anda berlatih Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka) 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 Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka)?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka) 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 1 daripada 4.

Berapa lamakah pelajaran “Melakukan Komit Offset Secara Manual” 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 Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka) ini?

Ya. Setiap pelajaran Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka) 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

Melakukan Komit Offset Secara Manual
Menjeda dan Menyambung Semula Pengguna
Keserentakan dan Pengurusan Utas
Pendengar Pengimbangan Semula dan Keahlian Statik

← Kembali ke Spring Boot 4 Lanjutan: Seni Bina Dipacu Peristiwa (Kafka)