Advanced Spring Boot 4: Event-Driven Architecture (Kafka) · Pelajaran

Membangun Kontainer Listener Kafka

Buat metode @KafkaListener untuk secara otomatis menggunakan pesan dari topik tertentu dan mengonfigurasi propertinya.

Pelajaran 1 dari 411 langkah

Membangun Kontainer Listener Kafka adalah pelajaran Advanced Spring Boot 4: Event-Driven Architecture (Kafka) gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Advanced Spring Boot 4: Event-Driven Architecture (Kafka), dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Advanced Spring Boot 4: Event-Driven Architecture (Kafka) mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

Welcome to Kafka Consumers!

In event-driven systems, producers send events, and consumers react to them. Spring Boot makes it easy to build Kafka consumers.

We'll learn how to create methods that automatically listen for and process messages from Kafka topics using the @KafkaListener annotation.

The @KafkaListener Annotation

The @KafkaListener annotation is the core of consuming messages in Spring Boot. You place it on a method, telling Spring which Kafka topic(s) to listen to.

It automatically sets up the necessary infrastructure.
The method parameter receives the message payload.
You must specify a topics and groupId.

Basic Listener: String Messages

Let's create a simple Kafka listener that consumes plain string messages. Remember, you'd typically have Kafka dependencies and configuration in your Spring Boot project.

Here, my-topic is the Kafka topic, and my-group is the consumer group 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);
  }
}

Understanding Consumer Groups

The groupId property is crucial for Kafka consumers. It defines a group of consumers that work together to process messages from one or more topics.

Load Balancing: Messages from a topic are distributed among consumers in the same group.
Fault Tolerance: If a consumer fails, another in the group takes over its partitions.
Unique Processing: Each message is processed by only one consumer within a group.

Listening to Multiple Topics

A single @KafkaListener method can listen to multiple topics. You can specify them as an array of strings in the topics attribute.

This is useful when different topics carry related types of messages that can be handled by the same logic.

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);
  }
}

Receiving Custom Objects

Kafka messages often contain structured data, not just strings. Spring Kafka can automatically convert JSON or Avro messages into Java objects (POJOs).

You just need to define a POJO that matches the structure of your Kafka messages and use it as the method parameter.

Code: Custom Object Listener

Here's how to set up a listener for a custom MyEvent object. Spring Boot handles the deserialization, assuming you have the correct deserializer configured (e.g., JSON deserializer).

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);
  }
}

Accessing Message Metadata

Beyond the message payload, Kafka messages carry useful metadata like topic, partition, offset, and headers. You can access these in your listener method:

@Payload: The message body (default).
@Header: Access specific Kafka headers.
ConsumerRecord: The raw Kafka record, giving access to 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);
  }
}

Configuring Listener Properties

While @KafkaListener handles many defaults, you can customize consumer behavior. Properties like bootstrap.servers, auto.offset.reset, and key.deserializer are typically set in your application.properties or application.yml file.

Spring Boot automatically picks up these configurations.
They apply to all @KafkaListeners unless overridden.

Test Your Kafka Listener Knowledge!

Which of the following statements about Spring Boot's @KafkaListener annotation is TRUE?

Jawab di pelajaran interaktif

Recap: Building Kafka Listeners

You've taken the first step into consuming Kafka messages with Spring Boot!

The @KafkaListener annotation simplifies consumer creation.
You specify topics and a groupId to organize consumers.
Listeners can handle String messages, custom objects, and access metadata.
Configuration is often managed through application.properties.

Next, we'll explore how consumer groups work in more detail to achieve scalable and fault-tolerant message processing!

Gratis untuk memulai

Belajar Advanced Spring Boot 4: Event-Driven Architecture (Kafka) dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 12
Pelajaran: 48

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membangun Kontainer Listener Kafka” gratis?

Ya — teks lengkap “Membangun Kontainer Listener Kafka” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Advanced Spring Boot 4: Event-Driven Architecture (Kafka), upgrade ke CoddyKit PRO. Kursus Advanced Spring Boot 4: Event-Driven Architecture (Kafka) mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membangun Kontainer Listener Kafka”?

Buat metode @KafkaListener untuk secara otomatis menggunakan pesan dari topik tertentu dan mengonfigurasi propertinya. Kamu berlatih Advanced Spring Boot 4: Event-Driven Architecture (Kafka) dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Advanced Spring Boot 4: Event-Driven Architecture (Kafka)?

Tidak diperlukan pengalaman sebelumnya. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Membangun Kontainer Listener Kafka” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Advanced Spring Boot 4: Event-Driven Architecture (Kafka) ini?

Ya. Setiap pelajaran Advanced Spring Boot 4: Event-Driven Architecture (Kafka) menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Advanced Spring Boot 4: Event-Driven Architecture (Kafka)