RabbitMQ学习(八)——做WebSocket消息代理，集成Spring Boot实现消息实时推送
在前面的几篇文章中，我们讲解了RabbitMQ的大致使用情况，对RabbitMQ的使用有了更细致的了解，今天我们来讲解一下如何使用RabbitMQ来代理WebSocket，并结合Spring Boot实现消息实时推送。
一、WebSocket
WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket通信协议于2011年被IETF定为标准RFC6455，并由RFC7936补充规范。WebSocket API也被W3C定为标准。
WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。
我们知道：HTTP协议是一种无状态的、无连接的、单向的应用层协议。它采用了请求/响应模型。通信请求只能由客户端发起，服务端对请求做出应答处理。
这种通信模型有一个弊端：HTTP 协议无法实现服务器主动向客户端发起消息。
这种单向请求的特点，注定了如果服务器有连续的状态变化，客户端要获知就非常麻烦。大多数 Web 应用程序将通过频繁的异步JavaScript和XML（AJAX）请求实现长轮询。轮询的效率低，非常浪费资源（因为必须不停连接，或者 HTTP 连接始终打开）。
而WebSocket 就是这样发明的，为了解决上面HTTP协议无法解决的问题。WebSocket 连接允许客户端和服务器之间进行全双工通信，以便任一方都可以通过建立的连接将数据推送到另一端。WebSocket 只需要建立一次连接，就可以一直保持连接状态。这相比于轮询方式的不停建立连接显然效率要大大提高。
Web浏览器和服务器都必须实现 WebSockets 协议来建立和维护连接。由于 WebSockets 连接长期存在，与典型的HTTP连接不同，对服务器有重要的影响。
二、在RabbitMQ中启用WebSocket
通过官方的文档查询我们知道，在RabbitMQ中使用WebSocket是通过STOMP协议来实现的，如下：
因此我们需要启用插件rabbitmq_stomp，确保stomp协议可以，接着我们再启用rabbitmq_web_stomp开启websocket协议。
我们在RabbitMQ服务中启动插件，
rabbitmq-plugins enable rabbitmq_stomp
rabbitmq-plugins enable rabbitmq_web_stomp
然后重启RabbitMQ服务service rabbitmq-server restart。
其中RabbitMQ运行在15672端口，stomp服务运行在15674端口。
更多关于STOMP上使用WebSocket的原理可以查看文档。
三、结合Spring Boot实战
首先我们构建一个Spring Boot工程，然后在pom的依赖里面添加需要的包，这里添加如下：
org.springframework.boot
spring-boot-starter-amqp
org.springframework.boot
spring-boot-starter-websocket
org.springframework.boot
spring-boot-starter-reactor-netty
创建名为WebSocketConfig.java的类来配置WebSocket，实现配置接口WebSocketMessageBrokerConfigurer。
package net.anumbrella.rabbitmq.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.ChannelRegistration;
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 org.springframework.web.socket.config.annotation.WebSocketTransportRegistration;
/**
* @author Anumbrella
*/
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketConfig.class);
@Autowired
private MyChannelInterceptor inboundChannelInterceptor;
@Autowired
private AuthHandshakeInterceptor authHandshakeInterceptor;
@Autowired
private MyHandshakeHandler myHandshakeHandler;
@Override
public void configureMessageBroker(MessageBrokerRegistry registry) {
registry.enableStompBrokerRelay("/topic", "/queue")
.setRelayHost("localhost") // rabbitmq-host服务器地址
.setRelayPort(61613) // rabbitmq-stomp 服务器服务端口
.setClientLogin("guest") // 登陆账户
.setClientPasscode("guest"); // 登陆密码
//定义一对一推送的时候前缀
registry.setUserDestinationPrefix("/user/");
//客户端需要把消息发送到/message/xxx地址
registry.setApplicationDestinationPrefixes("/message");
LOGGER.info("init rabbitmq websocket MessageBroker complated.");
}
/**
* 连接站点配置
*
* @param registry
*/
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/ws").setAllowedOrigins("*")
.setHandshakeHandler(myHandshakeHandler)
.addInterceptors(authHandshakeInterceptor)
.withSockJS();
LOGGER.info("init rabbitmq websocket endpoint ");
}
/**
* 输入通道配置
*
* @param registration
*/
@Override
public void configureClientInboundChannel(ChannelRegistration registration) {
registration.interceptors(inboundChannelInterceptor);
registration.taskExecutor() // 线程信息
.corePoolSize(400) // 核心线程池
.maxPoolSize(800) // 最多线程池数
.keepAliveSeconds(60); // 超过核心线程数后，空闲线程超时60秒则杀死
}
/**
* 消息传输参数配置
*
* @param registration
*/
@Override
public void configureWebSocketTransport(WebSocketTransportRegistration registration) {
registration.setSendTimeLimit(15 * 1000) // 超时时间
.setSendBufferSizeLimit(512 * 1024) // 缓存空间
.setMessageSizeLimit(128 * 1024); // 消息大小
}
}
上面的注释讲解得也挺清楚的，这里大致说一下重点：
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/ws").setAllowedOrigins("*")
.setHandshakeHandler(myHandshakeHandler)
.addInterceptors(authHandshakeInterceptor)
.withSockJS();
LOGGER.info("init rabbitmq websocket endpoint ");
}
registerStompEndpoints(StompEndpointRegistry registry)，这个方法的作用是添加一个服务端点，来接收客户端的连接。
addEndpoint("/ws")表示添加了一个/ws端点，客户端就可以通过这个端点来进行连接。
setHandshakeHandler(myHandshakeHandler)，这个方法是自定义处理拦截器，在这里可以验证Socket连接的用户是否可靠。
addInterceptors(authHandshakeInterceptor)，这个方法是添加一个TCP手势处理连接操作，是在WebSocket连接建立之前的操作。
withSockJS()的作用是开启SockJS支持。
@Override
public void configureMessageBroker(MessageBrokerRegistry registry) {
registry.enableStompBrokerRelay("/topic", "/queue")
.setRelayHost("localhost") // rabbitmq-host服务器地址
.setRelayPort(61613) // rabbitmq-stomp 服务器服务端口
.setClientLogin("guest") // 登陆账户
.setClientPasscode("guest"); // 登陆密码
//定义一对一推送的时候前缀
registry.setUserDestinationPrefix("/user/");
//客户端需要把消息发送到/message/xxx地址
registry.setApplicationDestinationPrefixes("/message");
LOGGER.info("init rabbitmq websocket MessageBroker complated.");
}
configureMessageBroker(MessageBrokerRegistry config)，这个方法的作用是定义消息代理，通俗一点讲就是设置消息连接请求的各种规范信息。
enableSimpleBroker("/topic")，表示客户端订阅地址的前缀信息，也就是客户端接收服务端消息的地址的前缀信息。
setUserDestinationPrefix("/user/")，表示指定一对一发送队列的前缀。
registry.setApplicationDestinationPrefixes("/message")指服务端接收地址的前缀，意思就是说客户端给服务端发消息的地址的前缀。
自定义AuthHandshakeInterceptor类，是在WebSocket连接建立之前的操作。如下：
package net.anumbrella.rabbitmq.config;
import net.anumbrella.rabbitmq.util.SpringContextUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;
import javax.servlet.http.HttpSession;
import java.util.Map;
/**
* @author Anumbrella
*/
@Component
public class AuthHandshakeInterceptor implements HandshakeInterceptor {
private static final Logger LOGGER = LoggerFactory.getLogger(AuthHandshakeInterceptor.class);
@Override
public boolean beforeHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map map) throws Exception {
LOGGER.info("===============before handshake=============");
// 在beforeHandshake中可以获取socket连接URL中的参数
// 在这里可以获取session，做用户登录判断依据，这里只做了简单处理
// HttpSession session = SpringContextUtils.getSession();
// session.getAttribute("session_key") 判断具体的session存在
// 比如，只有登录后，才可以进行websocket连接
ServletServerHttpRequest serverRequest = (ServletServerHttpRequest) serverHttpRequest;
String user = serverRequest.getServletRequest().getParameter("user");
if (user != null) {
return true;
}
return false;
}
@Override
public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
LOGGER.info("===============after handshake=============");
}
}
新建我们频道相关处理类，MyChannelInterceptor。如下：
package net.anumbrella.rabbitmq.config;
import net.anumbrella.rabbitmq.entity.MyPrincipal;
import net.anumbrella.rabbitmq.util.SocketSessionRegistry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
import org.springframework.messaging.simp.stomp.StompCommand;
import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
import org.springframework.messaging.support.ChannelInterceptor;
import org.springframework.messaging.support.ChannelInterceptorAdapter;
import org.springframework.messaging.support.MessageHeaderAccessor;
import org.springframework.stereotype.Component;
import java.util.LinkedList;
import java.util.Map;
/**
* @author Anumbrella
*/
@Component
public class MyChannelInterceptor extends ChannelInterceptorAdapter {
@Autowired
private SocketSessionRegistry webAgentSessionRegistry;
@Override
public Message preSend(Message message, MessageChannel channel) {
StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
if (StompCommand.CONNECT.equals(accessor.getCommand())) {
System.out.println("连接success");
Object raw = message.getHeaders().get(SimpMessageHeaderAccessor.NATIVE_HEADERS);
if (raw instanceof Map) {
Object name = ((Map) raw).get("name");
if (name instanceof LinkedList) {
String id = ((LinkedList) name).get(0).toString();
//设置当前访问器的认证用户
accessor.setUser(new MyPrincipal(id));
String sessionId = accessor.getSessionId();
// 统计用户在线数，可通过redis来实现更好
webAgentSessionRegistry.registerSessionId(id, sessionId);
}
}
} else if (StompCommand.DISCONNECT.equals(accessor.getCommand())) {
//点击断开连接，这里会执行两次，第二次执行的时候，message.getHeaders.size()=5,第一次是6。直接关闭浏览器，只会执行一次，size是5。
System.out.println("断开连接");
MyPrincipal principal = (MyPrincipal) message.getHeaders().get(SimpMessageHeaderAccessor.USER_HEADER);
// 如果同时发生两个连接，只有都断开才能叫做不在线
if (message.getHeaders().size() == 5 && principal.getName() != null) {
String sessionId = accessor.getSessionId();
webAgentSessionRegistry.unregisterSessionId(principal.getName(), sessionId);
}
}
return message;
}
}
这里我只是做了一个简单WebSocket连接的简单处理，如何在连接中包含name参数，就将其赋值为认证标识，这里的MyPrincipal，做了重新覆写，以用户名为准。然后再做其他的操作。
MyPrincipal，
package net.anumbrella.rabbitmq.entity;
import java.security.Principal;
/**
* @author Anumbrella
*/
public class MyPrincipal implements Principal {
private String loginName;
public MyPrincipal(String loginName) {
this.loginName = loginName;
}
@Override
public String getName() {
return loginName;
}
}
同时新建SocketSessionRegistry类，在里面对用户相关统计操作。
package net.anumbrella.rabbitmq.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import java.util.Collections;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CopyOnWriteArraySet;
/**
* @author Anumbrella
*/
@Component
@Scope("singleton")
public class SocketSessionRegistry {
private static final Logger LOGGER = LoggerFactory.getLogger(SocketSessionRegistry.class);
/**
* 这个集合存储session
*/
private final ConcurrentMap> userSessionIds = new ConcurrentHashMap();
private final Object lock = new Object();
public SocketSessionRegistry() {
}
/**
* 获取sessionId
*
* @param userId
* @return
*/
public Set getSessionIds(String userId) {
Set set = (Set) this.userSessionIds.get(userId);
return set != null ? set : Collections.emptySet();
}
/**
* 获取所有session
*
* @return
*/
public ConcurrentMap> getAllSessionIds() {
return this.userSessionIds;
}
/**
* register session
*
* @param userId
* @param sessionId
*/
public void registerSessionId(String userId, String sessionId) {
Assert.notNull(userId, "User ID must not be null");
Assert.notNull(sessionId, "Session ID must not be null");
synchronized (this.lock) {
Object set = (Set) this.userSessionIds.get(userId);
if (set == null) {
set = new CopyOnWriteArraySet();
this.userSessionIds.put(userId, (Set) set);
}
((Set) set).add(sessionId);
}
LOGGER.info("===============当前在线人数=============: " + userSessionIds.size());
}
/**
* remove session
*
* @param userId
* @param sessionId
*/
public void unregisterSessionId(String userId, String sessionId) {
Assert.notNull(userId, "User ID must not be null");
Assert.notNull(sessionId, "Session ID must not be null");
synchronized (this.lock) {
Set set = (Set) this.userSessionIds.get(userId);
if (set != null && set.remove(sessionId) && set.isEmpty()) {
this.userSessionIds.remove(userId);
}
}
LOGGER.info("===============当前在线人数=============: " + userSessionIds.size());
}
}
然后我们添加两个controller类，SendController，ReceiveController类，模拟发送和接收的测试。在这里会使用SimpMessagingTemplate。
使用org.springframework.messaging.simp.SimpMessagingTemplate类可以在服务端的任意地方给客户端发送消息。此外，在我们配置Spring支持STOMP后SimpMessagingTemplate类就会被自动装配到Spring的上下文中，因此我们只需要在想要使用的地方使用@Autowired注解注入SimpMessagingTemplate即可使用。
需要说明的是，SimpMessagingTemplate类有两个重要的方法，它们分别是：
- public void convertAndSend(D destination, Object payload)：给监听了路径destination的所有客户端发送消息payload
- public void convertAndSendToUser(String user, String destination, Object payload)：给监听了路径destination的用户user发送消息payload
SendController类，
package net.anumbrella.rabbitmq.controller;
import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author Anumbrella
*/
@RestController
@RequestMapping("/websocket")
public class SendController {
@Autowired
private SimpMessagingTemplate messagingTemplate;
/**
* 通知消息
*/
@GetMapping("/notice")
public void notice() {
messagingTemplate.convertAndSend("/topic/notice", JSON.toJSONString("这是通知消息！！"));
}
/**
* 具体用户消息
*/
@GetMapping("/user/{name}")
public void user(@PathVariable("name") String name) {
messagingTemplate.convertAndSendToUser(name, "/topic/reply", JSON.toJSONString("这是发送给" + name + "用户的消息！！"));
}
}
ReceiveController类，
package net.anumbrella.rabbitmq.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.stereotype.Controller;
/**
* @author Anumbrella
*/
@Controller
public class ReceiveController {
private static final Logger LOGGER = LoggerFactory.getLogger(ReceiveController.class);
@MessageMapping("/client")
public void all(String message) {
LOGGER.info("*** 来自客户端的消息 ***:" + message);
}
}
到此我们后端代码基本完成，关于前端使用Socket，RabbitMQ推荐使用stomp-websocket。
这里我结合一个React的demo来进行讲解一下，核心代码如下：
let client = Stomp.over(new SockJS('http://localhost:8080/ws?user=211'));
client.heartbeat.outgoing = 0;
client.heartbeat.incoming = 0;
this.setState(() => ({
wsClient: client
}));
client.connect({
name: '211',
}, (frame) => {
this.setState(() => ({
connected: true
}));
client.subscribe('/user/topic/reply', (msg) => {
const messages = this.state.pMessages;
msg.id = Date.now();
const newMessages = messages.concat([msg]);
this.setState(() => ({
pMessages: newMessages
}));
});
client.subscribe('/topic/notice', (msg) => {
const messages = this.state.pMessages;
msg.id = Date.now();
const newMessages = messages.concat([msg]);
console.log("notice");
console.log(msg);
this.setState(() => ({
pMessages: newMessages
}));
});
});
}
首先我们使用Stompjs来连接服务端，配置的端点为/ws，至于后面的参数是我在后台加入的判断，如果没参数是无法认证成功，因此用户可以在这里做一下session判断认证，用户是否登录成功等。
ServletServerHttpRequest serverRequest = (ServletServerHttpRequest) serverHttpRequest;
String user = serverRequest.getServletRequest().getParameter("user");
if (user != null) {
return true;
}
return false;
连接成功后，在前端控制台我们可以看到相关输入信息。
在后台我们也可以看到相关连接信息。
然后我们在浏览器中输入http://localhost:8080/websocket/notice，可以发现我们接收到相关信息。
我们在发送一对一信息，http://localhost:8080/websocket/user/211，我们就可以看到接收到具体用户信息。
而当我们输入http://localhost:8080/websocket/user/212，http://localhost:8080/websocket/user/213，是没有消息的，因为我们是没有相关用户监听，必须配置定点用户。
当我们点击前端send发送消息，后端接收到相关信息。
到此，我们简单的基于RabbitMQ做WebSocket消息代理，集成Spring Boot实现消息实时推送就完成了。
代码实例：rabbitmq-websocket。
参考
- https://www.rabbitmq.com/web-stomp.html
- https://www.rabbitmq.com/stomp.html
- http://jmesnil.net/stomp-websocket/doc/
- https://www.zifangsky.cn/1359.html