Stream-Verarbeitung mit KStream und KTable
Lernen Sie, KStream für unveränderliche Event-Streams und KTable für zustandsbehaftete, aktualisierbare Datensichten zu verwenden und dabei Vorgänge wie Filtern und Mapping auszuführen.
Stream-Verarbeitung mit KStream und KTable ist eine kostenlose Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
KStream & KTable Unveiled
Welcome! In Kafka Streams, KStream and KTable are your primary tools for processing data. They represent different views of your data in motion.
Think of them as two sides of the same coin, each suited for distinct stream processing tasks. Understanding their differences is key to building powerful stream applications.
KStream: Immutable Events
A KStream represents an infinite, immutable sequence of events. Each record in a KStream is a self-contained fact, an independent event that happened at a specific point in time.
- It's like a transaction log: once an event is added, it's never changed.
- Operations on a KStream produce new KStreams, leaving the original untouched.
- It's ideal for processing individual events like clicks, sensor readings, or log entries.
Filtering KStream Events
One common KStream operation is filtering. You can selectively keep records that match certain criteria, creating a new KStream with only the relevant events.
Here's a simple example filtering messages that contain 'hello'.
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.kstream.KStream;
import java.util.Properties;
public class Main {
public static void main(String[] args) {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "filter-app");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_BY_DEFAULT, Serdes.String().getClass());
props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_BY_DEFAULT, Serdes.String().getClass());
StreamsBuilder builder = new StreamsBuilder();
KStream<String, String> sourceStream = builder.stream("input-topic");
KStream<String, String> filteredStream = sourceStream.filter(
(key, value) -> value.contains("hello")
);
filteredStream.to("output-topic");
KafkaStreams streams = new KafkaStreams(builder.build(), props);
// In a real app, you'd start and manage this lifecycle:
// streams.start();
// Runtime.getRuntime().addShutdownHook(new Thread(streams::close));
System.out.println("KStream filter setup complete. Send 'hello world' to input-topic!");
}
}Transforming KStream Values
The mapValues operation transforms the value of each record in a KStream, producing a new KStream with the modified values. The key remains unchanged.
This is useful for cleaning data, changing formats, or enriching information without altering the message's key.
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.kstream.KStream;
import java.util.Properties;
public class Main {
public static void main(String[] args) {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "mapvalues-app");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_BY_DEFAULT, Serdes.String().getClass());
props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_BY_DEFAULT, Serdes.String().getClass());
StreamsBuilder builder = new StreamsBuilder();
KStream<String, String> sourceStream = builder.stream("input-topic");
KStream<String, String> uppercasedStream = sourceStream.mapValues(
value -> value.toUpperCase()
);
uppercasedStream.to("output-topic");
KafkaStreams streams = new KafkaStreams(builder.build(), props);
System.out.println("KStream mapValues setup complete. Send 'test' to input-topic!");
}
}KTable: A Materialized View
A KTable represents a changelog stream, where each record is an update to a specific key. It's essentially a materialized view of a table, reflecting the latest state for each key.
- It's like a database table: keys have associated values, and new records for a key overwrite previous ones.
- KTable is stateful, maintaining the latest value for each key over time.
- It's perfect for aggregating data, maintaining counts, or storing user profiles.
KTable's Stateful Nature
The core idea behind a KTable is that it keeps track of the latest value for each unique key. When a new record with an existing key arrives, the KTable updates its internal state.
This makes KTable ideal for scenarios where you care about the current state of an entity, rather than every single event that led to that state.
KStream to KTable: Counting
You can transform a KStream into a KTable, typically to perform aggregations. A common example is counting occurrences of keys using groupByKey().count().
Each time a message arrives, the count for its key is updated, and the KTable emits the new total.
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.kstream.KStream;
import org.apache.kafka.streams.kstream.KTable;
import org.apache.kafka.streams.kstream.Materialized;
import java.util.Properties;
public class Main {
public static void main(String[] args) {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "kstream-to-ktable-app");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_BY_DEFAULT, Serdes.String().getClass());
props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_BY_DEFAULT, Serdes.String().getClass());
StreamsBuilder builder = new StreamsBuilder();
KStream<String, String> sourceStream = builder.stream("input-topic");
KTable<String, Long> wordCounts = sourceStream
.groupByKey() // Group by the existing key
.count(Materialized.as("counts-store")); // Count occurrences, store in state
wordCounts.toStream().to("output-topic"); // Convert back to stream to send out
KafkaStreams streams = new KafkaStreams(builder.build(), props);
System.out.println("KStream to KTable count setup. Send 'word' with key 'A' to input-topic!");
}
}KTable for Aggregation
KTables are excellent for continuous aggregation. Beyond simple counts, you can use operations like aggregate to maintain sums, averages, or custom aggregates over time.
This allows your application to always have an up-to-date summary of data for specific keys.
When to Use Which?
The choice between KStream and KTable depends on your processing needs:
- Use KStream when you need to process individual events, react to every occurrence, or build a pipeline of transformations that don't depend on historical state. Think real-time alerts or event logging.
- Use KTable when you need to maintain a current state, aggregate data over time, or join with other data sources based on the latest value. Think user profiles, stock prices, or aggregated metrics.
KStream vs. KTable Check
You've learned about KStream and KTable. Let's test your understanding.
KStream & KTable Recap
Great job! You've explored the core differences and uses of KStream and KTable.
- KStream handles individual, immutable events, perfect for event-by-event processing.
- KTable maintains a materialized view, tracking the latest state for each key, ideal for aggregations and stateful processing.
These two primitives are the foundation for building powerful and flexible stream processing applications with Kafka Streams.
Lerne Advanced Spring Boot 4: Event-Driven Architecture (Kafka) mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 12
- Lektionen
- 48
Häufig gestellte Fragen
Ist die Lektion „Stream-Verarbeitung mit KStream und KTable“ kostenlos?
Ja — der vollständige Text von „Stream-Verarbeitung mit KStream und KTable“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Stream-Verarbeitung mit KStream und KTable“?
Lernen Sie, KStream für unveränderliche Event-Streams und KTable für zustandsbehaftete, aktualisierbare Datensichten zu verwenden und dabei Vorgänge wie Filtern und Mapping auszuführen. Du übst Advanced Spring Boot 4: Event-Driven Architecture (Kafka) mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Advanced Spring Boot 4: Event-Driven Architecture (Kafka) zu starten?
Keine Vorkenntnisse erforderlich. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Stream-Verarbeitung mit KStream und KTable“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Lektion Code schreiben und ausführen?
Ja. Jede Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Einführung in Kafka Streams
- Stream-Verarbeitung mit KStream und KTable
- Eine einfache Stream-Anwendung erstellen
- Windowing und zustandsbehaftete Aggregationen in Kafka Streams