Kafka integration basics in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when a Spring Boot Kafka listener receives a message?

Consider a Spring Boot Kafka listener configured to listen to topic "orders". When a message "Order123" is sent to this topic, what will the listener method print?

Spring Boot

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

@Component
public class OrderListener {

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

A Received: Order123

B No output, listener not triggered

C Received: null

D Order123

💡 Hint

The listener method prints a prefix before the message content.

The listener method prints "Received: " followed by the message content it receives from the Kafka topic.

📝 Syntax

intermediate

Which Kafka producer configuration property sets the Kafka server address?

In Spring Boot Kafka producer configuration, which property key correctly sets the Kafka broker address to localhost:9092?

A spring.kafka.producer.broker-address=localhost:9092

B spring.kafka.bootstrap-servers=localhost:9092

C spring.kafka.producer.server=localhost:9092

D spring.kafka.producer.bootstrap-servers=localhost:9092

💡 Hint

The property includes 'producer' and 'bootstrap-servers'.

The correct property to set Kafka broker address for producer is 'spring.kafka.producer.bootstrap-servers'.

🔧 Debug

advanced

Why does this Kafka listener fail to receive messages?

Given the following listener code, why does it not receive messages from the topic payments?

Spring Boot

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

@Component
public class PaymentListener {

    @KafkaListener(topic = "payments")
    public void listen(String message) {
        System.out.println("Payment received: " + message);
    }
}

A The listener method must return a value.

B The annotation property should be 'topics' not 'topic'.

C The class must implement an interface to receive messages.

D The method parameter type should be ConsumerRecord, not String.

💡 Hint

Check the spelling of the annotation property for topic subscription.

The @KafkaListener annotation requires the property 'topics' (plural) to specify the topic list. Using 'topic' causes the listener not to subscribe.

❓ state_output

advanced

What is the value of the message count after processing 3 messages?

A Spring Boot Kafka listener increments a counter each time it receives a message. After receiving 3 messages, what is the value of the counter?

Spring Boot

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

@Component
public class CountingListener {

    private int messageCount = 0;

    @KafkaListener(topics = "events")
    public void listen(String message) {
        messageCount++;
    }

    public int getMessageCount() {
        return messageCount;
    }
}

A 0

B 1

C 3

D Cannot determine without synchronization

💡 Hint

The counter increments once per message received.

Each message increments messageCount by 1. After 3 messages, messageCount is 3.

🧠 Conceptual

expert

Which option best describes the role of Kafka consumer groups in Spring Boot?

In Spring Boot Kafka integration, what is the main purpose of assigning consumers to the same consumer group?

A To allow multiple consumers to share the load by dividing topic partitions among them

B To ensure all consumers receive every message from the topic

C To enable consumers to produce messages to the same topic

D To prevent consumers from connecting to the Kafka broker simultaneously

💡 Hint

Think about how Kafka distributes messages to consumers in a group.

Consumers in the same group share partitions of a topic so messages are load balanced and processed once per 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