Kafka integration basics in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a Kafka topic bean in Spring Boot.

Spring Boot

import org.apache.kafka.clients.admin.NewTopic;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class KafkaTopicConfig {

    @Bean
    public NewTopic [1]() {
        return new NewTopic("my_topic", 1, (short) 1);
    }
}

Drag options to blanks, or click blank then click option'

AtopicBean

BcreateTopic

CnewTopic

DkafkaTopic

Attempts:

3 left

💡 Hint

Common Mistakes

Using a method name that does not clearly indicate it creates a topic.

Not annotating the method with @Bean.

The method name defining the Kafka topic bean can be any valid method name, but createTopic is a common and clear choice.

2fill in blank

medium

Complete the code to send a message to a Kafka topic using KafkaTemplate.

Spring Boot

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class ProducerService {

    private final KafkaTemplate<String, String> kafkaTemplate;

    public ProducerService(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public void sendMessage(String message) {
        kafkaTemplate.[1]("my_topic", message);
    }
}

Drag options to blanks, or click blank then click option'

Asend

Bpublish

Cproduce

Dwrite

Attempts:

3 left

💡 Hint

Common Mistakes

Using method names that do not exist on KafkaTemplate.

Confusing send with other verbs like publish or write.

The KafkaTemplate class uses the send method to send messages to a Kafka topic.

3fill in blank

hard

Fix the error in the Kafka listener method annotation to listen to the correct topic.

Spring Boot

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class ConsumerService {

    @KafkaListener(topics = "[1]", groupId = "group_id")
    public void consume(String message) {
        System.out.println("Received message: " + message);
    }
}

Drag options to blanks, or click blank then click option'

Amy_topic

Btopic1

Cdefault_topic

Dkafka_topic

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different topic name than the producer sends to.

Misspelling the topic name.

The listener must subscribe to the same topic name used when sending messages, which is my_topic.

4fill in blank

hard

Fill both blanks to configure Kafka consumer properties in application.yml.

Spring Boot

spring:
  kafka:
    consumer:
      bootstrap-servers: localhost:9092
      group-id: [1]
      key-deserializer: [2]

Drag options to blanks, or click blank then click option'

Amy_group

Borg.apache.kafka.common.serialization.StringDeserializer

Corg.apache.kafka.common.serialization.IntegerDeserializer

Ddefault_group

Attempts:

3 left

💡 Hint

Common Mistakes

Using default group id that may conflict with others.

Using wrong deserializer class for string keys.

The group-id should be a custom group name like my_group. The key-deserializer for string keys is org.apache.kafka.common.serialization.StringDeserializer.

5fill in blank

hard

Fill all three blanks to create a Kafka listener method that listens to two topics and uses a specific group id.

Spring Boot

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class MultiTopicConsumer {

    @KafkaListener(topics = {"[1]", "[2]"}, groupId = "[3]")
    public void listen(String message) {
        System.out.println("Message received: " + message);
    }
}

Drag options to blanks, or click blank then click option'

AtopicA

BtopicB

Cmulti_group

Ddefault_group

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same topic twice.

Using a default group id that conflicts with others.

The listener subscribes to topicA and topicB with the consumer group multi_group.

Practice

1. What is the primary purpose of @KafkaListener in a Spring Boot application?

easy

A. To listen and consume messages from a Kafka topic

B. To send messages to a Kafka topic

C. To configure Kafka broker settings

D. To create new Kafka topics automatically

Solution

1. Step 1: Understand the role of @KafkaListener

   This annotation marks a method to receive messages from a Kafka topic automatically.

2. Step 2: Differentiate sending and listening

   Sending messages is done with KafkaTemplate, not @KafkaListener.

3. Final Answer:

   To listen and consume messages from a Kafka topic -> Option A

4. Quick Check:

   @KafkaListener listens to topics [OK]

Hint: Remember: Listener receives, Template sends [OK]

Common Mistakes:

• Confusing @KafkaListener with KafkaTemplate
• Thinking @KafkaListener creates topics
• Assuming it configures Kafka brokers

2. Which of the following is the correct way to send a message to a Kafka topic using Spring Boot?

easy

A. new KafkaProducer().send("topicName", "message")

B. @KafkaListener(topic = "topicName")

C. KafkaTemplate.listen("topicName", "message")

D. kafkaTemplate.send("topicName", "message")

Solution

1. Step 1: Identify the sending method in Spring Boot

   Spring Boot uses KafkaTemplate with the send() method to send messages.

2. Step 2: Check syntax correctness

   kafkaTemplate.send("topicName", "message") is the correct syntax to send a message.

3. Final Answer:

   kafkaTemplate.send("topicName", "message") -> Option D

4. Quick Check:

   Sending uses KafkaTemplate.send() [OK]

Hint: Send messages with kafkaTemplate.send() [OK]

Common Mistakes:

• Using @KafkaListener to send messages
• Calling listen() instead of send()
• Instantiating KafkaProducer manually in Spring Boot

3. Given this Spring Boot Kafka listener method:

@KafkaListener(topics = "myTopic")
public void listen(String message) {
    System.out.println("Received: " + message);
}

What will be printed if a message "Hello Kafka" is sent to myTopic?

medium

A. Received: Hello Kafka

B. Hello Kafka

C. Received message: Hello Kafka

D. Error: No message received

Solution

1. Step 1: Analyze the listener method output

   The method prints "Received: " concatenated with the message string.

2. Step 2: Substitute the message value

   Message is "Hello Kafka", so output is "Received: Hello Kafka".

3. Final Answer:

   Received: Hello Kafka -> Option A

4. Quick Check:

   Prints "Received: " + message [OK]

Hint: Check print statement format carefully [OK]

Common Mistakes:

• Ignoring the prefix in the print statement
• Assuming only the message prints
• Confusing topic name with output

4. Consider this Spring Boot Kafka configuration snippet:

@Bean
public NewTopic topic() {
    return new NewTopic("testTopic", 1, (short) 1);
}

What is the likely error if the application fails to create the topic?

medium

A. Incorrect topic name format

B. Missing Kafka broker connection settings

C. NewTopic requires 3 parameters but only 2 provided

D. NewTopic bean must be annotated with @KafkaListener

Solution

1. Step 1: Understand NewTopic bean usage

   NewTopic defines topic name, partitions, and replication factor correctly here.

2. Step 2: Identify common cause for topic creation failure

   Failure usually happens if Kafka broker connection settings are missing or incorrect.

3. Final Answer:

   Missing Kafka broker connection settings -> Option B

4. Quick Check:

   Broker settings needed for topic creation [OK]

Hint: Check Kafka broker config if topic creation fails [OK]

Common Mistakes:

• Thinking @KafkaListener is needed on NewTopic bean
• Assuming topic name format is invalid
• Miscounting NewTopic constructor parameters

5. You want to create a Spring Boot Kafka consumer that listens to two topics: topicA and topicB. Which of the following @KafkaListener annotations correctly achieves this?

hard

A. @KafkaListener(topics = "topicA, topicB")

B. @KafkaListener(topic = "topicA,topicB")

C. @KafkaListener(topics = {"topicA", "topicB"})

D. @KafkaListener(topics = ["topicA", "topicB"])

Solution

1. Step 1: Recall correct syntax for multiple topics

   Spring Boot expects an array of strings for multiple topics: topics = {"topicA", "topicB"}.

2. Step 2: Evaluate other options

   @KafkaListener(topic = "topicA,topicB") uses wrong attribute name and comma string, C uses string with comma but not array, D uses invalid syntax with square brackets.

3. Final Answer:

   @KafkaListener(topics = {"topicA", "topicB"}) -> Option C

4. Quick Check:

   Multiple topics require array syntax [OK]

Hint: Use curly braces for multiple topics in @KafkaListener [OK]

Common Mistakes:

• Using comma-separated string instead of array
• Wrong attribute name 'topic' instead of 'topics'
• Using square brackets instead of curly braces