Advanced Spring Boot 4: Event-Driven Architecture (Kafka) · 课时

反序列化与消息转换

为各种消息格式（字符串、JSON 和自定义对象）配置反序列化器，并在监听器中处理消息转换。

反序列化与消息转换 是 CoddyKit 上的免费 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 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-deserializer
spring.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.MyEvent

Deserializer 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 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.

常见问题解答

「反序列化与消息转换」课时是免费的吗？

是的 — 「反序列化与消息转换」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课程的其余内容，请升级到 CoddyKit PRO。 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课程共包含 4 节课。

「反序列化与消息转换」这节课中我会学到什么？

为各种消息格式（字符串、JSON 和自定义对象）配置反序列化器，并在监听器中处理消息转换。你通过在浏览器中直接运行的动手代码来练习 Advanced Spring Boot 4: Event-Driven Architecture (Kafka)，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「反序列化与消息转换」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课中编写并运行代码吗？

能。每节 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Advanced Spring Boot 4: Event-Driven Architecture (Kafka)