Membangun Aplikasi Kafka Streams Sederhana
Buat aplikasi Kafka Streams pertama Anda untuk memproses data dari topik Kafka secara waktu nyata.
Membangun Aplikasi Kafka Streams Sederhana adalah pelajaran Apache Kafka & Stream Processing Fundamentals gratis di CoddyKit. Ini adalah pelajaran 1 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 Apache Kafka & Stream Processing Fundamentals, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Apache Kafka & Stream Processing Fundamentals mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
Welcome to Kafka Streams!
Ready to build real-time data processing apps? Kafka Streams is a client library for building applications and microservices that process data stored in Kafka.
It lets you write standard Java/Scala applications that leverage Kafka's power for stream processing. Think of it as a toolkit to transform, filter, and analyze data as it flows through Kafka.
The Power of Kafka Streams
Kafka Streams offers several key advantages for your real-time applications:
- Lightweight: It's just a library, no separate cluster needed.
- Fault-Tolerant: Automatically handles failures and data recovery.
- Scalable: Easily scales by adding more instances of your application.
- Exactly-Once Processing: Guarantees data is processed once, even with failures.
It's great for real-time analytics, data transformations, and event-driven microservices.
Setting Up Your Project
To start, you'll need to add the Kafka Streams library to your project. If you're using Maven, add this dependency to your pom.xml:
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-streams</artifactId>
<version>3.5.1</version>
</dependency>Core Component: StreamsBuilder
The StreamsBuilder is your main entry point for defining the stream processing topology. Think of it as the architect for your data flow.
You use it to create source streams, apply transformations, and define where the processed data should go. Here's how you'd create one:
import org.apache.kafka.streams.StreamsBuilder;
public class Main {
public static void main(String[] args) {
StreamsBuilder builder = new StreamsBuilder();
// Your stream processing logic will go here
System.out.println("StreamsBuilder created!");
}
}KStream: Records in Motion
A KStream represents an unbounded, continuously updating stream of key-value records. Each record is processed independently as it arrives.
You can create a KStream from a Kafka topic using the stream() method of your StreamsBuilder. This tells your app to start consuming messages from that topic.
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.kstream.KStream;
public class Main {
public static void main(String[] args) {
StreamsBuilder builder = new StreamsBuilder();
KStream<String, String> sourceStream =
builder.stream("input-topic");
System.out.println("KStream created from input-topic!");
}
}Simple Transformation: mapValues
One common operation is to transform the value of each record in a KStream. The mapValues() method is perfect for this.
It applies a function to each record's value, keeping the key unchanged. Let's write code to make all text values uppercase!
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.kstream.KStream;
public class Main {
public static void main(String[] args) {
StreamsBuilder builder = new StreamsBuilder();
KStream<String, String> sourceStream =
builder.stream("input-topic");
KStream<String, String> transformedStream =
sourceStream.mapValues(value -> value.toUpperCase());
System.out.println("Stream values will be uppercased!");
}
}Essential Stream Configuration
Before running your app, you need to configure it. This is done using a Properties object and StreamsConfig. Key settings include:
APPLICATION_ID_CONFIG: Unique ID for your app (like a consumer group).BOOTSTRAP_SERVERS_CONFIG: Your Kafka broker addresses.DEFAULT_KEY_SERDE_CLASS_CONFIG: How to serialize/deserialize keys.DEFAULT_VALUE_SERDE_CLASS_CONFIG: How to serialize/deserialize values.
Serdes (Serializer/Deserializer) are crucial for converting data to/from bytes.
Your First Kafka Streams App
Let's put everything together! This app will read messages from an 'input-topic', convert their values to uppercase, and then write the results to an 'output-topic'.
Remember to create these topics in your Kafka cluster before running this code!
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 UppercaseStreamApp {
public static void main(String[] args) {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "uppercase-app");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
StreamsBuilder builder = new StreamsBuilder();
KStream<String, String> sourceStream = builder.stream("input-topic");
KStream<String, String> transformedStream =
sourceStream.mapValues(value -> value.toUpperCase());
transformedStream.to("output-topic");
KafkaStreams streams = new KafkaStreams(builder.build(), props);
// Clean up local state on shutdown (for development)
streams.cleanUp();
streams.start();
// Add shutdown hook to close Kafka Streams cleanly
Runtime.getRuntime().addShutdownHook(new Thread(streams::close));
System.out.println("UppercaseStreamApp started!");
}
}Managing Your Stream App
After defining your topology and configuration, you create a KafkaStreams instance and call start() to begin processing.
It's crucial to add a shutdown hook (Runtime.getRuntime().addShutdownHook) to ensure your application closes gracefully, flushing any buffered data and releasing resources.
The streams.cleanUp() call is useful during development to clear any local state store data, but should generally be avoided in production.
Test Your Knowledge
Which of the following is NOT a core component or essential configuration for a basic Kafka Streams application?
Recap: Your First Stream App
Great job! You've successfully learned the fundamentals of building a simple Kafka Streams application.
You now understand how to:
- Add the necessary Kafka Streams dependency.
- Use
StreamsBuilderto define your processing topology. - Create a
KStreamfrom an input topic. - Apply simple transformations like
mapValues(). - Configure your application with
StreamsConfig. - Start and gracefully stop your Kafka Streams application.
Next, we'll dive deeper into KStream and KTable concepts!
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Membangun Aplikasi Kafka Streams Sederhana” gratis?
Ya — teks lengkap “Membangun Aplikasi Kafka Streams Sederhana” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Apache Kafka & Stream Processing Fundamentals, upgrade ke CoddyKit PRO. Kursus Apache Kafka & Stream Processing Fundamentals mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Membangun Aplikasi Kafka Streams Sederhana”?
Buat aplikasi Kafka Streams pertama Anda untuk memproses data dari topik Kafka secara waktu nyata. Kamu berlatih Apache Kafka & Stream Processing Fundamentals 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 Apache Kafka & Stream Processing Fundamentals?
Tidak diperlukan pengalaman sebelumnya. Apache Kafka & Stream Processing Fundamentals 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 1 dari 4.
Berapa lama pelajaran “Membangun Aplikasi Kafka Streams Sederhana” 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 Apache Kafka & Stream Processing Fundamentals ini?
Ya. Setiap pelajaran Apache Kafka & Stream Processing Fundamentals 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
- Membangun Aplikasi Kafka Streams Sederhana
- Konsep KStream & KTable
- Operasi Tanpa Status vs. Berstatus
- Serdes dan Serialisasi Data di Kafka Streams