Spring Stomp的使用

本文主要讲spring boot项目中spring stomp的使用

依赖

	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-messaging</artifactId>
	    <version>5.2.14</version>
	</dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
        <version>5.2.14</version>
    </dependency>

配置

增加如下配置类，添加注解@EnableWebSocketMessageBroker

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
   
}

配置即 实现WebSocketMessageBrokerConfigurer类的不同的方法。接下来逐一说明。

连接配置

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
    	// 类似于http的 contextPath。如此配置后，连长链的url为：http://domain/myWeb
        registry.addEndpoint("/myWeb")
        		.setAllowedOrigins("*")
        		// 配置长链握手的拦截器：拦截点有握手前和握手后。握手前可以做一些校验工作
                .addInterceptors(new MyHandshakeInterceptor())
                // 握手处理器，在此类中可以处理一些握手的工作，比如确定Principle
                .setHandshakeHandler(new MyHandshakeHandler())
                // 使用socketjs
                .withSockJS();
    }

消息通道配置

通道配置分为入站通道和出站通道。
spring为了松散耦合，将消息的处理分为了消息的生产者和消费者，两者通过消息通道连接。详细的关于消息通道的介绍单开一篇。现在只需要知到，消息到达服务端并节吗后，经过入站消息通道clientInBoundChannel，将消息交给各个MessageHandler进行处理。经过simple broker处理的消息，转发给不同的客户端，也要经过出站通道clientOutBoundChannel。

消息入站通道

    @Resource
    private TaskScheduler messageBrokerTaskScheduler;
    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        registration.interceptors(cInboundChannelIntercepter());
        registration.interceptors(testIneterceptor());
        // ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        // taskExecutor.setCorePoolSize(5);
        registration.taskExecutor(messageBrokerTaskScheduler);
    }
    @Bean
    public TestIneterceptor testIneterceptor(){
        return new TestIneterceptor();
    }
    @Bean
    public CInboundChannelIntercepter cInboundChannelIntercepter(){
        return new CInboundChannelIntercepter();
    }

下面对这三个配置进行说明

线程池

消息被处理是在线程池中执行的，不配置默认也会有一个线程池，其核心线程数是2*N

CInboundChannelIntercepter

入站通道拦截器（cInboundChannelIntercepter）：对从客户端发来的消息在被处理前和后拦截

消息到达服务端后：

• 交由各个MessageHandler处理前，会调用入站通道拦截器的preSend方法；
• 消息交给各个MessageHandler处理后：
  • 如果没有发生异常会调用postSend方法与afterSendCompletion方法；
  • 如果发生了异常，则在catch块调用afterSendCompletion方法

public class CInboundChannelIntercepter implements ChannelInterceptor {

}

TestInterceptor

上面说过MessageHandler处理消息是在线程池内执行的，而ChannelInterceptor#preSend是在主线程调用的，有没有和消息处理过程在同一个线程内的拦截呢？答案是有

public class TestIneterceptor implements ExecutorChannelInterceptor {
    @Override
    public Message<?> beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler) {
       
        return ExecutorChannelInterceptor.super.beforeHandle(message, channel, handler);
    }
}

beforeHandle方法就是在具体处理message前调用的。

消息出站通道

与入站通道配置一样，并且出站通道与入站通道的实现都是同一个累，只是处于的阶段不一样：入站通道时处理客户端发往服务端的消息，出站通道是处理从服务端发往客户端的。

MessageBroker配置

@Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        // 
        SimpleBrokerRegistration bBroker = registry.enableSimpleBroker("queue");
        // 配置心跳
        bBroker.setHeartbeatValue(new long[]{1000, 5000}).setTaskScheduler(this.messageBrokerTaskScheduler);

        // SEND消息的destination以book、shop开头的，都会被路由到被Controller注解的类的对应方法
        registry.setApplicationDestinationPrefixes("app");
 		
        // registry.setUserDestinationPrefix("/user");
        
        // registry.setPreservePublishOrder(true);//配置消息有序性，性能会变差
    }

这个方法主要配置三种MessageHandler需要处理的消息的destination的前缀，以此配置来确定哪些消息需要被哪些MessageHandler处理。

simple broker配置

如果不配置，默认有topic、queue两个值，即simple broker会处理topic、queue开头的消息。

注意，如果自己配置的话，需要至少有一个queue，因为@SendToUser注解依赖于这个。

心跳配置
因为broker维护与各个客户度的连接，所以在broker中配置心跳。
心跳有两个参数：第一个值表示服务端向客户端发送心跳的间隔（单位毫秒）；第二个值表示服务端期望收到客户端发送的心跳的间隔。

配置心跳，必须配置TaskScheduler，否则无心跳。
如果只配置TaskScheduler，则心跳默认值为[10000,10000]

ApplicationDestinationPrefixes配置

destination以app开头的 消息，都会被WebSocketAnnotationMethodMessageHandler处理

UserDestinationPrefix配置

destination以book、shop开头的 消息都会被UserDestinationMessageHandler处理。

WebSocketTransport

    @Override
    public void configureWebSocketTransport(WebSocketTransportRegistration registry) {
        registry.setSendTimeLimit(15 * 1000).setSendBufferSizeLimit(512 * 1024);
        registry.addDecoratorFactory(handler -> mySessionHandler(handler));
    }
    @Bean
    public MySessionHandler mySessionHandler(WebSocketHandler delegate) {
        return new MySessionHandler(delegate);
    }

这里主要说一下WebSocketHandler配置，这个是什么作用呢？我们一般情况下会有维护用户session的配置，比如做单点限制。

public class MySessionHandler extends WebSocketHandlerDecorator {
	public MySessionHandler(WebSocketHandler delegate) {
		super(delegate);
	}
	
	@Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        super.afterConnectionEstablished(session);
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        super.handleTransportError(session, exception);

    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
        super.afterConnectionClosed(session, closeStatus);

    }

}

如上，session建立后，afterConnectionEstablished方法会被调用；其实spring-websocket通过装饰者模式，层层包装，用户建立连接后，会层层调用各个WebSocketHandlerDecorator的方法。

使用

服务端：

@Controller
@Slf4j
@MessageMapping("book")
public class BookController {
	/**
	 * 
	 */
    @MessageMapping("list")
    @SendToUser(broadcast = false)
    public List<Book> bookList(Message message, MessageHeaders messageHeaders, Principal principal, StompHeaderAccessor accessor) throws InterruptedException {
        return new ArrayList<>();
    }
    @Resource
    private SimpMessagingTemplate simpMessagingTemplate;
    @MessageMapping("list2")
    public void> bookList(Message message, MessageHeaders messageHeaders, Principal principal, StompHeaderAccessor accessor) throws InterruptedException {
        simpMessagingTemplate.convertAndSend()
    }
}

可以通过@SendToUser将方法返回值原路返回，也可以通过simpMessagingTemplate自定义消息 发送路径。

客户端：

let sock = new SockJS("http://localhost:8080/myWeb?token="+userToken);
let stomp = webstomp.over(sock);
stomp.connect({}, function (frame) {
    stomp.subscribe("/user/queue/book/list",function (message) {
        console.log("get response:"+message)
    })
}
// 发往controller
stomp.send("/app/book/list", JSON.stringify(content));
// 发往另一个用户
// stomp.send("/user/mike/queue/book/readComplete", JSON.stringify(content));
// 发往所有用户
// stomp.send("/topic/book/onSale", JSON.stringify(content));