STOMP Broker em Spring Boot: princípio e uso
Introdução
STOMP (Simple Text Oriented Messaging Protocol) é um protocolo baseado em texto para passar mensagens entre aplicativos da web. O STOMP fornece uma maneira fácil de implementar a comunicação bidirecional por meio do WebSocket. No Spring Boot, podemos usar o STOMP para realizar a comunicação bidirecional do WebSocket.
O STOMP Broker é uma implementação do protocolo STOMP, que é usado para passar mensagens entre aplicativos da web. No Spring Boot, podemos usar o STOMP Broker fornecido pelo módulo Spring WebSocket para implementar a comunicação bidirecional do WebSocket.
Este artigo apresentará o princípio e o uso do STOMP Broker no Spring Boot.
princípio
No Spring Boot, o STOMP Broker é um servidor proxy para passar mensagens entre aplicativos da web. O STOMP Broker permite a comunicação bidirecional entre vários clientes WebSocket. Quando um cliente WebSocket envia uma mensagem, o STOMP Broker encaminhará a mensagem para o cliente WebSocket de destino.
No Spring Boot, podemos usar a anotação @EnableWebSocketMessageBroker para habilitar o agente de mensagens WebSocket. Quando essa anotação é aplicada, o Spring Boot configurará automaticamente o proxy de mensagem WebSocket para que possamos usar anotações como @MessageMapping e @SendTo para processar mensagens WebSocket.
No STOMP Broker, podemos usar a anotação @MessageMapping para processar mensagens WebSocket. Quando um cliente WebSocket envia uma mensagem, o STOMP Broker encaminhará a mensagem para o método de processamento marcado com a anotação @MessageMapping para processamento. O método manipulador pode enviar a mensagem para outro cliente WebSocket ou pode enviar a mensagem para um tópico STOMP específico.
Aqui está um exemplo simples:
@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() + "!");
}
}
}
No exemplo acima, definimos uma classe de configuração Spring Boot chamada "WebSocketConfig" e ativamos o agente de mensagens WebSocket nela. Usamos a anotação @EnableWebSocketMessageBroker para ativar o agente de mensagens WebSocket e implementamos a interface WebSocketMessageBrokerConfigurer para configurar o agente de mensagens WebSocket.
No método configureMessageBroker, usamos o método config.enableSimpleBroker("/topic") para habilitar um tópico STOMP denominado "/topic". Também usamos o método config.setApplicationDestinationPrefixes("/app") para definir um prefixo de aplicativo chamado "/app" para identificar as mensagens WebSocket do aplicativo.
No método registerStompEndpoints, usamos o método Registry.addEndpoint(“/websocket”).withSockJS() para registrar um endpoint WebSocket denominado “/websocket” e ativar o suporte SockJS.
No controlador WebSocket, definimos um método de processamento marcado com a anotação @MessageMapping, que é usada para processar a mensagem WebSocket chamada "/hello" e enviar o resultado do processamento para o tema "/topic/greetings" do STOMP.
Como usar
O processo de uso do STOMP Broker para processar mensagens WebSocket é muito simples. Precisamos apenas definir um ou mais métodos de processamento marcados com a anotação @MessageMapping no controlador WebSocket e usar a anotação @SendTo para enviar os resultados do processamento para o tópico STOMP especificado.
Em nosso método manipulador, podemos usar a anotação @Payload para identificar a carga útil da mensagem WebSocket. Neste exemplo, usamos a anotação @Payload para desserializar a carga da mensagem WebSocket em um objeto HelloMessage.
Além da anotação @MessageMapping e da anotação @SendTo, o Spring Boot também fornece muitas outras anotações e ferramentas para nos ajudar a processar mensagens WebSocket com mais facilidade. Por exemplo, a anotação @SubscribeMapping pode ser usada para assinar um tópico STOMP; a anotação @DestinationVariable pode ser usada para obter o valor da variável no tópico STOMP; a anotação @Header pode ser usada para obter o cabeçalho na mensagem WebSocket, etc.
Aqui está um exemplo simples mostrando como usar o STOMP Broker para processar mensagens WebSocket:
1. Adicione dependências
Primeiro, precisamos adicionar dependências WebSocket e STOMP ao nosso aplicativo Spring Boot. Adicione as seguintes dependências ao nosso arquivo 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. Configure o agente de mensagens WebSocket
Em seguida, precisamos configurar o agente de mensagens WebSocket em nosso aplicativo Spring Boot. Adicione a anotação @EnableWebSocketMessageBroker à nossa classe de configuração para habilitar a intermediação de mensagens 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();
}
}
No exemplo acima, usamos o método config.enableSimpleBroker("/topic") para habilitar um tópico STOMP chamado "/topic" e usamos o método config.setApplicationDestinationPrefixes("/app") para definir um tópico STOMP chamado "/ topic" app", que é usado para identificar a mensagem WebSocket do aplicativo. Também usamos o método Registry.addEndpoint(“/websocket”).withSockJS() para registrar um endpoint WebSocket denominado “/websocket” e habilitar o suporte SockJS.
3. Escreva um controlador WebSocket
Em seguida, precisamos escrever um controlador WebSocket para lidar com mensagens WebSocket. Em nossos controladores, podemos usar a anotação @MessageMapping para processar mensagens WebSocket e usar a anotação @SendTo para enviar os resultados do processamento para o tópico 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() + "!");
}
}
No exemplo acima, definimos um controlador WebSocket marcado com a anotação @Controller e definimos um método de processamento chamado "/hello" nele para processar mensagens WebSocket. Usamos a anotação @Payload para desserializar a carga útil da mensagem WebSocket em um objeto HelloMessage e usamos a anotação @SendTo para enviar o resultado do processamento para o tópico STOMP chamado "/topic/greetings".
4. Escreva um cliente WebSocket
Por fim, precisamos escrever um cliente WebSocket para enviar mensagens WebSocket e receber os resultados do processamento. Em nosso cliente, podemos usar StompClient para conectar ao servidor WebSocket e usar StompSession para enviar e receber mensagens 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"));
}
}
}
No exemplo acima, definimos uma classe chamada "WebSocketClient" e implementamos nela um método chamado "connect". No método connect, usamos WebSocketStompClient para conectar ao servidor WebSocket e implementamos uma classe StompSessionHandler chamada "MyStompSessionHandler", que é usada para manipular o StompSession conectado ao servidor WebSocket.
Na classe MyStompSessionHandler, usamos o método session.subscribe(“/topic/greetings”, new StompFrameHandler() {…}) para assinar o tópico STOMP denominado “/topic/greetings” e definimos uma classe StompFrameHandler para manipular o mensagens STOMP recebidas. Também enviamos um objeto HelloMessage para o tópico STOMP chamado "/hello" usando o método session.send("/app/hello", new HelloMessage("World")).
Resumir
O STOMP Broker no Spring Boot é um servidor proxy para passar mensagens entre aplicativos da web. O STOMP Broker permite a comunicação bidirecional entre vários clientes WebSocket. No Spring Boot, podemos usar o STOMP Broker fornecido pelo módulo Spring WebSocket para implementar a comunicação bidirecional do WebSocket.
No STOMP Broker, podemos usar a anotação @MessageMapping para processar mensagens WebSocket. Quando um cliente WebSocket envia uma mensagem, o STOMP Broker encaminhará a mensagem para o método de processamento marcado com a anotação @MessageMapping para processamento. O método manipulador pode enviar a mensagem para outro cliente WebSocket ou pode enviar a mensagem para um tópico STOMP específico.
O processo de uso do STOMP Broker para processar mensagens WebSocket é muito simples. Precisamos apenas definir um ou mais métodos de processamento marcados com a anotação @MessageMapping no controlador WebSocket e usar a anotação @SendTo para enviar os resultados do processamento para o tópico STOMP especificado.
Ao escrever um cliente WebSocket, podemos usar StompClient para conectar ao servidor WebSocket e usar StompSession para enviar e receber mensagens STOMP.
Por fim, o Spring Boot fornece muitas outras anotações e ferramentas para nos ajudar a processar mensagens WebSocket com mais facilidade. Por exemplo, a anotação @SubscribeMapping pode ser usada para assinar um tópico STOMP; a anotação @DestinationVariable pode ser usada para obter o valor da variável no tópico STOMP; a anotação @Header pode ser usada para obter o cabeçalho na mensagem WebSocket, etc.