WebSockets & Real-Time Systems with Spring · Ders

Mesaj Dönüştürücülerini Özelleştirme

JSON'un yanı sıra Protobuf veya Avro gibi çeşitli veri biçimlerini işlemek üzere mesaj dönüştürücülerini özelleştirin.

Mesaj Dönüştürücülerini Özelleştirme, CoddyKit'te ücretsiz bir WebSockets & Real-Time Systems with Spring dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, WebSockets & Real-Time Systems with Spring öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. WebSockets & Real-Time Systems with Spring kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

What are Message Converters?

In Spring WebSockets, message converters are like translators. They handle the magic of turning data from your application (like a Java object) into a format that can be sent over the network (like a JSON string or binary data), and vice-versa.

Think of them as intermediaries between your Java code and the raw WebSocket messages.

JSON: Spring's Default

By default, Spring Boot WebSockets are set up to use JSON (JavaScript Object Notation) for message conversion. This is handled by the MappingJackson2MessageConverter.

JSON is human-readable and widely supported.
It's great for most common use cases.
Spring automatically converts your Java objects to JSON and back.

Beyond JSON: Why Customize?

While JSON is versatile, there are times you might need other formats:

Performance: Binary formats (like Protobuf or Avro) are often smaller and faster to serialize/deserialize, especially for high-throughput systems.
Interoperability: You might need to integrate with existing systems that communicate using a specific non-JSON format.
Specific Needs: Custom encryption, compression, or specialized data structures.

The MessageConverter Interface

Spring uses the MessageConverter interface (from org.springframework.messaging.converter) to define how messages are handled. When you create a custom converter, you'll implement this interface.

Key methods you'd typically implement:

supports(Class payloadClass): Can this converter handle this type of payload?
fromMessage(Message message, Class targetClass): Convert an incoming message into a Java object.
toMessage(Object payload, MessageHeaders headers): Convert a Java object into an outgoing message.

Building a Custom Converter Logic

Let's see a simple example of the *logic* a custom converter might use. Here, we'll demonstrate converting a string to bytes (lowercase) and bytes back to a string (uppercase).

This runnable code shows the core transformation concept, mimicking what a converter does.

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);
    }
}

Integrating with Spring Config

To tell Spring about your custom message converter, you need to register it. This is typically done by implementing WebSocketMessageBrokerConfigurer and overriding the configureMessageConverters method.

You add your custom converter to the list of converters. Spring will then try them in order.

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());
        }
    }
}

Order of Converters Matters

When you register multiple message converters, Spring tries them in the order they appear in the list until one reports that it supports the message's payload type.

If you add a custom converter that handles a type already managed by a default converter (e.g., String), place your custom converter before the default one in the list.
This ensures your custom logic is applied first.

Binary Formats: Protobuf & Avro

For highly optimized binary communication, formats like Protocol Buffers (Protobuf) by Google or Apache Avro are excellent choices.

They define data structures in a language-agnostic way.
Generated code handles efficient serialization and deserialization.
While Spring doesn't provide direct MessageConverter implementations for these by default, you can integrate existing libraries. For example, Spring Cloud OpenFeign provides a ProtobufHttpMessageConverter that can be adapted.

Client-Side Considerations

Remember, if your server uses a custom message format, your client (e.g., a JavaScript browser client or another microservice) must also know how to encode and decode that same format.

For Protobuf/Avro, this means using their respective client libraries.
For a simple custom text format, your client would need to implement the same transformation logic.

Consistency between client and server is key!

Check Your Understanding

You've learned about customizing message converters. Let's test your knowledge!

Recap: Custom Converters

Great job! In this lesson, you've learned about:

The role of message converters in Spring WebSockets.
Spring's default use of JSON and MappingJackson2MessageConverter.
Why and when to customize converters for performance or interoperability.
The MessageConverter interface and how to register your own custom converters using WebSocketMessageBrokerConfigurer.
Considerations for binary formats like Protobuf/Avro and the importance of client-server consistency.

Custom converters give you powerful control over your WebSocket message formats!

Sıkça Sorulan Sorular

“Mesaj Dönüştürücülerini Özelleştirme” dersi ücretsiz mi?

Evet — “Mesaj Dönüştürücülerini Özelleştirme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve WebSockets & Real-Time Systems with Spring kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. WebSockets & Real-Time Systems with Spring kursu toplamda 4 dersten oluşur.

“Mesaj Dönüştürücülerini Özelleştirme” dersinde ne öğreneceğim?

JSON'un yanı sıra Protobuf veya Avro gibi çeşitli veri biçimlerini işlemek üzere mesaj dönüştürücülerini özelleştirin. WebSockets & Real-Time Systems with Spring ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

WebSockets & Real-Time Systems with Spring öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te WebSockets & Real-Time Systems with Spring, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Mesaj Dönüştürücülerini Özelleştirme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu WebSockets & Real-Time Systems with Spring dersinde kod yazıp çalıştırabilir miyim?

Evet. Her WebSockets & Real-Time Systems with Spring dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

WebSocket Araya Giricileri
Mesaj Dönüştürücülerini Özelleştirme
Kullanıcı Oturumu Yönetimi
Belirli Kullanıcılara Hedefli İleti Gönderme

← WebSockets & Real-Time Systems with Spring Sayfasına Dön