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

Pemrosesan Aliran dengan KStream & KTable

Pelajari cara menggunakan KStream untuk aliran peristiwa yang tidak dapat diubah dan KTable untuk tampilan data yang memiliki status serta dapat diperbarui, dengan melakukan operasi seperti penyaringan dan pemetaan.

Pemrosesan Aliran dengan KStream & KTable adalah pelajaran Advanced Spring Boot 4: Event-Driven Architecture (Kafka) gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Advanced Spring Boot 4: Event-Driven Architecture (Kafka), dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Advanced Spring Boot 4: Event-Driven Architecture (Kafka) mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pemrosesan Aliran dengan KStream & KTable” gratis?

Ya — teks lengkap “Pemrosesan Aliran dengan KStream & KTable” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Advanced Spring Boot 4: Event-Driven Architecture (Kafka), upgrade ke CoddyKit PRO. Kursus Advanced Spring Boot 4: Event-Driven Architecture (Kafka) mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pemrosesan Aliran dengan KStream & KTable”?

Pelajari cara menggunakan KStream untuk aliran peristiwa yang tidak dapat diubah dan KTable untuk tampilan data yang memiliki status serta dapat diperbarui, dengan melakukan operasi seperti penyaring… Kamu berlatih Advanced Spring Boot 4: Event-Driven Architecture (Kafka) dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Advanced Spring Boot 4: Event-Driven Architecture (Kafka)?

Tidak diperlukan pengalaman sebelumnya. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Pemrosesan Aliran dengan KStream & KTable” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Advanced Spring Boot 4: Event-Driven Architecture (Kafka) ini?

Ya. Setiap pelajaran Advanced Spring Boot 4: Event-Driven Architecture (Kafka) menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Pengantar Kafka Streams
  2. Pemrosesan Aliran dengan KStream & KTable
  3. Membangun Aplikasi Aliran Sederhana
  4. Windowing dan Agregasi Berstatus di Kafka Streams
← Kembali ke Advanced Spring Boot 4: Event-Driven Architecture (Kafka)