0Pricing
WebSockets & Real-Time Systems with Spring · レッスン

メッセージコンバーターのカスタマイズ

ProtobufやAvroなど、JSON以外のさまざまなデータ形式を扱えるようにメッセージコンバーターをカスタマイズします。

「メッセージコンバーターのカスタマイズ」はCoddyKit上の無料WebSockets & Real-Time Systems with Springレッスンです。 これはレッスン2/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはWebSockets & Real-Time Systems with Spring学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 WebSockets & Real-Time Systems with Springコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

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!

よくある質問

「メッセージコンバーターのカスタマイズ」レッスンは無料ですか？

はい。「メッセージコンバーターのカスタマイズ」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、WebSockets & Real-Time Systems with Springコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 WebSockets & Real-Time Systems with Springコースには全4レッスンが含まれています。

「メッセージコンバーターのカスタマイズ」で何を学びますか？

ProtobufやAvroなど、JSON以外のさまざまなデータ形式を扱えるようにメッセージコンバーターをカスタマイズします。 ブラウザで直接実行するハンズオンコードでWebSockets & Real-Time Systems with Springを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

WebSockets & Real-Time Systems with Springを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのWebSockets & Real-Time Systems with Springは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン2/4です。

「メッセージコンバーターのカスタマイズ」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このWebSockets & Real-Time Systems with Springレッスンでコードを書いて実行できますか？

はい。すべてのWebSockets & Real-Time Systems with Springレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. WebSocketインターセプター
  2. メッセージコンバーターのカスタマイズ
  3. ユーザーセッション管理
  4. 特定ユーザーへのターゲットメッセージング
← WebSockets & Real-Time Systems with Springに戻る