0Pricing
Advanced Spring Boot 4: Event-Driven Architecture (Kafka) · Leçon

Créer une application de flux simple

Développez une application Spring Boot de base qui utilise Kafka Streams pour traiter et transformer des événements en temps réel.

Créer une application de flux simple est une leçon Advanced Spring Boot 4: Event-Driven Architecture (Kafka) gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Advanced Spring Boot 4: Event-Driven Architecture (Kafka), et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Advanced Spring Boot 4: Event-Driven Architecture (Kafka) comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

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!

Questions Fréquemment Posées

La leçon « Créer une application de flux simple » est-elle gratuite ?

Oui — le texte complet de « Créer une application de flux simple » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Advanced Spring Boot 4: Event-Driven Architecture (Kafka), passe à CoddyKit PRO. Le cours Advanced Spring Boot 4: Event-Driven Architecture (Kafka) comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Créer une application de flux simple » ?

Développez une application Spring Boot de base qui utilise Kafka Streams pour traiter et transformer des événements en temps réel. Tu pratiques Advanced Spring Boot 4: Event-Driven Architecture (Kafka) avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Advanced Spring Boot 4: Event-Driven Architecture (Kafka) ?

Aucune expérience préalable n'est requise. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Créer une application de flux simple » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Advanced Spring Boot 4: Event-Driven Architecture (Kafka) ?

Oui. Chaque leçon Advanced Spring Boot 4: Event-Driven Architecture (Kafka) inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Introduction à Kafka Streams
  2. Traitement par flux avec KStream et KTable
  3. Créer une application de flux simple
  4. Fenêtrage et agrégations avec état dans Kafka Streams
← Retour à Advanced Spring Boot 4: Event-Driven Architecture (Kafka)