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

Tworzenie prostej aplikacji strumieniowej

Opracuj podstawową aplikację Spring Boot wykorzystującą Kafka Streams do przetwarzania i przekształcania zdarzeń w czasie rzeczywistym.

Tworzenie prostej aplikacji strumieniowej to bezpłatna lekcja Advanced Spring Boot 4: Event-Driven Architecture (Kafka) na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Advanced Spring Boot 4: Event-Driven Architecture (Kafka), a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Advanced Spring Boot 4: Event-Driven Architecture (Kafka) zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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!

Często zadawane pytania

Czy lekcja „Tworzenie prostej aplikacji strumieniowej” jest bezpłatna?

Tak — pełny tekst „Tworzenie prostej aplikacji strumieniowej” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Advanced Spring Boot 4: Event-Driven Architecture (Kafka), przejdź na CoddyKit PRO. Kurs Advanced Spring Boot 4: Event-Driven Architecture (Kafka) zawiera 4 lekcji w sumie.

Co nauczysz się w „Tworzenie prostej aplikacji strumieniowej”?

Opracuj podstawową aplikację Spring Boot wykorzystującą Kafka Streams do przetwarzania i przekształcania zdarzeń w czasie rzeczywistym. Ćwiczysz Advanced Spring Boot 4: Event-Driven Architecture (Kafka) z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Advanced Spring Boot 4: Event-Driven Architecture (Kafka)?

Nie wymagamy żadnego doświadczenia. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Tworzenie prostej aplikacji strumieniowej”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Advanced Spring Boot 4: Event-Driven Architecture (Kafka)?

Tak. Każda lekcja Advanced Spring Boot 4: Event-Driven Architecture (Kafka) zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Wprowadzenie do Kafka Streams
  2. Przetwarzanie strumieni za pomocą KStream i KTable
  3. Tworzenie prostej aplikacji strumieniowej
  4. Okna czasowe i agregacje stanowe w Kafka Streams
← Powrót do Advanced Spring Boot 4: Event-Driven Architecture (Kafka)