What is KafkaTemplate and how do you use it to send a message to a Kafka topic in Spring?
answer
- thin wrapper over native KafkaProducer
- needs a ProducerFactory
- send(topic, key, value) -> CompletableFuture<SendResult>
- Boot auto-configures from spring.kafka.*
- thread-safe singleton
basics
~10 sKafkaTemplate is Spring's helper for producing messages. You inject it and call template.send("topic", key, value). Spring Boot auto-configures it from application.properties, so you just autowire and send.
solid answer
~30 sKafkaTemplate<K,V> is Spring for Apache Kafka's central producer abstraction — a thin, thread-safe wrapper over the native Kafka Producer. Spring Boot auto-configures a bean when spring-kafka is on the classpath and spring.kafka.* properties are set, wiring in a ProducerFactory. You inject it and call send(topic, value), send(topic, key, value), or send(ProducerRecord). It serializes the key/value with the configured serializers, hands the record to the underlying producer's send, and returns a CompletableFuture<SendResult<K,V>> for the async result. You can also set a defaultTopic. It centralizes producer config (bootstrap servers, serializers, acks) so business code just calls send.
code
java · 21 lines@Service
public class OrderProducer {
private final KafkaTemplate<String, String> kafkaTemplate;
public OrderProducer(KafkaTemplate<String, String> kafkaTemplate) {
this.kafkaTemplate = kafkaTemplate;
}
public void publish(String orderId, String payload) {
// key = orderId ensures per-order ordering on one partition
kafkaTemplate.send("orders", orderId, payload);
}
}
// application.yml
// spring:
// kafka:
// bootstrap-servers: localhost:9092
// producer:
// key-serializer: org.apache.kafka.common.serialization.StringSerializer
// value-serializer: org.apache.kafka.common.serialization.StringSerializergo deeper
Know it's the Spring class for sending, that you inject it and call send(topic, key, value), and that Boot auto-configures it.
Explain the ProducerFactory relationship, the send overloads, and that it returns a future.
Discuss thread-safety, serializer wiring, defaultTopic, and that failures surface via the future not an exception.
Frame it as a thin managed wrapper; reason about shared-producer semantics, config centralization, and where transactions/idempotence plug in via the factory.
**KafkaTemplate** (`org.springframework.kafka.core.KafkaTemplate<K,V>`) is the producer-side entry point of the *Spring for Apache Kafka* project. Kafka's own client library gives you a low-level `org.apache.kafka.clients.producer.KafkaProducer` that you must construct, configure, and close yourself. KafkaTemplate wraps that producer and gives it a Spring flavor: it's a managed bean, it's thread-safe, and it removes boilerplate. **How it gets created.** KafkaTemplate needs a `ProducerFactory<K,V>`, which knows how to create the underlying Kafka `Producer` (bootstrap servers, key/value serializers, acks, etc.). With Spring Boot, adding the `spring-kafka` dependency and setting `spring.kafka.bootstrap-servers`, `spring.kafka.producer.key-serializer`, and `spring.kafka.producer.value-serializer` in `application.yml` triggers auto-configuration that creates both a `DefaultKafkaProducerFactory` and a `KafkaTemplate` bean for you. Without Boot you declare these `@Bean`s yourself. **Sending.** The core overloads are: - `send(String topic, V data)` — value only; key is null. - `send(String topic, K key, V data)` — key + value (key drives partitioning). - `send(String topic, Integer partition, K key, V data)` — explicit partition. - `send(ProducerRecord<K,V> record)` — full control including headers and timestamp. - `sendDefault(...)` — uses the `defaultTopic` configured on the template. Every `send` is **asynchronous**: it returns a `CompletableFuture<SendResult<K,V>>` that completes when the broker acknowledges (or fails). The record is placed into the producer's in-memory batch buffer and flushed by a background I/O thread. **Terms defined.** - *Serializer*: converts your K/V objects to `byte[]` for the wire (e.g. `StringSerializer`, `JsonSerializer`). - *ProducerRecord*: the unit sent to Kafka — topic, optional partition, optional key, value, headers, timestamp. - *SendResult*: what you get back on success — the original `ProducerRecord` plus `RecordMetadata` (topic, partition, offset, timestamp) assigned by the broker. **When to use.** Any time application code needs to publish to Kafka. It's the standard, and you almost never touch the raw `KafkaProducer`. **Gotchas.** (1) send() does *not* throw on delivery failure synchronously — you must handle the returned future or you'll silently lose errors. (2) The template is thread-safe and meant to be a singleton — don't create one per request. (3) It only *produces*; consuming is a separate concern (`@KafkaListener` / `KafkaTemplate` is not for reading).
- Does send() block until the broker acknowledges the message?No. send() is asynchronous — it buffers the record and returns a CompletableFuture<SendResult> immediately. It completes later on the producer I/O thread. To block you'd call .get() on the future (with the risk of blocking the caller).
- Where does KafkaTemplate get its configuration from?From its ProducerFactory (usually DefaultKafkaProducerFactory), which holds the producer config map — bootstrap servers, serializers, acks, etc. Spring Boot builds it from spring.kafka.producer.* properties.
saying these in an interview costs you the question
- Thinking send() blocks until acknowledged / is synchronous by default
- Creating a new KafkaTemplate per request instead of reusing the singleton bean
- Believing KafkaTemplate is also used for consuming messages
- Assuming a delivery error is thrown from send() rather than surfaced via the returned future