การแปลงข้อมูลกลับและการแปลงข้อความ

Kafka doesn't care about the format of your data. It treats every message as a raw array of bytes. This is how messages are stored and transmitted.

When a producer sends a message, it's first converted into bytes. When a consumer receives that message, it's still just a bunch of bytes.

This flexibility allows Kafka to handle any data type, but it means consumers need a way to interpret those bytes back into a usable format.

To make sense of Kafka messages in your Java application, you need to convert these raw bytes back into meaningful Java objects. This crucial process is called deserialization.

A deserializer is a specific component that knows how to read a byte array and reconstruct a Java object from it. Think of it as the reverse of serialization.

Without proper deserialization, your consumer would only ever see byte[], which isn't very useful for application logic.

Spring for Apache Kafka provides sensible defaults to get you started quickly. If you don't specify otherwise, it assumes your message keys and values are simple strings.

Behind the scenes, it uses org.apache.kafka.common.serialization.StringDeserializer to convert message bytes into Java String objects.

This works perfectly for plain text messages, but most real-world applications often need to handle more structured data.

Here's a basic Spring Boot application with a Kafka listener that consumes simple string messages. Notice the String type in the listener method signature.

You can explicitly configure which deserializers to use in your application.properties or application.yml file. This tells Spring Kafka which classes to use for converting bytes for both the message key and value.

• spring.kafka.consumer.key-deserializer
• spring.kafka.consumer.value-deserializer

For our default string example, these would be set to org.apache.kafka.common.serialization.StringDeserializer.

JSON (JavaScript Object Notation) is a widely used format for exchanging structured data. It's very common for Kafka messages to carry data in JSON format.

To utilize JSON messages effectively in your Java application, you need to convert the incoming JSON string (or bytes) into a Java object, typically a Plain Old Java Object (POJO).

This mapping allows you to easily access data fields directly, like myObject.getId() or myObject.getName(), instead of parsing JSON manually.

Spring for Apache Kafka provides a powerful org.springframework.kafka.support.serializer.JsonDeserializer to simplify handling JSON messages.

This deserializer leverages the popular Jackson library to automatically map incoming JSON bytes to your specified Java POJO class.

You just need to configure it to know which POJO type to expect, and it handles the complex conversion for you.

First, let's define a simple Java POJO that will represent our incoming JSON data. The properties of this POJO should match the fields in your JSON messages.

Now, let's update our consumer to use the JsonDeserializer and listen for MyEvent objects. Remember, you'll also need to configure the deserializer in your application.properties.

Great job! In this lesson, you learned that Kafka messages are raw bytes and require deserialization to be used in Java applications.

• Spring Kafka uses StringDeserializer by default for simple text messages.
• You can configure specific deserializers for keys and values using application.properties.
• The JsonDeserializer simplifies mapping JSON messages to Java POJOs automatically.

Understanding deserialization is fundamental to building robust Kafka consumers that can handle various data formats effectively.