0Pricing
Advanced Spring Boot 4: Event-Driven Architecture (Kafka) · Lesson

Building a Simple Stream Application

Develop a basic Spring Boot application that utilizes Kafka Streams to process and transform events in real-time.

Building a Simple Stream Application is a free Advanced Spring Boot 4: Event-Driven Architecture (Kafka) lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Advanced Spring Boot 4: Event-Driven Architecture (Kafka) learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Your First Stream App

Welcome! In this lesson, we'll build a basic Spring Boot application that uses Kafka Streams to process events in real-time.

Our goal is simple: read messages from one Kafka topic, transform them, and write the results to another topic.

Spring Boot Project Setup

To begin, create a new Spring Boot project using Spring Initializr (start.spring.io).

Make sure to include these dependencies:

  • Spring Web (for a web context, though not strictly needed for streams)
  • Spring for Apache Kafka
  • Kafka Streams

Essential Stream Properties

Kafka Streams applications need some core properties to function. These are typically set in your application.properties or as a @Bean.

Key properties include:

  • application.id: A unique ID for your stream application.
  • bootstrap.servers: The Kafka broker addresses.
  • default.key.serde: Serializer/Deserializer for message keys.
  • default.value.serde: Serializer/Deserializer for message values.

Activating Stream Processing

For Spring Boot to recognize and manage your Kafka Streams application, you need to annotate your main application class with @EnableKafkaStreams.

This annotation tells Spring to look for stream topology definitions and manage their lifecycle.

package com.coddykit.kafka.streams;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.EnableKafkaStreams;

@SpringBootApplication
@EnableKafkaStreams // This enables Kafka Streams
public class SimpleStreamApplication {
    public static void main(String[] args) {
        SpringApplication.run(SimpleStreamApplication.class, args);
    }
}

Kafka Streams Configuration Bean

You can define a @Bean of type KafkaStreamsConfiguration to configure your stream application. This is often preferred over application.properties for more complex setups.

Here, we set essential properties like the application ID and Kafka broker address:

package com.coddykit.kafka.streams;

import org.apache.kafka.common.serialization.Serdes;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.KafkaStreamsDefaultConfiguration;
import org.springframework.kafka.config.KafkaStreamsConfiguration;

import java.util.HashMap;
import java.util.Map;

import static org.apache.kafka.streams.StreamsConfig.*;

@Configuration
public class KafkaStreamsConfig {

    @Bean(name = KafkaStreamsDefaultConfiguration.DEFAULT_STREAMS_CONFIG_BEAN_NAME)
    public KafkaStreamsConfiguration kStreamsConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(APPLICATION_ID_CONFIG, "my-uppercase-app");
        props.put(BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());
        props.put(DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());
        return new KafkaStreamsConfiguration(props);
    }
}

Building Your Stream Topology

The StreamsBuilder is your primary tool for defining the processing logic, or 'topology', of your Kafka Streams application.

Spring automatically injects an instance of StreamsBuilder into any @Bean method that defines your stream topology.

Defining the Stream Source

To start processing, you need to define where your stream gets its data. This is done by creating a KStream from an input topic.

The stream() method of StreamsBuilder does exactly this:

KStream<String, String> stream = kStreamBuilder.stream("input-topic");

Here, we're reading messages with String keys and String values from input-topic.

Transforming and Sending Data

Once you have a KStream, you can apply various transformations. For our simple app, we'll convert message values to uppercase using mapValues().

Finally, we'll send the transformed messages to an output-topic using the to() method. Try running this example!

package com.coddykit.kafka.streams;

import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.kstream.KStream;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.kafka.annotation.EnableKafkaStreams;
import org.springframework.kafka.annotation.KafkaStreamsDefaultConfiguration;
import org.springframework.kafka.config.KafkaStreamsConfiguration;

import java.util.HashMap;
import java.util.Map;

import static org.apache.kafka.streams.StreamsConfig.*;

@SpringBootApplication
@EnableKafkaStreams
public class SimpleStreamApplication {

    public static void main(String[] args) {
        System.out.println("Starting SimpleStreamApplication...");
        SpringApplication.run(SimpleStreamApplication.class, args);
    }

    @Bean(name = KafkaStreamsDefaultConfiguration.DEFAULT_STREAMS_CONFIG_BEAN_NAME)
    public KafkaStreamsConfiguration kStreamsConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(APPLICATION_ID_CONFIG, "uppercase-stream-app");
        props.put(BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());
        props.put(DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());
        return new KafkaStreamsConfiguration(props);
    }

    @Bean
    public KStream<String, String> kStream(StreamsBuilder kStreamBuilder) {
        KStream<String, String> stream = kStreamBuilder.stream("input-topic");

        stream.mapValues(String::toUpperCase)
              .to("output-topic");

        System.out.println("Kafka Stream 'uppercase-stream-app' topology built!");
        return stream;
    }
}

Testing Your Stream App

To see your application in action:

  1. Ensure a Kafka broker is running (e.g., via Docker).
  2. Run this Spring Boot application.
  3. Use a Kafka console producer to send messages to input-topic.
  4. Use a Kafka console consumer to read messages from output-topic and observe the uppercase transformation.

Stream Concepts Quick Check

Which of the following is the primary purpose of the application.id configuration in a Kafka Streams application?

Recap: Building Stream Apps

Great job! You've learned how to build a basic Kafka Streams application with Spring Boot:

  • Configured essential Kafka Streams properties.
  • Used @EnableKafkaStreams to activate stream processing.
  • Defined a stream topology using StreamsBuilder, including reading from a source topic, applying transformations, and writing to a sink topic.

This foundation will help you build more complex real-time data processing pipelines!

Frequently asked questions

Is the “Building a Simple Stream Application” lesson free?

Yes — the full text of “Building a Simple Stream Application” is free to read here on the web, and the Advanced Spring Boot 4: Event-Driven Architecture (Kafka) course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Advanced Spring Boot 4: Event-Driven Architecture (Kafka) course, upgrade to CoddyKit PRO.

What will I learn in “Building a Simple Stream Application”?

Develop a basic Spring Boot application that utilizes Kafka Streams to process and transform events in real-time. You practise Advanced Spring Boot 4: Event-Driven Architecture (Kafka) with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Advanced Spring Boot 4: Event-Driven Architecture (Kafka)?

No prior experience is required. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Building a Simple Stream Application” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Advanced Spring Boot 4: Event-Driven Architecture (Kafka) lesson?

Yes. Every Advanced Spring Boot 4: Event-Driven Architecture (Kafka) lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Introduction to Kafka Streams
  2. Stream Processing with KStream & KTable
  3. Building a Simple Stream Application
  4. Windowing and Stateful Aggregations in Kafka Streams
← Back to Advanced Spring Boot 4: Event-Driven Architecture (Kafka)