记录springBoot使用SOCKJS+STOMP长连接
概览
WebSocket
- WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket通信协议于2011年被IETF定为标准RFC 6455，并由RFC7936补充规范。WebSocket API也被W3C定为标准。
WebSocket 面临的问题
- 某些浏览器中缺乏对 WebSocket 的支持。支持 WebSocket 的第一个 Internet Explorer version 是 version 10(请参阅http://caniuse.com/websockets以获得浏览器版本的支持)。某些限制性代理配置会阻止尝试进行 HTTP 升级，要么在一段时间之后以其他方式 break 连接。
- 与 HTTP(一种 application-level 协议)不同，在 WebSocket 协议中，传入消息中的信息不足以让 framework 或容器知道如何对其进行 route 路由或处理它。因此，除了非常简单的应用程序之外WebSocket 可以说太底层了。
STOMP
- 一种简单的消息传递协议，最初创建用于脚本语言，其框架受 HTTP 启发。 STOMP 得到广泛支持，非常适合在 WebSocket 和 web 上使用。
SockJS
- SockJS是WebSocket技术的一种模拟，在表面上，它尽可能使用原生webSocket API，但是再底层非常智能，优先使用原生WebSocket，如果在不支持WebSocket的浏览器中，会自动降为轮询的方式。
何时使用
- 最适合WebSocket的是需要客户端和服务器以高频率和低延迟交换事件的web应用。
SockJS
SockJS 包括
- SockJS 协议以可执行文件叙述测试的形式定义。
- SockJS JavaScript client - 用于浏览器的 client library。
- Spring Framework spring-websocket模块中包括了一个SockJS服务器的实现。
- spring-websocket在4.1版本后提供了一个 SockJS Java client。
SockJS传输类型
- WebSocket
- HTTP Streaming (服务器保持响应打开，当有新的事件的时候就发送，需要约定开始和结束协议)
- HTTP Long Polling
SockJS传输类型选择
- 首先发送"GET /info"以从服务器获取基本信息。之后，决定使用什么传输。如果可能，使用 WebSocket。如果没有，在大多数浏览器中至少有一个 HTTP 流选项，如果没有，则使用 HTTP(long)轮询。
传输请求URL 结构
http://host:port/myApp/myEndpoint/{server-id}/{session-id}/{transport}
- {server-id} - 用于在 cluster 中路由请求。
- {session-id} - 关联属于 SockJS session 的 HTTP 请求。
- {transport} - 表示传输类型，e.g. “websocket”，“xhr-streaming”等
如何启用 SockJS：@EnableWebSocket
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(myHandler(), "/myHandler").withSockJS();
}
@Bean
public WebSocketHandler myHandler() {
return new MyHandler();
}
}
SockJsClient
- 用于在不使用浏览器的情况下连接到 remote SockJS endpoints。
创建 SockJS client 并连接到 SockJS 端点
List<Transport> transports = new ArrayList<>(2);
transports.add(new WebSocketTransport(new StandardWebSocketClient()));
transports.add(new RestTemplateXhrTransport());
SockJsClient sockJsClient = new SockJsClient(transports);
sockJsClient.doHandshake(new MyWebSocketHandler(), "ws://example.com:8080/sockjs");
STOMP
STOMP协议
-
WebSocket 协议定义了两种类型的消息，文本和二进制，但它们的内容是未定义的。客户端和服务端需要一种子协议（比如更高级的协议）来帮助解释消息。
-
STOMP是一个简单面向文本的消息传递协议
-
STOMP是一种基于帧的协议，其帧在HTTP上建模。STOMP帧的框架结构：
COMMAND
header1:value1
header2:value2
Body^@
使用STOMP协议好处
- 无需发明自定义消息传递协议和消息格式
- 浏览器可直接使用现有的stomp.js库
- 能够根据目的将消息路由
- 可以使用成熟的消息代理，如RabbitMQ、ActiveMQ等广播消息
启用STOMP
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/portfolio").withSockJS();
}
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.setApplicationDestinationPrefixes("/app");
config.enableSimpleBroker("/topic", "/queue");
}
}
消息流
基于注解的消息处理示例
@Slf4j
@Controller
public class RestWebSocketController {
/**
* 发起一条广播消息
* @param principal 身份标识
* @param message 接收的消息体
* @return 广播发送的消息
*/
@MessageMapping("/app-test/topic")
@SendTo("/topic/ping")
public GreetingResponse topic(Principal principal, String message) {
log.info("来自{}的消息{}", principal.getName(), message);
return new GreetingResponse("Hello,Spring,这是客户端主动拉取的topic消息!");
}
/**
* 发送消息到当前请求用户
* @param principal 身份标识
* @param message 接收的消息体
* @return 发送到当前请求用户的消息
*/
@MessageMapping({
"/app-test/user"})
@SendToUser(value = "/ping", broadcast = false)
public GreetingResponse queue(Principal principal, String message) {
log.info("来自{}的消息{}", principal.getName(), message);
return new GreetingResponse("Hello," + principal.getName() + ",这是客户端主动拉取的topic消息!");
}
}
-
@MessageMapping 用在@Controller注解的类中，根据目的地路由消息的方法
-
@SendTo 自定义要将有效内容发送到的目标，一般用于广播消息
-
@SendToUser 是仅向与消息关联的用户发送消息
-
使用SimpMessagingTemplate发送消息
public class WebSocketHelperImpl {
@Autowired
private SimpMessagingTemplate messagingTemplate;
/**
* 通过websocket点对点发送单一定阅用户
*
* @param subsAdd 用户的定阅地址，不需要拼接前缀和用户id
* @param msg 发送的内容，Json字符串格式
* @param userId userId,需要发送的用户SaasCode
*/
public void sendToUser(String subsAdd, Object msg, String userId) {
messagingTemplate.convertAndSendToUser(userId, subsAdd, msg);
log.info("Send to user {} through webSocket successful!", userId);
}
/**
* 通过websocket点对点发送多个定阅用户
*
* @param subsAdd 用户的定阅地址，不需要拼接前缀和用户id
* @param msg 发送的内容，Json字符串格式
* @param userIds 需要发送的用户id数组
*/
public void sendToUsers(String subsAdd, Object msg, String[] userIds) {
if (userIds != null && userIds.length > 0) {
for (String userId : userIds) {
sendToUser(subsAdd, msg, userId);
}
}
}
/**
* 通过websocket广播消息,发给所有定阅用户
*
* @param subsAdd 用户的定阅地址
* @param msg 发送的内容，Json字符串格式
*/
public void broadCast(String subsAdd, Object msg) {
messagingTemplate.convertAndSend(subsAdd, msg);
log.info("BroadCast through webSocket successfully!");
}
}
握手拦截器、握手处理器
/**
* 功能简介：基于stomp协议的webSocket配置
* 功能详解：wsTopicEndPoint和wsQueueEndPoint是两个端点，一个用于点对点通信, 另一个用于广播通信; 端点用于建立连接
* topic 和 queue是消息代理地址前缀，一个用于点对点，一个用于广播；这个前缀用于区分消息发送的目的地
*
* @author alwaysBrother
* @date 2019/12/17
*/
@Slf4j
@Configuration
@EnableConfigurationProperties(WebSocketProperties.class)
@EnableWebSocketMessageBroker
public class WebSocketConfiguration implements WebSocketMessageBrokerConfigurer {
@Autowired
private WebSocketProperties webSocketProperties;
@Autowired
private TokenService tokenService;
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic", "/user");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
// 用于广播的endPoint
registry.addEndpoint(webSocketProperties.getTopicEndPoint())
.addInterceptors(interceptor)
.setHandshakeHandler(handshakeHandler)
.setAllowedOrigins("*")
.withSockJS();
// 用于点对点通信的endPoint
registry.addEndpoint(webSocketProperties.getUserEndPoint())
.addInterceptors(interceptor)
.setHandshakeHandler(handshakeHandler)
.setAllowedOrigins("*")
.withSockJS();
}
@Override
public void configureWebSocketTransport(WebSocketTransportRegistration registry) {
// The default value is 10 seconds (i.e. 10 * 10000).
registry.setSendTimeLimit(15 * 1000)
// the default value is 512K (i.e. 512 * 1024).
.setSendBufferSizeLimit(512 * 1024)
// The default value is 64K (i.e. 64 * 1024).
.setMessageSizeLimit(64 * 1024);
}
private HandshakeInterceptor interceptor = new HandshakeInterceptor() {
@Override
public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response,
WebSocketHandler wsHandler, Map<String, Object> attributes) {
ServletServerHttpRequest req = (ServletServerHttpRequest) request;
String token = req.getServletRequest().getHeader(HeaderConstants.TOKEN);
if (StringUtils.isEmpty(token)) {
log.error("token is empty, webSocket connect can`t be establish");
return false;
}
TokenDTO tokenDTO = tokenService.parseToken(token);
if (tokenDTO == null || !tokenDTO.getTokenValid() || StringUtils.isEmpty(tokenDTO.getUserId())) {
log.error("token is invalid, webSocket connect can`t be establish");
return false;
}
attributes.put("userId", tokenDTO.getUserId());
return true;
}
@Override
public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response,
WebSocketHandler wsHandler, Exception exception) {
}
};
private DefaultHandshakeHandler handshakeHandler = new DefaultHandshakeHandler() {
@Override
protected Principal determineUser(ServerHttpRequest request, WebSocketHandler wsHandler,
Map<String, Object> attributes) {
return new UserPrincipal((String) attributes.get("userId"));
}
};
}
测试程序
@Slf4j
public abstract class AbsWebClient {
protected static ThreadFactory sockJsThreadFactory = new ThreadFactoryBuilder()
.setNameFormat("socket-client-pool-%d").build();
protected ExecutorService executor = new ThreadPoolExecutor(3, 100,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<>(100),
sockJsThreadFactory,
new ThreadPoolExecutor.AbortPolicy());
@LocalServerPort
private int port;
protected class Connect implements Runnable {
/**
* 要建立连接需要有token
*/
private String token;
/**
* 连接点
*/
private String endPoint;
/**
* 订阅地址
*/
private String subAddress;
public Connect(String token, String endPoint, String subAddress) {
this.token = token;
this.endPoint = endPoint;
this.subAddress = subAddress;
}
@Override
public void run() {
// 客户端
WebSocketStompClient stompClient = createStompClient();
// 订阅、接收消息
StompSessionHandler handler = new PandaQueueSessionHandler(subAddress);
// headers
WebSocketHttpHeaders headers = new WebSocketHttpHeaders();
headers.add("token", token);
stompClient.connect("ws://localhost:{port}/{endPoint}", headers, handler, port, endPoint);
}
}
protected static WebSocketStompClient createStompClient() {
List<Transport> transports = new ArrayList<>();
transports.add(new WebSocketTransport(new StandardWebSocketClient()));
SockJsClient sockJsClient = new SockJsClient(transports);
WebSocketStompClient stompClient = new WebSocketStompClient(sockJsClient);
stompClient.setMessageConverter(new MappingJackson2MessageConverter());
return stompClient;
}
/**
* 用来建立连接后订阅一个地址，并扩展其他业务
*/
class AppQueueSessionHandler extends StompSessionHandlerAdapter {
private String subAddress;
public PandaQueueSessionHandler(String subAddress) {
this.subAddress = subAddress;
}
@Override
public void afterConnected(final StompSession session, StompHeaders connectedHeaders) {
session.subscribe(subAddress, new PandaStompFrameHandler());
afterSubscribe(session);
}
}
/**
* 用来处理消息
*/
static class AppStompFrameHandler implements StompFrameHandler {
@Override
public Type getPayloadType(StompHeaders headers) {
return GreetingResponse.class;
}
@Override
public void handleFrame(StompHeaders headers, Object payload) {
GreetingResponse greetingResponse = (GreetingResponse) payload;
try {
if (greetingResponse != null) {
log.info("===============success received===========\n {}",
greetingResponse.getContent());
}
} catch (Throwable t) {
log.info("================failed received~~~~~~~~~~\n", t);
}
}
}
protected abstract void afterSubscribe(StompSession session);
}
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class QueueTest extends AbsWebClient {
@Autowired
private TokenService tokenService;
private String endPoint = "/app-user-endPoint";
private String token = "***";
/**
* 两个用户，使用同一个用户id订阅消息,会各自收到一次发送给订阅id用户的消息
*
* @throws InterruptedException
*/
@Test
public void broadCastTest() throws InterruptedException {
Connect connect1 = new Connect(tokenService.getToken(), endPoint, "/user/S4NbecfYB1ACT6IPAPE5DQ/ping");
Connect connect2 = new Connect(token, endPoint, "/user/S4NbecfYB1ACT6IPAPE5DQ/ping");
executor.execute(connect1);
executor.execute(connect2);
Thread.sleep(10 * 1000);
}
/**
* 两个用户，使用各自用户id订阅消息,会各自收到订阅id的消息
*
* @throws InterruptedException
*/
@Test
public void banBroadCastTest() throws InterruptedException {
Connect connect1 = new Connect(tokenService.getToken(), endPoint, "/user/S4NbecfYB1ACT6IPAPE5DQ/ping");
Connect connect2 = new Connect(token, endPoint, "/user/S4NbecfYB1BUUB3Q0232D9/ping");
executor.execute(connect1);
executor.execute(connect2);
Thread.sleep(10 * 1000);
}
protected void afterSubscribe(StompSession session) {
try {
session.send("/app-test/user", "Spring");
} catch (Throwable t) {
log.error("client send to server error", t);
}
}
}
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = AppTest.class)
public class TopicTest {
@Autowired
private TokenService tokenService;
@LocalServerPort
private int port;
private WebSocketStompClient stompClient;
private final WebSocketHttpHeaders headers = new WebSocketHttpHeaders();
@Before
public void setup() {
List<Transport> transports = new ArrayList<>();
transports.add(new WebSocketTransport(new StandardWebSocketClient()));
SockJsClient sockJsClient = new SockJsClient(transports);
this.stompClient = new WebSocketStompClient(sockJsClient);
this.stompClient.setMessageConverter(new MappingJackson2MessageConverter());
}
/**
* 测试一个连接
* @throws Exception
*/
@Test
public void topicTest() throws Exception {
final CountDownLatch latch = new CountDownLatch(1);
final AtomicReference<Throwable> failure = new AtomicReference<>();
StompSessionHandler handler = new PandaTestSessionHandler(failure, latch);
headers.add("token", tokenService.getToken());
this.stompClient.connect("ws://localhost:{port}/app-topic-endPoint", this.headers, handler, this.port);
if (latch.await(5, TimeUnit.SECONDS)) {
if (failure.get() != null) {
throw new AssertionError("not receive after 5 seconds", failure.get());
}
}
else {
fail("Greeting not received");
}
}
private static class PandaTestSessionHandler extends StompSessionHandlerAdapter {
private final AtomicReference<Throwable> failure;
private final CountDownLatch latch;
public PandaTestSessionHandler(AtomicReference<Throwable> failure, CountDownLatch latch) {
this.failure = failure;
this.latch = latch;
}
@Override
public void afterConnected(StompSession session, StompHeaders connectedHeaders) {
session.subscribe("/topic/ping", new StompFrameHandler() {
@Override
public Type getPayloadType(StompHeaders headers) {
return GreetingResponse.class;
}
@Override
public void handleFrame(StompHeaders headers, Object payload) {
GreetingResponse greetingResponse = (GreetingResponse) payload;
try {
if (greetingResponse != null) {
log.info("收到服务端回复消息：{}", greetingResponse.getContent());
assertEquals("Hello,Spring,这是客户端主动拉取的topic消息!", greetingResponse.getContent());
}
} catch (Throwable t) {
failure.set(t);
} finally {
session.disconnect();
latch.countDown();
}
}
});
try {
session.send("/app-test/topic", "Spring");
// 以"/topic"开头，可以路由到带注释的控制器中的@MessageMapping方法，而"/topic"和"/queue"消息可以直接路由到消息 broker。
// session.send("/topic/ping", "Spring");
} catch (Throwable t) {
failure.set(t);
latch.countDown();
}
}
}
}
测试表现
- 最大连接数
使用多台机器作为客户端客，每台机器创建线程池，每个现场建立一个和服务器的长连接，经过测试最大可以建立一万个连接。
- 最大消息体
Websocket框架代码中消息大小的限制和消息发送超时时间都是可配置的。理论上 WebSocket 消息的大小几乎是无限的，但实际上WebSocket服务器强加了限制 -例如，Tomcat上的 8K和 Jetty上的 64K。因此，诸如 stomp.js的 STOMPclients 在 16K边界处拆分较大的 STOMP消息，并将它们作为多个 WebSocket消息发送，因此需要服务器缓冲和重新组装。
-
消息推送频率和消息体大小关系（与网络状况、硬件环境有关，参考即可）
本文参考
-
https://docs.spring.io/spring/docs/4.3.3.RELEASE/spring-framework-reference/htmlsingle/#websocket-intro-sub-protocol
-
https://stomp.github.io/stomp-specification-1.2.html
-
https://baike.baidu.com/item/WebSocket/1953845?fr=aladdin
-
https://spring.io/blog/2012/05/08/spring-mvc-3-2-preview-techniques-for-real-time-updates