Deserializzazione e conversione dei messaggi
Configuri deserializzatori per diversi formati di messaggio (String, JSON, oggetti personalizzati) e gestisca la conversione dei messaggi nei listener.
Deserializzazione e conversione dei messaggi è una lezione Advanced Spring Boot 4: Event-Driven Architecture (Kafka) gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Advanced Spring Boot 4: Event-Driven Architecture (Kafka), e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Advanced Spring Boot 4: Event-Driven Architecture (Kafka) include 4 lezioni in totale.
I messaggi grezzi di Kafka
A Kafka non interessa il formato dei dati. Ogni messaggio viene trattato come un array grezzo di byte. È così che i messaggi vengono memorizzati e trasmessi.
Quando un producer invia un messaggio, questo viene prima convertito in byte. Quando un consumer riceve il messaggio, è ancora semplicemente un insieme di byte.
Questa flessibilità consente a Kafka di gestire qualsiasi tipo di dato, ma significa che i consumer devono poter interpretare nuovamente quei byte e convertirli in un formato utilizzabile.
Dai byte agli oggetti: deserializzazione
Per interpretare i messaggi Kafka nell'applicazione Java, è necessario convertire questi byte grezzi in oggetti Java significativi. Questo processo fondamentale si chiama deserializzazione.
Un deserializzatore è un componente specifico che sa leggere un array di byte e ricostruire un oggetto Java. È l'operazione inversa della serializzazione.
Senza una deserializzazione corretta, il consumer vedrebbe soltanto byte[], che non è molto utile per la logica dell'applicazione.
Deserializzazione predefinita delle stringhe
Spring for Apache Kafka offre impostazioni predefinite ragionevoli per consentirle di iniziare rapidamente. Se non specifica diversamente, presume che le chiavi e i valori dei messaggi siano semplici stringhe.
Internamente, utilizza org.apache.kafka.common.serialization.StringDeserializer per convertire i byte dei messaggi in oggetti Java String.
Questo funziona perfettamente per i messaggi di testo semplice, ma nella maggior parte delle applicazioni reali è spesso necessario gestire dati più strutturati.
Codice: consumer di stringhe semplice
Ecco una semplice applicazione Spring Boot con un listener Kafka che consuma messaggi di testo. Noti il tipo String nella firma del metodo del listener.
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);
}
}
}Configurazione esplicita dei deserializzatori
È possibile configurare esplicitamente i deserializzatori da utilizzare nel file application.properties o application.yml. In questo modo si indica a Spring Kafka quali classi utilizzare per convertire i byte sia della chiave sia del valore del messaggio.
spring.kafka.consumer.key-deserializerspring.kafka.consumer.value-deserializer
Nel nostro esempio predefinito con stringhe, questi valori verrebbero impostati su org.apache.kafka.common.serialization.StringDeserializer.
Utilizzo dei dati JSON
JSON (JavaScript Object Notation) è un formato ampiamente utilizzato per lo scambio di dati strutturati. È molto comune che i messaggi Kafka contengano dati in formato JSON.
Per utilizzare efficacemente i messaggi JSON nell'applicazione Java, è necessario convertire la stringa JSON ricevuta, o i relativi byte, in un oggetto Java, in genere un Plain Old Java Object (POJO).
Questa mappatura consente di accedere facilmente direttamente ai campi dei dati, ad esempio con myObject.getId() o myObject.getName(), invece di analizzare manualmente il JSON.
Il JsonDeserializer di Spring
Spring for Apache Kafka offre un potente org.springframework.kafka.support.serializer.JsonDeserializer per semplificare la gestione dei messaggi JSON.
Questo deserializzatore sfrutta la popolare libreria Jackson per mappare automaticamente i byte JSON ricevuti sulla classe Java POJO specificata.
È sufficiente configurarlo indicando il tipo di POJO previsto; il deserializzatore gestirà la complessa conversione al posto Suo.
Codice: definizione di un POJO per gli eventi
Per prima cosa, definiamo un semplice POJO Java che rappresenterà i dati JSON ricevuti. Le proprietà di questo POJO devono corrispondere ai campi presenti nei messaggi JSON.
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 + "'}";
}
}Codice: ricezione di messaggi JSON
Ora aggiorniamo il consumer affinché utilizzi JsonDeserializer e ascolti oggetti MyEvent. Ricordi che dovrà configurare il deserializzatore anche nel file 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.MyEventQuiz sulla configurazione del deserializzatore
Consideri un'applicazione consumer Spring Boot Kafka che deve elaborare messaggi il cui valore è la rappresentazione JSON di un oggetto Product, definito in com.example.Product. Quale configurazione è essenziale nel file application.properties per questa configurazione?
Riepilogo della deserializzazione
Ottimo lavoro! In questa lezione ha imparato che i messaggi Kafka sono byte grezzi e richiedono la deserializzazione per poter essere utilizzati nelle applicazioni Java.
- Spring Kafka utilizza
StringDeserializerper impostazione predefinita nei messaggi di testo semplice. - È possibile configurare deserializzatori specifici per chiavi e valori utilizzando
application.properties. JsonDeserializersemplifica la mappatura automatica dei messaggi JSON sui POJO Java.
Comprendere la deserializzazione è fondamentale per creare consumer Kafka robusti, in grado di gestire efficacemente vari formati di dati.
Impara Advanced Spring Boot 4: Event-Driven Architecture (Kafka) con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 12
- Lezioni
- 48
Domande Frequenti
La lezione «Deserializzazione e conversione dei messaggi» è gratuita?
Sì — il testo completo di «Deserializzazione e conversione dei messaggi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Advanced Spring Boot 4: Event-Driven Architecture (Kafka), passa a CoddyKit PRO. Il corso Advanced Spring Boot 4: Event-Driven Architecture (Kafka) include 4 lezioni in totale.
Cosa imparerò in «Deserializzazione e conversione dei messaggi»?
Configuri deserializzatori per diversi formati di messaggio (String, JSON, oggetti personalizzati) e gestisca la conversione dei messaggi nei listener. Eserciti Advanced Spring Boot 4: Event-Driven Architecture (Kafka) con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Advanced Spring Boot 4: Event-Driven Architecture (Kafka)?
Non è richiesta alcuna esperienza precedente. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Deserializzazione e conversione dei messaggi»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Advanced Spring Boot 4: Event-Driven Architecture (Kafka)?
Sì. Ogni lezione Advanced Spring Boot 4: Event-Driven Architecture (Kafka) include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Creare container listener Kafka
- Gestione dei gruppi di consumatori
- Deserializzazione e conversione dei messaggi
- Consumo in batch e modalità di acknowledgment