Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) · Les

Consumeruitzonderingen afhandelen

Ontdek verschillende strategieën om uitzonderingen die tijdens berichtverwerking in Kafka-listeners optreden op een nette manier af te handelen.

Les 1 van 411 stappen

Consumeruitzonderingen afhandelen is een gratis Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka)-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka). Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) bevat in totaal 4 lessen.

Waarom Kafka-fouten afhandelen?

Wanneer je Spring Boot Kafka-consumer berichten verwerkt, kan er van alles misgaan. Misschien is een bericht ongeldig of faalt een afhankelijkheid.

Gegevensintegriteit: Voorkom dat beschadigde gegevens je systeem beïnvloeden.
Stabiliteit van de applicatie: Voorkom dat consumers vastlopen of in oneindige verwerkingslussen terechtkomen.
Gebruikerservaring: Zorg voor een betrouwbare service door fouten zorgvuldig af te handelen.

Een goede foutafhandeling is essentieel voor het bouwen van robuuste gebeurtenisgestuurde applicaties.

Standaardgedrag van de consumer

Wanneer er standaard een exception optreedt binnen je @KafkaListener-method, probeert de container van Spring Kafka hetzelfde bericht onbeperkt opnieuw te verwerken.

Dit kan leiden tot:

Een oneindige lus die CPU-cycli verbruikt.
Blokkering van andere berichten in de partitie.
Volle logboeken met herhaalde foutmeldingen.

We hebben een strategie nodig om deze cyclus te doorbreken en fouten zorgvuldig af te handelen.

Eenvoudig try-catch-blok

De eenvoudigste manier om een oneindige verwerkingslus voor een specifiek bericht te voorkomen, is je verwerkingslogica rechtstreeks in je listener-method te plaatsen binnen een try-catch-blok.

Zo kun je de exception opvangen, loggen en de listener-method normaal laten eindigen, waardoor de offset wordt vastgelegd.

Voorbeeld van try-catch

Zo ziet een eenvoudige try-catch eruit binnen een Spring Boot Kafka-listener. Dit voorbeeld biedt een minimale Spring Boot-applicatiestructuur die kan worden gecompileerd.

package com.coddykit;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@SpringBootApplication
@EnableKafka // Enables Kafka listener processing
public class KafkaErrorHandlerApp {

    public static void main(String[] args) {
        SpringApplication.run(KafkaErrorHandlerApp.class, args);
        // In a real app, you'd have a Kafka broker running
        // and messages sent to "my-topic" for this listener.
    }

    @Component
    public static class MyKafkaConsumer {

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

        @KafkaListener(topics = "my-topic", groupId = "my-group", 
                       properties = "spring.kafka.consumer.auto-offset-reset=earliest")
        public void listen(String message) {
            try {
                log.info("Received message: {}", message);
                // Simulate processing logic that might fail
                if (message.contains("error")) {
                    throw new IllegalArgumentException("Processing error!");
                }
                log.info("Processed message successfully.");
            } catch (Exception e) {
                log.error("Error processing message: '{}'. Error: {}", 
                          message, e.getMessage());
                // When an error is caught here, the method completes normally,
                // and the offset is committed, effectively skipping this message.
            }
        }
    }
}

Wanneer gebruik je try-catch?

try-catch binnen de listener is geschikt voor:

Verwachte, herstelbare fouten: Bijvoorbeeld een specifiek probleem met de berichtindeling dat je kunt loggen en overslaan.
Afzonderlijke berichtfouten: Wanneer de fout in één bericht niet de hele consumer mag stilleggen.
Snelle oplossingen: Voor eenvoudige foutsituaties waarvoor afhandeling op frameworkniveau niet nodig is.

Voor bredere en consistentere foutafhandeling in meerdere listeners biedt Spring Kafka echter krachtigere mechanismen.

Kennismaking met foutafhandelaars van Spring Kafka

Spring Kafka biedt een speciale ErrorHandler-interface voor het afhandelen van exceptions die tijdens de berichtverwerking optreden op een hoger niveau, buiten je afzonderlijke listener-methoden.

Zo kun je fouten centraal beheren en geavanceerdere strategieën gebruiken dan met een eenvoudige try-catch.

Geconfigureerd op het niveau van de containerfabriek.
Van toepassing op alle listeners die deze fabriek gebruiken.
Biedt verschillende ingebouwde implementaties.

Een foutafhandelaar configureren

Je configureert een ErrorHandler door een instantie door te geven aan je ConcurrentKafkaListenerContainerFactory-bean. Deze fabriek is verantwoordelijk voor het maken van de listenercontainers.

Zo kun je een fabriek met een eenvoudige foutafhandelaar instellen:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.listener.SeekToCurrentErrorHandler;

@Configuration
public class KafkaConfig {

    // Assume consumerFactory is autowired or defined elsewhere.
    // In a Spring Boot app, it's typically auto-configured.
    private final ConsumerFactory<String, String> consumerFactory;

    public KafkaConfig(ConsumerFactory<String, String> consumerFactory) {
        this.consumerFactory = consumerFactory;
    }

    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, String> 
            kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = 
            new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory);
        
        // Set a basic error handler
        factory.setErrorHandler(new SeekToCurrentErrorHandler()); 
        // This handler prevents the consumer from getting stuck
        // on a single message by re-delivering it a few times.
        return factory;
    }
}

SeekToCurrentErrorHandler

De SeekToCurrentErrorHandler is een krachtige ingebouwde afhandelaar. Wanneer er een exception optreedt, zoekt deze de partitie terug naar de offset van het mislukte record.

Dit betekent dat hetzelfde bericht opnieuw wordt afgeleverd. Als het opnieuw mislukt, wordt er weer teruggezocht. Standaard wordt geprobeerd het bericht enkele keren opnieuw te verwerken voordat de afhandelaar het opgeeft en de offset voor dat record verderzet.

Dit werkt uitstekend bij tijdelijke fouten: de consumer kan zo voorbij een problematisch bericht gaan zonder onbeperkt vast te lopen.

Aangepaste foutafhandelingslogica

Voor zeer specifieke behoeften op het gebied van foutafhandeling kun je je eigen aangepaste ErrorHandler of ConsumerAwareErrorHandler implementeren. Zo krijg je volledige controle over wat er gebeurt wanneer een exception optreedt.

Loggen naar een specifiek systeem.
Aangepaste meldingen versturen, bijvoorbeeld via e-mail of Slack.
Berichten in een aangepaste 'foutenwachtrij' plaatsen, vóór DLT's.
Bepalen of de offset moet worden vastgelegd of het bericht opnieuw moet worden verwerkt.

Houd er rekening mee dat complexe logica voor opnieuw proberen en Dead Letter Topics (DLT's) in latere lessen wordt behandeld!

Korte controle: foutafhandeling

Stel je een Kafka-consumer voor die tijdens het verwerken van een bericht een exception tegenkomt. Wat is zonder expliciete foutafhandeling standaard waarschijnlijk het resultaat?

Beantwoord dit in de interactieve les

Samenvatting: exceptions van consumers afhandelen

In deze les hebben we fundamentele strategieën onderzocht voor het afhandelen van exceptions in Spring Boot Kafka-consumers:

Het standaardgedrag waarbij onbehandelde fouten oneindig opnieuw worden verwerkt.
try-catch-blokken gebruiken voor lokale foutafhandeling die specifiek is voor een bericht.
De ErrorHandler-interface van Spring Kafka introduceren voor centrale controle.
Een SeekToCurrentErrorHandler configureren om te voorkomen dat consumers vastlopen.
De flexibiliteit van aangepaste foutafhandelaars voor unieke vereisten.

Deze technieken zijn essentieel voor het bouwen van veerkrachtige Kafka-applicaties die zich na verwerkingsfouten zorgvuldig kunnen herstellen.

Gratis beginnen

Leer Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Consumeruitzonderingen afhandelen” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka), waaronder “Consumeruitzonderingen afhandelen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) bevat in totaal 4 lessen.

Wat leer ik in “Consumeruitzonderingen afhandelen”?

Ontdek verschillende strategieën om uitzonderingen die tijdens berichtverwerking in Kafka-listeners optreden op een nette manier af te handelen. Je oefent met Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) te beginnen?

Ervaring vooraf is niet nodig. Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Consumeruitzonderingen afhandelen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka)?

Ja. Elke les over Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka) bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Consumeruitzonderingen afhandelen
Retrymechanismen met Spring Retry
Dead-lettertopics (DLT) implementeren
Niet-blokkerende retries met retry topics

← Terug naar Geavanceerd Spring Boot 4: gebeurtenisgestuurde architectuur (Kafka)