Kafka integration basics in Spring Boot - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Apache Kafka used for in Spring Boot applications?

Apache Kafka is used as a messaging system to send and receive streams of data between different parts of an application or between different applications, enabling real-time data processing.

beginner

What annotation is used in Spring Boot to create a Kafka listener?

The @KafkaListener annotation is used to mark a method as a listener for Kafka messages on a specified topic.

beginner

How do you send a message to a Kafka topic in Spring Boot?

You use the KafkaTemplate class's send() method, specifying the topic name and the message to send.

beginner

What is the role of application.properties in Kafka integration with Spring Boot?

It holds configuration settings like Kafka server addresses, topic names, and consumer group IDs to connect and communicate with Kafka brokers.

intermediate

Why is it important to handle message serialization and deserialization in Kafka integration?

Because Kafka sends data as bytes, serialization converts objects to bytes when sending, and deserialization converts bytes back to objects when receiving, ensuring data is correctly understood.

Which Spring Boot annotation is used to listen to Kafka messages?

A @KafkaProducer

B @KafkaListener

C @KafkaConsumer

D @KafkaHandler

The @KafkaListener annotation marks a method to receive messages from Kafka topics.

What class do you use to send messages to Kafka in Spring Boot?

A KafkaTemplate

B KafkaSender

C KafkaProducerClient

D KafkaMessageSender

KafkaTemplate is the Spring Boot class used to send messages to Kafka topics.

Where do you configure Kafka server addresses in a Spring Boot app?

A application.yml

B bootstrap.properties

C KafkaConfig.java

D application.properties

Kafka server addresses and other settings are typically set in application.properties.

What does Kafka use to group consumers for load balancing?

A Broker ID

B Topic Partition

C Consumer Group ID

D Producer ID

Consumer Group ID groups consumers so they share message consumption.

Why must messages be serialized before sending to Kafka?

A To convert data into bytes for transmission

B To encrypt the message

C To compress the message

D To validate the message format

Serialization converts data into bytes so Kafka can transmit it.

Explain how to set up a basic Kafka producer and consumer in Spring Boot.

Think about how you send and listen to messages and where you put settings.

Describe why serialization and deserialization are important in Kafka integration.

Consider how data travels between apps in Kafka.

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