Bygga Kafka-listenercontainrar
Skapa @KafkaListener-metoder som automatiskt konsumerar meddelanden från angivna topics och konfigurera deras egenskaper.
Bygga Kafka-listenercontainrar är en gratis lektion i Avancerad Spring Boot 4: händelsestyrd arkitektur (Kafka) på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Avancerad Spring Boot 4: händelsestyrd arkitektur (Kafka), och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Avancerad Spring Boot 4: händelsestyrd arkitektur (Kafka) innehåller totalt 4 lektioner.
Välkommen till Kafka-konsumenter!
I händelsestyrda system skickar producenter händelser och konsumenter reagerar på dem. Spring Boot gör det enkelt att bygga Kafka-konsumenter.
Vi kommer att lära oss hur man skapar metoder som automatiskt lyssnar efter och bearbetar meddelanden från Kafka-ämnen med hjälp av annoteringen @KafkaListener.
Annoteringen @KafkaListener
Annoteringen @KafkaListener är central när Spring Boot ska konsumera meddelanden. Du placerar den på en metod och anger för Spring vilka Kafka-ämnen den ska lyssna på.
- Den konfigurerar automatiskt den nödvändiga infrastrukturen.
- Metodparametern tar emot meddelandets nyttolast.
- Du måste ange
topicsochgroupId.
Grundläggande lyssnare: strängmeddelanden
Låt oss skapa en enkel Kafka-lyssnare som konsumerar vanliga strängmeddelanden. Kom ihåg att du vanligtvis behöver ha Kafka-beroenden och konfiguration i ditt Spring Boot-projekt.
Här är my-topic Kafka-ämnet och my-group konsumentgruppens ID.
package com.example.kafkaconsumer;
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;
@SpringBootApplication
@EnableKafka
public class KafkaConsumerApplication {
public static void main(String[] args) {
// In a real app, SpringApplication.run() starts the context
// and registers the @KafkaListener methods.
System.out.println("Spring Boot Kafka Consumer App Started (simulated)");
// For a runnable snippet, we just show the listener logic.
// In a full app, this would run indefinitely, waiting for messages.
}
}
@Component
class MyStringListener {
@KafkaListener(topics = "my-topic", groupId = "my-group")
public void listen(String message) {
System.out.println("Received String: " + message);
}
}Förstå konsumentgrupper
Egenskapen groupId är avgörande för Kafka-konsumenter. Den definierar en grupp konsumenter som samarbetar för att bearbeta meddelanden från ett eller flera ämnen.
- Lastbalansering: Meddelanden från ett ämne fördelas mellan konsumenterna i samma grupp.
- Feltolerans: Om en konsument slutar fungera tar en annan konsument i gruppen över dess partitioner.
- Unik bearbetning: Varje meddelande bearbetas av endast en konsument inom en grupp.
Lyssna på flera ämnen
En enda metod med @KafkaListener kan lyssna på flera ämnen. Du kan ange dem som en strängarray i attributet topics.
Detta är användbart när olika ämnen innehåller relaterade typer av meddelanden som kan hanteras av samma logik.
package com.example.kafkaconsumer;
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;
@SpringBootApplication
@EnableKafka
public class KafkaConsumerApplication {
public static void main(String[] args) {
System.out.println("Spring Boot Kafka Consumer App Started (simulated)");
}
}
@Component
class MultiTopicListener {
@KafkaListener(topics = {"topic-a", "topic-b"}, groupId = "multi-group")
public void listenMultipleTopics(String message) {
System.out.println("Received from multiple topics: " + message);
}
}Ta emot anpassade objekt
Kafka-meddelanden innehåller ofta strukturerade data, inte bara strängar. Spring Kafka kan automatiskt konvertera JSON- eller Avro-meddelanden till Java-objekt (POJO:er).
Du behöver bara definiera en POJO som motsvarar strukturen hos dina Kafka-meddelanden och använda den som metodparameter.
Kod: Lyssnare för anpassade objekt
Så här konfigurerar du en lyssnare för ett anpassat MyEvent-objekt. Spring Boot hanterar deserialiseringen, förutsatt att du har konfigurerat rätt deserialiserare (till exempel en JSON-deserialiserare).
package com.example.kafkaconsumer;
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;
// A simple data class representing an event
class MyEvent {
private String id;
private String description;
// Getters and setters are essential for deserialization
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
@Override
public String toString() {
return "MyEvent{id='" + id + "', description='" + description + "'}";
}
}
@SpringBootApplication
@EnableKafka
public class KafkaConsumerApplication {
public static void main(String[] args) {
System.out.println("Spring Boot Kafka Consumer App Started (simulated)");
}
}
@Component
class MyObjectListener {
@KafkaListener(topics = "object-topic", groupId = "object-group")
public void listenObject(MyEvent event) {
System.out.println("Received object: " + event);
}
}Åtkomst till meddelandemetadata
Utöver meddelandets nyttolast innehåller Kafka-meddelanden användbara metadata, till exempel topic, partition, offset och headers. Du kan komma åt dessa i din lyssnarmetod:
@Payload: Meddelandets innehåll (standard).@Header: Åtkomst till specifika Kafka-headers.ConsumerRecord: Det råa Kafka-posten, som ger åtkomst till all metadata.
package com.example.kafkaconsumer;
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.messaging.handler.annotation.Header;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;
@SpringBootApplication
@EnableKafka
public class KafkaConsumerApplication {
public static void main(String[] args) {
System.out.println("Spring Boot Kafka Consumer App Started (simulated)");
}
}
@Component
class MyMetadataListener {
@KafkaListener(topics = "metadata-topic", groupId = "meta-group")
public void listenWithMetadata(
@Payload String message,
@Header("kafka_receivedTopic") String topic,
@Header("kafka_receivedPartitionId") int partition,
@Header("kafka_offset") long offset) {
System.out.println("Topic: " + topic + ", Partition: " + partition + ", Offset: " + offset);
System.out.println("Message: " + message);
}
}Konfigurera lyssnaregenskaper
Även om @KafkaListener hanterar många standardvärden kan du anpassa konsumentens beteende. Egenskaper som bootstrap.servers, auto.offset.reset och key.deserializer anges vanligtvis i filen application.properties eller application.yml.
- Spring Boot läser automatiskt in dessa konfigurationer.
- De gäller för alla
@KafkaListener, om de inte åsidosätts.
Testa dina kunskaper om Kafka-lyssnare!
Vilket av följande påståenden om Spring Boots annotering @KafkaListener är SANT?
Sammanfattning: Skapa Kafka-lyssnare
Du har tagit det första steget mot att konsumera Kafka-meddelanden med Spring Boot!
- Annoteringen
@KafkaListenerförenklar skapandet av konsumenter. - Du anger topics och ett
groupIdför att organisera konsumenterna. - Lyssnare kan hantera strängmeddelanden och anpassade objekt samt komma åt metadata.
- Konfigurationen hanteras ofta via
application.properties.
Härnäst ska vi gå igenom hur konsumentgrupper fungerar mer i detalj för att uppnå skalbar och feltålig meddelandebearbetning!
Lär dig Avancerad Spring Boot 4: händelsestyrd arkitektur (Kafka) med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Bygga Kafka-listenercontainrar” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Avancerad Spring Boot 4: händelsestyrd arkitektur (Kafka), inklusive ”Bygga Kafka-listenercontainrar”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Avancerad Spring Boot 4: händelsestyrd arkitektur (Kafka) innehåller totalt 4 lektioner.
Vad lär jag mig i ”Bygga Kafka-listenercontainrar”?
Skapa @KafkaListener-metoder som automatiskt konsumerar meddelanden från angivna topics och konfigurera deras egenskaper. Ni övar på Avancerad Spring Boot 4: händelsestyrd arkitektur (Kafka) med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Avancerad Spring Boot 4: händelsestyrd arkitektur (Kafka)?
Du behöver inga förkunskaper. Utbildningen i Avancerad Spring Boot 4: händelsestyrd arkitektur (Kafka) på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Bygga Kafka-listenercontainrar”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Avancerad Spring Boot 4: händelsestyrd arkitektur (Kafka)-lektionen?
Ja. Varje Avancerad Spring Boot 4: händelsestyrd arkitektur (Kafka)-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Bygga Kafka-listenercontainrar
- Hantera konsumentgrupper
- Deserialisering och meddelandekonvertering
- Batchkonsumtion och bekräftelselägen