如何利用springboot快速搭建一个消息推送系统

最近在完善毕设的路上，由于是设计一个远程控制物联网系统，所以服务端到硬件我选用了MQTT协议。因为MQTT的发布/订阅模式很适合这种场景。接下来就来聊聊遇到的一些问题以及解决思路吧。
毕设技术栈：springboot 、swagger、springdata、shiro、JWT、redis、rabbitmq、android（语音控制远程设备）、VUE、axios、ElementUI、arduino核心开发板、ESP32（无线接收模块）

小前奏

既然是基于MQTT协议的，那么前端（Vue）我就想着使用一个支持MQTT的库直接用就好。然后：MQTT库介绍
先安装个MQTT库：

npm install mqtt --save

	var mqtt = require('mqtt')
	var client  = mqtt.connect('mqtt://localhost:1883')
	
	client.on('connect', function () {
	  client.subscribe('presence', function (err) {
	    if (!err) {
	      client.publish('presence', 'Hello mqtt')
	    }
	  })
	})
	
	client.on('message', function (topic, message) {
	  // message is Buffer
	  console.log(message.toString())
	  client.end()
	})

运行上面的代码在vue中，浏览器直接报错了，

WebSocket connection to 'ws://localhost:1883/' failed: 
Connection closed before receiving a handshake response

因为只能在node.js环境下才可以使用，浏览器环境是不支持的，因为数据包浏览器不支持解析，所以会报错。那么，该怎么办呢？
看下文：

一、安装RabbitMQ

这一步去官网直接下载安装就好了。RabbitMQ官网。
安装rabbitMQ,首先需要安装erlang
在这里查看版本适配：https://www.rabbitmq.com/which-erlang.html

二、开启插件

进入sbin目录。
1.启对mqtt的支持

rabbitmq-plugins enable rabbitmq_mqtt

2.开启web管理

rabbitmq-plugins enable rabbitmq_management

web在线管理：http://127.0.0.1:15672
默认账号密码：guest

3.开启 stomp

rabbitmq-plugins enable rabbitmq_web_stomp
rabbitmq-plugins enable rabbitmq_web_stomp_examples

三、安装库

npm install sockjs-client --save
npm install stompjs --save

四、引入库

  import SockJS from 'sockjs-client';
  import Stomp from 'stompjs';

五、执行代码

 function mqttStart() {
     console.log("进入mqtt初始化");
     var ws = new WebSocket('ws://127.0.0.1:15674/ws');
     var client = Stomp.over(ws);

     var on_connect = function () {
          
          console.log('connected');
          client.subscribe('/topic/test', (msg)=> {
              console.log("收到："+msg.body)
          });
      };
      var on_error = function () {
           console.log('error');
       };
     //参数依次为：用户名，密码，连接回调，错误回调，虚拟主机名
     client.connect('guest', 'guest', on_connect, on_error, '/');

}

ps:如果不需要使用stomp协议，又找到可以直接在浏览器环境连接MQTT服务器的库：paho.mqtt，使用这个库的效果跟步骤三四五六一样，但是不推荐这种用法，下面会说原因。

六、开始测试

如上代码订阅了test，所以我给test节点发布了一条消息，前端也成功收到了。

接下来，本文到此结束…emm…不行吧。感觉这也太敷衍了吧。是啊，我们回头看看这种写法有什么不好呢？
看看这段代码吧：

client.connect('guest', 'guest', on_connect, on_error, '/');

这太不好了吧，直接把MQTT服务分配的账号密码暴露在前端，肯定不行吧。对。这样当然不行，怎么解决呢？
直接把Websocket换成sockjs就可以了，因为上面我们已经安装过了Sockjs库，所以改成如下即可：
可以看到，此时我们连接mqtt服务器无需再使用账号密码了，而是通过一个websocket连接，使用stomp协议转化，间接连接了MQTT服务器，连接时带上登陆后的token，后端验证token是否正确，如若正确然后就可以握手成功了。

 mqttStart() {
  	 console.log("进入mqtt初始化");
     this.ws = Stomp.over(new SockJS('http://127.0.0.1:8080/ws?token='+localStorage.token));
     this.ws.heartbeat.outgoing = 0;
     this.ws.heartbeat.incoming = 0;  
     this.ws.connect({
     		//用户唯一识别信息 因为我的项目有web以及android类型，所以这里需要记录是什么类型@web
     		//即为web类型
         name: this.userInfo.username+"@web",
     }, (frame) => {
     	// 专属通知，其中user为前缀，必填，说明该订阅节点为单一通知节点
         this.ws.subscribe('/user/topic/reply', (msg) => {
             console.log( msg.body);
         });
         //系统通知，其中、topic为前缀，后面配置websocket使用了前缀topic,
         this.ws.subscribe('/topic/notice', (msg) => {
             console.log("notice");
             console.log(msg.body);
         });
     });
 }

七、配置后端

7.1 配置websocket

首先配置下springboot，让其websocket配置支持sockjs

package com.correspond.mqtt.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
 * 通过EnableWebSocketMessageBroker
 * 开启使用STOMP协议来传输基于代理(message broker)的消息,
 * 此时浏览器支持使用@MessageMapping 就像支持@RequestMapping一样。
 */
@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) {
        //将其目的地前缀设置为“/topic”这样的话，设置"/topic"
        // Spring就能知道所有目的地前缀为“/topic”的消息都会发送到STOMP代理中。
        registry.enableStompBrokerRelay("/topic")
                .setRelayHost("localhost")      // rabbitmq-host服务器地址
                .setRelayPort(61613)     // rabbitmq-stomp 服务器服务端口
                .setClientLogin("guest")   // 登陆账户
                .setClientPasscode("guest"); // 登陆密码

        //定义一对一推送的时候前缀
        registry.setUserDestinationPrefix("/user/");
        //所有目的地以“/message”打头的消息都将会路由到带有@MessageMapping注解的方法中，而不会发布到代理队列或主题中
        //客户端需要把消息发送到/message/xxx地址
        registry.setApplicationDestinationPrefixes("/message");
    }

    /**
     * 添加这个Endpoint，这样在网页中就可以通过websocket连接上服务,也就是我们配置websocket的服务地址,
     *      并且可以指定是否使用socketjs
     *
     * @param registry
     */
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").setAllowedOrigins("*")
                .setHandshakeHandler(myHandshakeHandler)
                .addInterceptors(authHandshakeInterceptor) //添加拦截处理，这里authHandshakeInterceptor 封装的认证用户信息
                .withSockJS();

        LOGGER.info("com.init rabbitmq websocket endpoint ");
    }


    /**
     * 设置输入消息通道的线程数，默认线程为1，可以自己自定义线程数，最大线程数，线程存活时间
     *
     * @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);   // 消息大小
    }


}

7.2 配置websocket握手连接器

由于本项目是采用前后端分离架构，采用了JWT+shiro鉴权。因为我们要保证websocket服务器是不能被任意连接的，所以我们前端使用sockJS是还传递了一个Authorization参数，这个参数是用户登录成功后台生成的一个token值，前端要想连接我们的sockJS服务，就必须带着这个登录的Authorization参数值，由我们的握手连接器去验证，是否是合法连接。

package com.correspond.mqtt.rabbitmq.config;

import com.web.jwt.util.TokenUtil;
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 java.util.Map;

/**
 * @author raven
 */
@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<String, Object> map) throws Exception {

        LOGGER.info("===============before handshake=============");
       
        // 比如，只有登录后，才可以进行websocket连接
        ServletServerHttpRequest serverRequest = (ServletServerHttpRequest) serverHttpRequest;
        String token = serverRequest.getServletRequest().getParameter("Authorization");
        if (token != null &&!TokenUtil.verify(token) ) {

                LOGGER.error("Token验证失败，连接失败！");
                return false;
        }

        return true;

    }

    @Override
    public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
        LOGGER.info("===============after handshake=============");
    }
}

7.3 配置websocket握手处理器

握手之前验证完之后，我们就需要准备开始握手的处理器了。包装客户端的信息。


package com.correspond.mqtt.rabbitmq.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.support.DefaultHandshakeHandler;

import javax.servlet.http.HttpServletRequest;
import java.security.Principal;
import java.util.Map;

/**
 * @author raven
 */
@Component
public class MyHandshakeHandler extends DefaultHandshakeHandler {

    private static final Logger LOGGER = LoggerFactory.getLogger(AuthHandshakeInterceptor.class);

    @Override
    protected Principal determineUser(ServerHttpRequest request, WebSocketHandler wsHandler, Map<String, Object> attributes) {
        System.out.println("--------------------------------");
        if (request instanceof ServletServerHttpRequest) {
            ServletServerHttpRequest servletServerHttpRequest = (ServletServerHttpRequest) request;
            HttpServletRequest httpRequest = servletServerHttpRequest.getServletRequest();
            /**
             * 这边就获取用户唯一信息用来包装
             */
            final String token = httpRequest.getParameter("Authorization");


            return () -> token;
        }
        return null;

    }

}

7.4 配置管道拦截器

握手成果之后，便开始对消息管道进行拦截，因为我们要用到Stomp代理我们的消息。

package com.correspond.mqtt.rabbitmq.config;


import com.correspond.mqtt.rabbitmq.entity.MyPrincipal;
import com.correspond.mqtt.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.MessageHeaderAccessor;
import org.springframework.stereotype.Component;

import java.util.LinkedList;
import java.util.Map;

/**
 * @author Anumbrella
 */
@Component
//ChannelInterceptorAdapter废弃了
public class MyChannelInterceptor implements ChannelInterceptor {

    @Autowired
    private SocketSessionRegistry webAgentSessionRegistry;

    @Override
    public Message<?> preSend(Message<?> message, MessageChannel channel) {
        StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
        /**
         * 1. 判断是否为首次连接请求，如果已经连接过，直接返回message
         * 、
         */
        if (StompCommand.CONNECT.equals(accessor.getCommand())) {
            System.out.println("连接success");

            Object raw = message.getHeaders().get(SimpMessageHeaderAccessor.NATIVE_HEADERS);

            if (raw instanceof Map) {
            	Object nameObj = ((Map) raw).get("name");
                if (nameObj instanceof LinkedList) {
                    String name = ((LinkedList) nameObj).get(0).toString();
                    System.out.println("name："+name);
                    //设置当前访问器的认证用户
                    accessor.setUser(new MyPrincipal(name));

                    String sessionId = accessor.getSessionId();

                    // 统计用户在线数，可通过redis来实现更好
                    webAgentSessionRegistry.registerSessionId(name, 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;
    }

}

7.5 实现Principal

最后实现自己的Principal ：

package com.correspond.mqtt.rabbitmq.entity;

import java.security.Principal;

/**
 * @author raven
 */
public class MyPrincipal implements Principal {

    private String loginName;

    public MyPrincipal(String loginName) {
        this.loginName = loginName;
    }

    @Override
    public String getName() {
        return loginName;
    }
}

这时候，我们的初始配置就完成了。接下来看看具体使用吧。
我们既可以提供http的形式推送消息，也可以使用原生的stomp推送消息。
首先看看http形式如何发布数据。
如下代码。

@Controller
@RequestMapping("/push_msg")
public class SendController {
	   @Autowired
    private SimpMessagingTemplate messagingTemplate;
	@GetMapping("/notice")
    public void notice(String msg) {
    	//对所有用户通知消息
        messagingTemplate.convertAndSend("/topic/notice", msg);
    }
    @GetMapping("/user/{username}/{type}")
    public void notice(@PathVariable String username, @PathVariable String type,String msg) {
        messagingTemplate.convertAndSendToUser(username+"@"+type
                , "/topic/reply",msg);
    }
}

为了方便演示，我现在登录了两个用户，左图是admin，右图是test。
这时候，直接在浏览器内访问 /push_msg/notice?msg=hello world!，因为两个用户已经订阅了系统通知节点/topic/notice,所以可以看到消息已经推送至每个用户。

系统通知没有问题了。我们再试试对特定用户推送消息吧。

直接在浏览器访问 /push_msg/user/admin/web?msg=林深时见鹿，因为两个用户都已经订阅了自己独有的通知节点/user/topic/reply,且消息发送的路径用户为admin，所以可以看到消息已经推送至admin用户而没有推送给test用户。

如果我们想在前端通过Stmop发送消息呢？而不是通过HTTP，因为这只是一个测试，就安全角度来讲，直接使用HTTP推送消息也需要对该接口加密，而不是任意人都可以使用HTTP方式推送消息。

使用Sockjs，可以使用如下方式给后端推送信息。

//为什么要加前缀message呢？因为7.1配置只拦截/message 开头的消息
this.ws.send("/message/test", {}, JSON.stringify({'name': "123456"}));

可以看出来，使用注解@DestinationVariable获取路径里面的参数值

@Controller
public class ReceiveController {
 	@MessageMapping("/web.{name}")
    @SendToUser("/topic/reply")
    public String say(String message, @DestinationVariable("name") String name) throws Exception {
       		 System.out.println("name:"+name+"用户来消息啦");
          	 return name+"发送："+message;
           }
}

由于我们使用了@SendToUser注解，所以发送完成以后可以看到后台给前端推送的消息。
如果我们想把该用户传来的消息发送给所有用户，可以直接使用@SendTo("/topic/notice")注解，该场景适用于聊天群组消息推送。

场景一：如果我们现在想做一个聊天软件，用户A如何给用户B发送消息呢？很简单。

如下图可见，当我们点击发送按钮的时候，会发送一个格式化的字符串给后台，该字符串包含了当前输入的消息以及和要发送给的用户。这里为了方便演示，toUser写死为test，也就是说，现在我登录admin用户给test用户发信息看看test是否会受到呢？
我们先来看看前端怎么写：

我们再来看看后端怎么写

@Controller
public class ReceiveController {
    @Autowired
    private SimpMessagingTemplate messagingTemplate;
    @MessageMapping("toFriend")
    public void toFriendMsg(String message){
        JSONObject msgJSON = JSON.parseObject(message);
        String username  = msgJSON.getString("toUser");
        String msg  = msgJSON.getString("message");
        messagingTemplate.convertAndSendToUser(username+"@web", "/topic/reply",
                msg);
    }
}

接下来看看效果图，test用户完全可以收到admin发送的消息，所以也就很轻松解决了该场景问题。

总结

本毕设现在已经到了尾声阶段，采用了前后端分离架构，加持shiro进行接口权限验证以及JWT无session保障用户状态。本篇博客总结了毕设的消息推送模块，应用如上应用场景，我们可以轻轻松松写一个适合自己的消息推送系统。本篇博客就到这里了，本人能力有限，如有地方书写错误，请留言批评指正！

如何利用springboot快速搭建一个消息推送系统

小前奏

一、安装RabbitMQ

二、开启插件

三、安装库

四、引入库

五、执行代码

六、开始测试

七、配置后端

7.1 配置websocket

7.2 配置websocket握手连接器

7.3 配置websocket握手处理器

7.4 配置管道拦截器

7.5 实现Principal

场景一：如果我们现在想做一个聊天软件，用户A如何给用户B发送消息呢？很简单。

总结

如何基于surging跨网关跨语言进行缓存降级

2024合集

程序员天天 CURD，怎么才能成长，职业发展的思考(2)

移位操作搞定两数之商

教你用Perl实现Smgp协议

如何通过前端表格控件在10分钟内完成一张分组报表？

win11关闭自动检测病毒删文件

通用代码生成器简介

lightdb 单机模式下数据库平移

千兆宽带实际网速能到达多少？

力扣練習之旋轉鏈表

如何僅花20元成本用arduino平臺建立自己的物聯網應用

CentOS7 JAVAWEB環境配置以及Communications link failure的解決方案

讓人又愛又恨的tkinter之坑

力扣刷題解析

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結