WebSockets og sanntidssystemer med Spring · leksjon

Tilpasning av meldingskonverterere

Tilpass meldingskonverterere til å håndtere ulike dataformater utover JSON, som Protobuf eller Avro.

Leksjon 2 av 411 trinn

Tilpasning av meldingskonverterere er en gratis leksjon i WebSockets og sanntidssystemer med Spring på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i WebSockets og sanntidssystemer med Spring, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i WebSockets og sanntidssystemer med Spring inneholder totalt 4 leksjoner.

Hva er meldingskonverterere?

I Spring WebSockets fungerer meldingskonverterere som oversettere. De håndterer omformingen av data fra applikasjonen Deres (for eksempel et Java-objekt) til et format som kan sendes over nettverket (for eksempel en JSON-streng eller binærdata), og omvendt.

Tenk på dem som mellomledd mellom Java-koden Deres og de rå WebSocket-meldingene.

JSON: Springs standard

Som standard er Spring Boot WebSockets konfigurert til å bruke JSON (JavaScript Object Notation) for meldingskonvertering. Dette håndteres av MappingJackson2MessageConverter.

JSON er lett å lese for mennesker og støttes bredt.
Det passer godt til de fleste vanlige bruksområder.
Spring konverterer automatisk Java-objektene Deres til JSON og tilbake igjen.

Utover JSON: Hvorfor tilpasse?

Selv om JSON er allsidig, finnes det situasjoner der De kan trenge andre formater:

Ytelse: Binærformater (som Protobuf eller Avro) er ofte mindre og raskere å serialisere og deserialisere, særlig i systemer med høy gjennomstrømning.
Samhandling: De kan måtte integrere med eksisterende systemer som kommuniserer ved hjelp av et bestemt format som ikke er JSON.
Spesifikke behov: Egendefinert kryptering, komprimering eller spesialiserte datastrukturer.

MessageConverter-grensesnittet

Spring bruker grensesnittet MessageConverter (fra org.springframework.messaging.converter) til å definere hvordan meldinger håndteres. Når De oppretter en egendefinert konverterer, implementerer De dette grensesnittet.

Viktige metoder De vanligvis implementerer:

supports(Class payloadClass): Kan denne konvertereren håndtere denne typen nyttelast?
fromMessage(Message message, Class targetClass): Konverter en innkommende melding til et Java-objekt.
toMessage(Object payload, MessageHeaders headers): Konverter et Java-objekt til en utgående melding.

Bygge logikk for en egendefinert konverterer

La oss se på et enkelt eksempel på *logikken* en egendefinert konverterer kan bruke. Her viser vi hvordan en streng konverteres til bytes (små bokstaver), og hvordan bytes konverteres tilbake til en streng (store bokstaver).

Denne kjørbare koden viser det grunnleggende transformasjonsprinsippet og etterligner det en konverterer gjør.

public class CustomConverterLogic {

    // Simulates the 'toMessage' part: Object -> Bytes
    public static byte[] stringToBytes(String text) {
        System.out.println("Converting string to bytes (lower)...");
        return text.toLowerCase().getBytes();
    }

    // Simulates the 'fromMessage' part: Bytes -> Object
    public static String bytesToString(byte[] bytes) {
        System.out.println("Converting bytes to string (upper)...");
        return new String(bytes).toUpperCase();
    }

    public static void main(String[] args) {
        String originalMessage = "Hello CoddyKit!";
        System.out.println("Original: " + originalMessage);

        // Step 1: Convert to bytes for sending
        byte[] payloadBytes = stringToBytes(originalMessage);
        System.out.println("Payload Bytes: " + new String(payloadBytes));

        // Step 2: Convert bytes back to string for receiving
        String receivedMessage = bytesToString(payloadBytes);
        System.out.println("Received: " + receivedMessage);
    }
}

Integrere med Spring-konfigurasjon

For å informere Spring om den egendefinerte meldingskonvertereren må De registrere den. Dette gjøres vanligvis ved å implementere WebSocketMessageBrokerConfigurer og overstyre metoden configureMessageConverters.

De legger den egendefinerte konvertereren til i listen over konverterere. Spring prøver dem deretter i rekkefølge.

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.converter.MessageConverter;
import org.springframework.messaging.converter.StringMessageConverter;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

import java.util.List;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/topic");
        config.setApplicationDestinationPrefixes("/app");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }

    @Override
    public boolean configureMessageConverters(List<MessageConverter> messageConverters) {
        // Add your custom converter here
        // It's often good to add custom ones before default ones if they handle the same type
        messageConverters.add(new CustomStringReverseConverter()); // Your custom converter
        messageConverters.add(new StringMessageConverter()); // Example of adding a default
        // Return true to disable default converters, false to keep them
        return false; // Keep default converters as well
    }

    // Your custom converter class would implement MessageConverter
    // For brevity, the full implementation is omitted here.
    // It would contain logic similar to the previous scene's example.
    static class CustomStringReverseConverter implements MessageConverter {
        // ... implementation of supports, fromMessage, toMessage
        @Override
        public boolean supports(Class<?> payloadClass) {
            return String.class.equals(payloadClass);
        }
        @Override
        public Object fromMessage(org.springframework.messaging.Message<?> message, Class<?> targetClass) {
            // Example: Reverse incoming string
            String payload = new String((byte[]) message.getPayload());
            return new StringBuilder(payload).reverse().toString();
        }
        @Override
        public org.springframework.messaging.Message<?> toMessage(Object payload, org.springframework.messaging.MessageHeaders headers) {
            // Example: Convert outgoing string to bytes
            return new org.springframework.messaging.support.GenericMessage<>(((String) payload).getBytes());
        }
    }
}

Rekkefølgen på konverterere er viktig

Når De registrerer flere meldingskonverterere, prøver Spring dem i den rekkefølgen de står i listen, til en av dem oppgir at den supports meldingens nyttelasttype.

Hvis De legger til en egendefinert konverterer som håndterer en type som allerede håndteres av en standardkonverterer (for eksempel String), plasser den egendefinerte konvertereren før standardkonvertereren i listen.
Dette sikrer at den egendefinerte logikken brukes først.

Binærformater: Protobuf og Avro

For svært optimalisert binærkommunikasjon er formater som Googles Protocol Buffers (Protobuf) eller Apache Avro gode valg.

De definerer datastrukturer på en språkagnostisk måte.
Generert kode håndterer effektiv serialisering og deserialisering.
Selv om Spring ikke tilbyr direkte MessageConverter-implementasjoner for disse som standard, kan De integrere eksisterende biblioteker. Spring Cloud OpenFeign tilbyr for eksempel en ProtobufHttpMessageConverter som kan tilpasses.

Hensyn på klientsiden

Husk at hvis serveren bruker et egendefinert meldingsformat, må klienten (for eksempel en JavaScript-nettleserklient eller en annen mikrotjeneste) også vite hvordan det samme formatet skal kodes og dekodes.

For Protobuf/Avro betyr dette at de respektive klientbibliotekene må brukes.
For et enkelt, egendefinert tekstformat må klienten implementere den samme transformasjonslogikken.

Det er avgjørende at klient og server er konsistente!

Test forståelsen

Du har lært om hvordan meldingskonverterere kan tilpasses. La oss teste kunnskapene dine!

Besvar den i den interaktive leksjonen

Oppsummering: Egendefinerte konverterere

Godt jobbet! I denne leksjonen har du lært om:

Rollen til meldingskonverterere i Spring WebSockets.
Springs standardbruk av JSON og MappingJackson2MessageConverter.
Hvorfor og når konverterere bør tilpasses for å oppnå bedre ytelse eller interoperabilitet.
Grensesnittet MessageConverter og hvordan du kan registrere egne egendefinerte konverterere ved hjelp av WebSocketMessageBrokerConfigurer.
Hensyn ved bruk av binære formater som Protobuf/Avro, og betydningen av konsistens mellom klient og server.

Egendefinerte konverterere gir deg kraftig kontroll over WebSocket-meldingsformatene dine!

Gratis å komme i gang

Lær deg WebSockets og sanntidssystemer med Spring 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 «Tilpasning av meldingskonverterere» gratis?

Ja – hele teksten i «Tilpasning av meldingskonverterere» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av WebSockets og sanntidssystemer med Spring-kurset, kan du oppgradere til CoddyKit PRO. Kurset i WebSockets og sanntidssystemer med Spring inneholder totalt 4 leksjoner.

Hva lærer jeg i «Tilpasning av meldingskonverterere»?

Tilpass meldingskonverterere til å håndtere ulike dataformater utover JSON, som Protobuf eller Avro. Du øver på WebSockets og sanntidssystemer med Spring 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 WebSockets og sanntidssystemer med Spring?

Ingen tidligere erfaring er nødvendig. WebSockets og sanntidssystemer med Spring 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 2 av 4.

Hvor lang tid tar leksjonen «Tilpasning av meldingskonverterere»?

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 WebSockets og sanntidssystemer med Spring-leksjonen?

Ja. Alle WebSockets og sanntidssystemer med Spring-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

WebSocket-interseptorer
Tilpasning av meldingskonverterere
Håndtering av brukerøkter
Målrettet meldingslevering til bestemte brukere

← Tilbake til WebSockets og sanntidssystemer med Spring