역직렬화와 메시지 변환
다양한 메시지 형식(String, JSON, 사용자 지정 객체)을 위한 역직렬화기를 구성하고 리스너 내부에서 메시지 변환을 처리합니다.
역직렬화와 메시지 변환은(는) CoddyKit의 무료 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 강의입니다. 이것은 4개 중 3번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 강의에는 총 4개의 강의가 포함되어 있습니다.
이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.
Kafka's Raw Messages
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.
From Bytes to Objects: Deserialization
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.
Default String Deserialization
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.
Code: Simple String Consumer
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.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
@SpringBootApplication
public class SimpleConsumerApp {
public static void main(String[] args) {
SpringApplication.run(SimpleConsumerApp.class, args);
System.out.println("String consumer app started, listening on my-string-topic...");
}
@Component
static class MyStringListener {
@KafkaListener(topics = "my-string-topic", groupId = "string-group")
public void listen(String message) {
System.out.println("Received String: " + message);
}
}
}Configuring Deserializers Explicitly
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-deserializerspring.kafka.consumer.value-deserializer
For our default string example, these would be set to org.apache.kafka.common.serialization.StringDeserializer.
Working with JSON Data
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's JsonDeserializer
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.
Code: Defining an Event POJO
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.
package com.coddykit;
// MyEvent.java
public class MyEvent {
private String id;
private String description;
// Default constructor is crucial for deserialization
public MyEvent() {}
public MyEvent(String id, String description) {
this.id = id;
this.description = description;
}
// Getters and Setters (omitted for brevity, but needed)
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
@Override
public String toString() {
return "MyEvent{id='" + id + "', description='" + description + "'}";
}
}Code: Consuming 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.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import com.coddykit.MyEvent; // Import your POJO
@SpringBootApplication
public class JsonConsumerApp {
public static void main(String[] args) {
SpringApplication.run(JsonConsumerApp.class, args);
System.out.println("JSON consumer app started, listening on my-json-topic...");
}
@Component
static class MyJsonListener {
@KafkaListener(topics = "my-json-topic", groupId = "json-group")
public void listen(MyEvent event) {
System.out.println("Received JSON Event: " + event.toString());
}
}
}
// Required application.properties configuration:
// spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
// spring.kafka.consumer.value-deserializer=org.springframework.kafka.support.serializer.JsonDeserializer
// spring.kafka.properties.spring.json.value.default.type=com.coddykit.MyEventDeserializer Configuration Quiz
Consider a Spring Boot Kafka consumer application that needs to process messages where the value is a JSON representation of a Product object, defined in com.example.Product. Which configuration is essential in application.properties for this setup?
Deserialization Recap
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
StringDeserializerby default for simple text messages. - You can configure specific deserializers for keys and values using
application.properties. - The
JsonDeserializersimplifies mapping JSON messages to Java POJOs automatically.
Understanding deserialization is fundamental to building robust Kafka consumers that can handle various data formats effectively.
자주 묻는 질문
“역직렬화와 메시지 변환” 강의는 무료인가요?
네 — “역직렬화와 메시지 변환” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 강의 전체를 잠금 해제할 수 있습니다. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 강의에는 총 4개의 강의가 포함되어 있습니다.
“역직렬화와 메시지 변환”에서 뭘 배우나요?
다양한 메시지 형식(String, JSON, 사용자 지정 객체)을 위한 역직렬화기를 구성하고 리스너 내부에서 메시지 변환을 처리합니다. 브라우저에서 직접 실행하는 실습 코드로 Advanced Spring Boot 4: Event-Driven Architecture (Kafka)을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.
Advanced Spring Boot 4: Event-Driven Architecture (Kafka)을(를) 시작하는 데 경험이 필요한가요?
사전 경험은 필요하지 않습니다. CoddyKit의 Advanced Spring Boot 4: Event-Driven Architecture (Kafka)은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 3번째 강의입니다.
“역직렬화와 메시지 변환” 강의는 얼마나 걸리나요?
대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.
이 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 강의에서 코드를 작성하고 실행할 수 있나요?
네. 모든 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.
이 강의의 모든 강의
- Kafka 리스너 컨테이너 구축
- 소비자 그룹 관리
- 역직렬화와 메시지 변환
- 일괄 소비와 승인 모드