Practice Now
Kafka Template
Spring Boot
Multiple Templates
Java Development
Application Design

Can we use multiple kafka template in spring boot?

System Design practice on Codemia

Work through 120+ system design problems with detailed solutions, from rate limiters to multi-region storage.

Practice system design
Kafka & StreamingJava

Introduction

Yes. Spring Boot can use multiple KafkaTemplate beans in the same application, and that is the normal approach when different topics, clusters, serializers, or reliability settings need separate producer configurations. The key is to define distinct ProducerFactory and KafkaTemplate beans and inject them with qualifiers.

When Multiple Templates Make Sense

You do not need multiple templates just because you publish to multiple topics. One KafkaTemplate can send to many topics if the producer settings are the same.

Multiple templates are useful when any of these differ:

  • bootstrap servers
  • key or value serializer
  • transactional settings
  • security configuration
  • producer tuning such as acks or compression

For example, a service might send plain text audit events to one cluster and Avro-encoded business events to another.

Define Separate Beans

The cleanest setup is to create one producer factory per configuration and one template per factory.

java
1import java.util.HashMap;
2import java.util.Map;
3import org.apache.kafka.clients.producer.ProducerConfig;
4import org.apache.kafka.common.serialization.StringSerializer;
5import org.springframework.context.annotation.Bean;
6import org.springframework.context.annotation.Configuration;
7import org.springframework.beans.factory.annotation.Qualifier;
8import org.springframework.kafka.core.DefaultKafkaProducerFactory;
9import org.springframework.kafka.core.KafkaTemplate;
10import org.springframework.kafka.core.ProducerFactory;
11import org.springframework.kafka.support.serializer.JsonSerializer;
12
13@Configuration
14public class KafkaProducerConfig {
15
16    @Bean
17    public ProducerFactory<String, String> textProducerFactory() {
18        Map<String, Object> props = new HashMap<>();
19        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
20        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
21        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
22        return new DefaultKafkaProducerFactory<>(props);
23    }
24
25    @Bean
26    public KafkaTemplate<String, String> textKafkaTemplate() {
27        return new KafkaTemplate<>(textProducerFactory());
28    }
29
30    @Bean
31    public ProducerFactory<String, OrderEvent> orderProducerFactory() {
32        Map<String, Object> props = new HashMap<>();
33        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9093");
34        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
35        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
36        return new DefaultKafkaProducerFactory<>(props);
37    }
38
39    @Bean
40    public KafkaTemplate<String, OrderEvent> orderKafkaTemplate() {
41        return new KafkaTemplate<>(orderProducerFactory());
42    }
43}

Now each template has its own producer settings and value type.

Inject the Right Template

Use @Qualifier so Spring knows which template you want.

java
1import org.springframework.beans.factory.annotation.Qualifier;
2import org.springframework.kafka.core.KafkaTemplate;
3import org.springframework.stereotype.Service;
4
5@Service
6public class EventPublisher {
7    private final KafkaTemplate<String, String> textKafkaTemplate;
8    private final KafkaTemplate<String, OrderEvent> orderKafkaTemplate;
9
10    public EventPublisher(
11            @Qualifier("textKafkaTemplate") KafkaTemplate<String, String> textKafkaTemplate,
12            @Qualifier("orderKafkaTemplate") KafkaTemplate<String, OrderEvent> orderKafkaTemplate) {
13        this.textKafkaTemplate = textKafkaTemplate;
14        this.orderKafkaTemplate = orderKafkaTemplate;
15    }
16
17    public void publishAudit(String message) {
18        textKafkaTemplate.send("audit-log", message);
19    }
20
21    public void publishOrder(OrderEvent event) {
22        orderKafkaTemplate.send("orders", event.orderId(), event);
23    }
24}
25
26record OrderEvent(String orderId, double total) {}

Without qualifiers, Spring may fail with a “multiple beans found” error.

Keep the Configuration Maintainable

For production systems, hard-coded server addresses are not ideal. A better pattern is to bind settings from application.yml into separate property classes. That keeps credentials and cluster endpoints out of the Java config and makes environment-specific deployment easier.

Even if you start with manual bean definitions, keep the separation clear: one logical producer configuration per use case.

It is also worth testing each template in isolation. A message that works through the text producer may still fail through the JSON producer because of serializer settings, headers, or topic-level expectations. Separate integration tests make those failures easier to localize.

Common Pitfalls

The biggest mistake is creating multiple templates when only the topic changes. That adds bean noise without solving a real problem.

Another mistake is reusing the wrong serializer. A template configured with StringSerializer for values cannot safely send JSON objects just because the generic type says it can.

Teams also forget qualifiers. Once two beans of the same type exist, constructor injection must identify the intended one explicitly.

Summary

  • Spring Boot can use multiple KafkaTemplate beans in one application.
  • Create separate ProducerFactory and KafkaTemplate beans for each producer configuration.
  • Use @Qualifier when injecting templates so Spring can resolve the correct bean.
  • Multiple templates are useful for different clusters, serializers, or producer settings, not just different topics.
  • Keep configuration externalized once the setup grows beyond a simple local example.
Related reading
Course
Beginner
27 lessons
10 hours
System Design Fundamentals

Build a strong foundation in designing scalable, reliable distributed systems.

View the course
Track what you have practised

A free account saves your progress, solutions and study plan across every problem on Codemia.

System Design practice on Codemia

Work through 120+ system design problems with detailed solutions, from rate limiters to multi-region storage.

Practice system design
Codemia
© 2026 Codemia
Resources
Legal
Social
All Rights Reserved.