Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka) · leksjon

Integrering av Spring Boot og Schema Registry

Integrer Confluent Schema Registry med Spring Boot Kafka-applikasjoner for automatisk håndtering av Avro-serialisering og -deserialisering.

Leksjon 3 av 412 trinn

Integrering av Spring Boot og Schema Registry er en gratis leksjon i Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka) på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka), og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka) inneholder totalt 4 leksjoner.

Velkommen til integrasjon med Schema Registry

I tidligere leksjoner lærte du om betydningen av skjemahåndtering og hvordan du definerer skjemaer med Apache Avro. Nå er det på tide å sette alt sammen!

Denne leksjonen veileder deg gjennom integrasjonen av Confluent Schema Registry med Spring Boot Kafka-applikasjonene dine. Denne integrasjonen automatiserer Avro-serialisering og -deserialisering, slik at datapipelines blir robuste og enkle å administrere.

Hva er Confluent Schema Registry?

Confluent Schema Registry er en frittstående tjeneste som tilbyr et sentralisert lager for Avro-skjemaer. Den fungerer som en portvakt og sikrer at alle data som går gjennom Kafka-emnene dine, samsvarer med forhåndsdefinerte skjemaer.

Den lagrer en versjonert historikk over alle skjemaene dine.
Den tilbyr et REST-grensesnitt for registrering og henting av skjemaer.
Den tildeler en unik ID til hvert registrerte skjema.

Denne sentraliserte håndteringen er avgjørende for å kunne videreutvikle skjemaer uten å ødelegge eldre applikasjoner.

Slik fungerer det med Kafka

Når du bruker Schema Registry med Kafka:

Produsenter sender meldinger og registrerer først Avro-skjemaet sitt i Registry hvis det er nytt. Deretter inkluderer de en liten skjema-ID i meldingens nyttelast (eller topptekst), sammen med de serialiserte Avro-dataene.
Konsumenter mottar meldinger, henter ut skjema-ID-en og henter det tilsvarende skjemaet fra Registry. Deretter bruker de dette skjemaet til å deserialisere Avro-dataene korrekt.

Når dette er riktig konfigurert, er denne prosessen i stor grad usynlig for applikasjonskoden din.

Legge til avhengigheter for Avro

For å aktivere Avro-serialisering/-deserialisering med Spring Kafka og Schema Registry må du legge til bestemte avhengigheter i prosjektet ditt. Med Maven innebærer dette vanligvis biblioteket kafka-avro-serializer.

Her er de viktigste avhengighetene:

spring-kafka: Kjernefunksjonalitet for Spring Kafka.
kafka-avro-serializer: Confluents Avro-serialiserer/deserialiserer.
avro: Kjernebiblioteket til Apache Avro.

Du må også konfigurere en plugin (for eksempel avro-maven-plugin) for å generere Java-klasser fra .avsc-skjemafilene dine.

Konfigurere Schema Registry-klienten

Spring Boot må vite hvor Confluent Schema Registry kjører. Du angir dette i filen application.properties eller application.yml.

Egenskapen spring.kafka.properties.schema.registry.url er avgjørende. La oss se på et eksempel:

spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=io.confluent.kafka.serializers.KafkaAvroSerializer
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=io.confluent.kafka.serializers.KafkaAvroDeserializer
spring.kafka.properties.schema.registry.url=http://localhost:8081

Definere Avro-meldingsklassen vår

Før vi sender eller mottar Avro-meldinger, trenger vi et Avro-skjema og en tilhørende Java-klasse. Vanligvis definerer du en .avsc-fil og bruker en byggeplugin til å generere Java-klassen.

La oss si at vi har et enkelt Avro-skjema kalt User. Dette vil generere en Java-klasse som com.coddykit.User, med felt som name og age. Vi bruker denne genererte klassen direkte i Spring Boot-koden vår.

Avro-serialisering på produsentsiden

Når Spring Boot-applikasjonen er konfigurert med Avro-serialisereren og URL-en til Schema Registry, er det enkelt å sende Avro-meldinger. KafkaTemplate håndterer automatisk serialiseringen og kommunikasjonen med Schema Registry.

Her er et forenklet eksempel på en Spring Boot-produsent som sender et User-objekt:

package com.coddykit.producer;

import com.coddykit.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.core.KafkaTemplate;

@SpringBootApplication
public class AvroProducerApplication implements CommandLineRunner {

    @Autowired
    private KafkaTemplate<String, User> kafkaTemplate;

    public static void main(String[] args) {
        SpringApplication.run(AvroProducerApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        String topic = "users-avro-topic";
        User user = new User("Alice", 30);
        kafkaTemplate.send(topic, "user-key-1", user);
        System.out.println("Sent Avro User: " + user);
    }
}

// Simplified User class for demonstration (generated from Avro schema)
// public class User { 
//    private String name; 
//    private int age; 
//    public User(String name, int age) { this.name = name; this.age = age; } 
//    public String getName() { return name; } 
//    public int getAge() { return age; } 
//    @Override public String toString() { return "User{" + "name='" + name + '\'' + ", age=" + age + '}'; } 
// }

Avro-deserialisering på konsumentsiden

Tilsvarende konverterer Spring sin @KafkaListener, kombinert med Avro-deserialisereren og konfigurasjonen av Schema Registry, automatisk de innkommende Avro-meldingsbytene til Java Avro-objektet ditt.

Du angir bare måltypen for Avro-klassen i signaturen til lyttemetoden.

package com.coddykit.consumer;

import com.coddykit.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;

@SpringBootApplication
public class AvroConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(AvroConsumerApplication.class, args);
    }

    @KafkaListener(topics = "users-avro-topic", groupId = "avro-group")
    public void listen(User user) {
        System.out.println("Received Avro User: " + user);
    }
}

Håndtere skjemaevolusjon

En av de mest kraftfulle fordelene ved å bruke Schema Registry med Avro er støtten for skjemaevolusjon. Etter hvert som behovene til applikasjonen endrer seg, kan det hende du må legge til, fjerne eller endre felt i Avro-skjemaene dine.

Schema Registry bidrar til å sikre at eldre konsumenter fortsatt kan behandle meldinger uten feil, selv om en produsent sender data med en nyere skjemaversjon (og omvendt), så lenge skjem endringene er kompatible (for eksempel at et felt legges til med en standardverdi).

Viktige fordeler ved integrasjonen

Integrasjon av Confluent Schema Registry med Spring Boot Kafka-applikasjoner gir flere betydelige fordeler:

Datakompatibilitet: Sikrer at produsenter og konsumenter alltid er enige om dataformatet, og forhindrer deserialiseringsfeil.
Skjemaevolusjon: Håndterer skjem endringer over tid på en smidig måte.
Mindre standardkode: Automatisk serialisering/deserialisering betyr mindre kode som må skrives manuelt.
Sentralisert håndtering: Én felles kilde til sannheten for alle hendelsesskjemaene dine.
Streng typing: Utnytter Avros sterke typing for bedre datakvalitet og utvikleropplevelse.

Kort kontroll: Formålet med Schema Registry

Hva er hovedrollen til Confluent Schema Registry når det integreres med Spring Boot Kafka-applikasjoner som bruker Avro?

Besvar den i den interaktive leksjonen

Oppsummering: Sømløs Avro med Spring

Godt jobbet! Du har lært hvordan du integrerer Confluent Schema Registry med Spring Boot Kafka-applikasjonene dine. Denne kraftfulle kombinasjonen automatiserer Avro-serialisering og -deserialisering, slik at hendelsesdrevne mikrotjenester blir mer robuste og enklere å vedlikeholde.

Vi gikk gjennom rollen til Schema Registry og hvordan den fungerer.
Du så hvordan du konfigurerer Spring Boot for Avro og Schema Registry.
Vi utforsket eksempler på produsenter og konsumenter for sømløs håndtering av Avro-objekter.
Vi så kort på fordelene ved skjemaevolusjon og datakompatibilitet.

Ved å bruke Schema Registry sikrer du at datakontraktene dine alltid overholdes, selv når applikasjonene dine videreutvikles.

Gratis å komme i gang

Lær deg Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka) med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Integrering av Spring Boot og Schema Registry» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka), inkludert «Integrering av Spring Boot og Schema Registry», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka) inneholder totalt 4 leksjoner.

Hva lærer jeg i «Integrering av Spring Boot og Schema Registry»?

Integrer Confluent Schema Registry med Spring Boot Kafka-applikasjoner for automatisk håndtering av Avro-serialisering og -deserialisering. Du øver på Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka) med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka)?

Ingen tidligere erfaring er nødvendig. Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka) på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Integrering av Spring Boot og Schema Registry»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka)-leksjonen?

Ja. Alle Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka)-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Viktigheten av skjemahåndtering
Avro for skjemadefinisjon
Integrering av Spring Boot og Schema Registry
Skjemaevolusjon og kompatibilitetsmoduser

← Tilbake til Avansert Spring Boot 4: hendelsesdrevet arkitektur (Kafka)