STOMP Broker en Spring Boot: principio y uso

STOMP Broker en Spring Boot: principio y uso

Introducción

STOMP (Simple Text Oriented Messaging Protocol) es un protocolo basado en texto para pasar mensajes entre aplicaciones web. STOMP proporciona una forma sencilla de implementar la comunicación bidireccional a través de WebSocket. En Spring Boot, podemos usar STOMP para realizar la comunicación bidireccional de WebSocket.

STOMP Broker es una implementación del protocolo STOMP, que se utiliza para pasar mensajes entre aplicaciones web. En Spring Boot, podemos usar el STOMP Broker proporcionado por el módulo Spring WebSocket para implementar la comunicación bidireccional de WebSocket.

Este artículo presentará el principio y el uso de STOMP Broker en Spring Boot.

principio

En Spring Boot, STOMP Broker es un servidor proxy para pasar mensajes entre aplicaciones web. STOMP Broker permite la comunicación bidireccional entre múltiples clientes WebSocket. Cuando un cliente WebSocket envía un mensaje, STOMP Broker enrutará el mensaje al cliente WebSocket de destino.

En Spring Boot, podemos usar la anotación @EnableWebSocketMessageBroker para habilitar el intermediario de mensajes WebSocket. Cuando se aplica esta anotación, Spring Boot configurará automáticamente el proxy de mensajes WebSocket para que podamos usar anotaciones como @MessageMapping y @SendTo para procesar mensajes WebSocket.

En STOMP Broker, podemos usar la anotación @MessageMapping para procesar mensajes WebSocket. Cuando un cliente WebSocket envía un mensaje, STOMP Broker enrutará el mensaje al método de procesamiento marcado con la anotación @MessageMapping para su procesamiento. El método del controlador puede enviar el mensaje a otro cliente WebSocket o puede enviar el mensaje a un tema STOMP específico.

Aquí hay un ejemplo simple:

@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("/websocket").withSockJS();
    }

    @Controller
    public class WebSocketController {
    
    

        @MessageMapping("/hello")
        @SendTo("/topic/greetings")
        public Greeting greeting(HelloMessage message) throws Exception {
    
    
            Thread.sleep(1000); // simulated delay
            return new Greeting("Hello, " + message.getName() + "!");
        }
    }
}

En el ejemplo anterior, definimos una clase de configuración Spring Boot llamada "WebSocketConfig" y habilitamos el intermediario de mensajes WebSocket en ella. Usamos la anotación @EnableWebSocketMessageBroker para habilitar el intermediario de mensajes WebSocket e implementamos la interfaz WebSocketMessageBrokerConfigurer para configurar el intermediario de mensajes WebSocket.

En el método configureMessageBroker, usamos el método config.enableSimpleBroker("/topic") para habilitar un tema STOMP llamado "/topic". También usamos el método config.setApplicationDestinationPrefixes("/app") para establecer un prefijo de aplicación llamado "/app" para identificar los mensajes WebSocket de la aplicación.

En el método registerStompEndpoints, usamos el método registration.addEndpoint(“/websocket”).withSockJS() para registrar un punto final de WebSocket llamado “/websocket” y habilitar la compatibilidad con SockJS.

En el controlador WebSocket, definimos un método de procesamiento marcado con la anotación @MessageMapping, que se usa para procesar el mensaje WebSocket llamado "/hello" y enviar el resultado del procesamiento al tema STOMP llamado "/tema/saludos".

cómo utilizar

El proceso de usar STOMP Broker para procesar mensajes WebSocket es muy simple. Solo necesitamos definir uno o más métodos de procesamiento marcados con la anotación @MessageMapping en el controlador WebSocket y usar la anotación @SendTo para enviar los resultados del procesamiento al tema STOMP especificado.

En nuestro método de controlador, podemos usar la anotación @Payload para identificar la carga útil del mensaje WebSocket. En este ejemplo, usamos la anotación @Payload para deserializar la carga útil del mensaje WebSocket en un objeto HelloMessage.

Además de la anotación @MessageMapping y la anotación @SendTo, Spring Boot también proporciona muchas otras anotaciones y herramientas para ayudarnos a procesar los mensajes de WebSocket más fácilmente. Por ejemplo, la anotación @SubscribeMapping se puede usar para suscribirse a un tema STOMP; la anotación @DestinationVariable se puede usar para obtener el valor de la variable en el tema STOMP; la anotación @Header se puede usar para obtener el encabezado en el mensaje WebSocket, etc.

Aquí hay un ejemplo simple que muestra cómo usar STOMP Broker para procesar mensajes WebSocket:

1. Agregar dependencias

Primero, debemos agregar las dependencias de WebSocket y STOMP a nuestra aplicación Spring Boot. Agregue las siguientes dependencias a nuestro archivo pom.xml:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

2. Configurar el agente de mensajes de WebSocket

Luego, debemos configurar el intermediario de mensajes WebSocket en nuestra aplicación Spring Boot. Agregue la anotación @EnableWebSocketMessageBroker a nuestra clase de configuración para habilitar la intermediación de mensajes de WebSocket.

@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("/websocket").withSockJS();
    }
}

En el ejemplo anterior, usamos el método config.enableSimpleBroker("/topic") para habilitar un tema STOMP llamado "/topic", y usamos el método config.setApplicationDestinationPrefixes("/app") para establecer un tema STOMP llamado "/ topic" app", que se utiliza para identificar el mensaje WebSocket de la aplicación. También usamos el método registration.addEndpoint(“/websocket”).withSockJS() para registrar un punto final de WebSocket llamado “/websocket” y habilitar la compatibilidad con SockJS.

3. Escriba un controlador WebSocket

A continuación, debemos escribir un controlador WebSocket para manejar los mensajes WebSocket. En nuestros controladores, podemos usar la anotación @MessageMapping para procesar mensajes WebSocket y usar la anotación @SendTo para enviar los resultados del procesamiento al tema STOMP especificado.

@Controller
public class WebSocketController {
    
    

    @MessageMapping("/hello")
    @SendTo("/topic/greetings")
    public Greeting greeting(HelloMessage message) throws Exception {
    
    
        Thread.sleep(1000); // simulated delay
        return new Greeting("Hello, " + message.getName() + "!");
    }
}

En el ejemplo anterior, definimos un controlador WebSocket marcado con la anotación @Controller y definimos un método de procesamiento llamado "/hello" para procesar mensajes WebSocket. Usamos la anotación @Payload para deserializar la carga útil del mensaje WebSocket en un objeto HelloMessage y usamos la anotación @SendTo para enviar el resultado del procesamiento al tema STOMP denominado "/tema/saludos".

4. Escriba un cliente WebSocket

Finalmente, necesitamos escribir un cliente WebSocket para enviar mensajes WebSocket y recibir los resultados del procesamiento. En nuestro cliente, podemos usar StompClient para conectarnos al servidor WebSocket y usar StompSession para enviar y recibir mensajes STOMP.

public class WebSocketClient {
    
    

    public static void main(String[] args) throws Exception {
    
    
        WebSocketClient webSocketClient = new WebSocketClient();
        webSocketClient.connect();
    }

    private void connect() throws Exception {
    
    
        WebSocketStompClient stompClient = new WebSocketStompClient(new StandardWebSocketClient());
        StompSessionHandler sessionHandler = new MyStompSessionHandler();
        stompClient.connect("ws://localhost:8080/websocket", sessionHandler);
        Thread.sleep(5000);
    }

    private static class MyStompSessionHandler extends StompSessionHandlerAdapter {
    
    

        @Override
        public void afterConnected(StompSession session, StompHeaders connectedHeaders) {
    
    
            session.subscribe("/topic/greetings", new StompFrameHandler() {
    
    
                @Override
                public Type getPayloadType(StompHeaders headers) {
    
    
                    return Greeting.class;
                }

                @Override
                public void handleFrame(StompHeaders headers, Object payload) {
    
    
                    Greeting greeting = (Greeting) payload;
                    System.out.println(greeting.getContent());
                }
            });

            session.send("/app/hello", new HelloMessage("World"));
        }
    }
}

En el ejemplo anterior, definimos una clase llamada "WebSocketClient" e implementamos un método llamado "conectar". En el método de conexión, usamos WebSocketStompClient para conectarnos al servidor WebSocket e implementamos una clase StompSessionHandler llamada "MyStompSessionHandler", que se usa para manejar la StompSession conectada al servidor WebSocket.

En la clase MyStompSessionHandler, usamos el método session.subscribe(“/tema/saludos”, new StompFrameHandler() {…}) para suscribirse al tema STOMP llamado “/tema/saludos”, y definimos una clase StompFrameHandler para manejar el recibido mensajes STOMP. También enviamos un objeto HelloMessage al tema STOMP llamado "/hello" usando el método session.send("/app/hello", new HelloMessage("World")).

Resumir

STOMP Broker en Spring Boot es un servidor proxy para pasar mensajes entre aplicaciones web. STOMP Broker permite la comunicación bidireccional entre múltiples clientes WebSocket. En Spring Boot, podemos usar el STOMP Broker proporcionado por el módulo Spring WebSocket para implementar la comunicación bidireccional de WebSocket.

En STOMP Broker, podemos usar la anotación @MessageMapping para procesar mensajes WebSocket. Cuando un cliente WebSocket envía un mensaje, STOMP Broker enrutará el mensaje al método de procesamiento marcado con la anotación @MessageMapping para su procesamiento. El método del controlador puede enviar el mensaje a otro cliente WebSocket o puede enviar el mensaje a un tema STOMP específico.

El proceso de usar STOMP Broker para procesar mensajes WebSocket es muy simple. Solo necesitamos definir uno o más métodos de procesamiento marcados con la anotación @MessageMapping en el controlador WebSocket y usar la anotación @SendTo para enviar los resultados del procesamiento al tema STOMP especificado.

Al escribir un cliente WebSocket, podemos usar StompClient para conectarnos al servidor WebSocket y usar StompSession para enviar y recibir mensajes STOMP.

Finalmente, Spring Boot proporciona muchas otras anotaciones y herramientas para ayudarnos a procesar los mensajes de WebSocket más fácilmente. Por ejemplo, la anotación @SubscribeMapping se puede usar para suscribirse a un tema STOMP; la anotación @DestinationVariable se puede usar para obtener el valor de la variable en el tema STOMP; la anotación @Header se puede usar para obtener el encabezado en el mensaje WebSocket, etc.