rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计

调研背景

公司消息推送服务以RabbitMQ为基础,pc端消息推送存在消息客户端接口不统一等诸多问题,访问权限不够灵活统一等问题。

为了将公司各个应用之间进行消息解耦,对业务的透明化处理及技术架构的统一管理,降低对各业务模块对消息模块开发难度,保障消息推送服务器与业务系统的稳定性,也方便各应用的消息中间件的快速搭建,尤其对pc端直接操作消息服务器,提供可行性解决方案

一、Web Stomp

消息投递与消费遇到的问题

  1. 统一web端消息接口
  2. 提高消息投递效率,让生产端不在维护交换机和关注队列
  1. 消息服务器与业务解耦

什么是RabbitMQ STOMP

即Simple (or Streaming) Text Orientated Messaging Protocol,简单(流)文本定向消息协议,它提供了一个可互操作的连接格式,允许STOMP客户端与任意STOMP消息代理(Broker)进行交互。STOMP协议设计简单,易于开发客户端,因此在多种语言和多种平台上得到广泛地应用。

stomp代理中会将stomp消息的处理委托给一个真正的消息代理(RabbitMQ,activeMQ)进行处理

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第1张图片

什么是RabbitMQ Web STOMP

可以理解为 HTML5 WebSocketSTOMP 协议间的桥接,目的也是为了让浏览器能够使用 RabbitMQ。当 RabbitMQ 消息服务器开启了 STOMP 和 Web STOMP 插件后,浏览器端就可以轻松地使用 WebSocket 或者 SockerJS 客户端实现与 RabbitMQ 服务器进行通信。
RabbitMQ Web STOMP 是对 STOMP 协议的桥接,因此其语法也完全遵循 STOMP 协议。STOMP 是基于 frame 的协议,与 HTTPframe 相似。一个 Frame 包含一个 command,一系列可选的 headers 和一个 body。STOMP client 的用户代理可以充当两个角色,当然也可能同时充当:作为生产者,通过 SEND frame 发送消息到服务器;作为消费者,发送 SUBCRIBE frame 到目的地并且通过 MESSAGE frame 从服务器获取消息。
在Web页面中利用WebSocket使用STOMP协议只需要下载stomp.js即可,考虑到老版本的浏览器不支持 WebSocket,SockJS 则提供了 WebSocket 的模拟支持。

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第2张图片

STOMP常用命令

CONNECT  与服务器建立连接,校验秘钥
CONNECTED 连接成功
SEND 发送消息
SUBSCRIBE 订阅消息
UNSUBSRIBE 取消订阅
ACK 消息确认,默认为ture,自动确认,手动确认改为false
NACK  NACK是ACK的反向
BEGIN 事务开始
COMMIT 事务提交
ABORT事务回滚
DISCONNECT 断开连接
MESSAGE   用于传输从服务端订阅的消息到客户端,MESSAGE中必须包含destionation头,用以表示这个消息应该发送的目标。如果这个消息被使用STOMP发 送,那么这个destionation应该与相应的SEND帧中的目标一样
ERROR如果连接过程中出现什么错误,服务端就会发送ERROR,并断开连接

header参数

  • durable (aliased as persistent) 持久化 (默认持久化)
  • auto-delete 自动删除 (默认非自动删除)
  • exclusive 独占 (默认非独占)
  • x-message-ttl  消息过期时间 (ms毫秒)
  • x-dead-letter-exchange (死信队列交换机)

服务端docker 暴露15674端口

docker run -it -d --name=rabbit-3.8 -v /d/docker/rabbitmq-stomp/conf:/etc/rabbitmq  -p 5617:5617 -p 5672:5672 -p 4369:4369 -p 15671:15671 -p 15672:15672 -p 25672:25672 -p 15670:15670 -p 15674:15674 rabbitmq:3.8.27

开启插件

如果在docker 环境下  进入docker-rabbitmq容器内 执行

rabbitmq-plugins enable rabbitmq_web_stomp
rabbitmq-plugins enable  rabbitmq_stomp

查看插件是否开启

rabbitmq-plugins list

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第3张图片

官方自带demo

rabbitmq-plugins enable rabbitmq_web_stomp_examples

stomp相关配置

如果不想用户名和密码暴露到前端,可以在配置文件中设置默认密码

stomp.default_user = admin
stomp.default_pass = a123456

#更改虚拟vhost
stomp.default_vhost = /


#web stomp 端口修改
web_stomp.tcp.port = 12345

#是否传输压缩
web_stomp.ws_opts.compress = true

#WebSocket 超时时间
web_stomp.ws_opts.idle_timeout = 60000


#无缓存模式
#auth_backends.1 = http

#混合模式 使用模块名称而不是短别名,“http”
#auth_backends.1 = rabbit_auth_backend_http
#auth_backends.2 = internal

#内部身份验证,http授权
#auth_backends.1.authn = internal
#auth_backends.1.authz = rabbit_auth_backend_http

#http授权,内部身份验证
#auth_backends.1.authn = rabbit_auth_backend_http
#auth_backends.1.authz = internal

#stomp.default_user = James
#stomp.default_pass = a123456

stomp 规范

stomp规范没有规定broker必须支持的destination地类型,而是在sendmessage帧中的destination头的值是特定broker。RabbitMQ STOMP适配器支持许多不同的destination类型

有效destination  /temp-queue, /exchange, /topic, /queue, /amq/queue, /reply-queue/

  • /exchange --SEND到任意路由键并SUBSCRIBE任意绑定模式;
    • 1,ex: /exchange/交换机名
    • 2,交换机无法自动创建,可以在管理图形界面创建交换机名或使用rabbitmq默认的交换机
      例如: 如果使用 fanout类型 则后面跟的队列名 无效,会自动给客户端一个临时队列  /exchange/amq.fanout/keyroute
      如果使用direct类型,  /exchange/log/error

amq.direct

direct

D

amq.fanout

fanout

D

amq.headers

headers

D

amq.match

headers

D

amq.topic

  • /queue --向 STOMP 网关管理的队列发送和订阅;
  • /amq/queue --发送和订阅在 STOMP 网关之外创建的队列;备注①
  • /topic -- 发送和订阅临时和持久主题;
    /topic/news.*.*

① stomp网关:就是在stomp协议基础上,创建队列,发布或订阅消息,如果非stomp网关,则无法创建队列,只能订阅已存在的队列

交换机-模式

对应模式在stomp协议下的调用方式

简单队列

//只有一个订阅者
client.subscribe("/queue/task_queue", function(data) {
	var msg = data.body;
	console.log("收到数据:");
	console.log(msg);
	},{ack:'client'});

工作队列,简单队列

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第4张图片

//过个订阅者轮询获取
client.subscribe("/queue/task_queue", function(data) {
	var msg = data.body;
	console.log("收到数据:");
	console.log(msg);
	data.ack(); //如果后面带了参数 ack 就是指定要手动确认消息,没带就是自动确认
	},{ack:'client'});

扇形交换机 fanout

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第5张图片

扇形交换机效率最好的,它不需要路由绑定等复杂操作

var headers = {ack: 'client'};
	交换机/交换机名
	client.subscribe("/exchange/logs", function(data) {
	var msg = data.body;
	console.log("收到数据:");
	console.log(msg);
	data.ack(); //如果后面带了参数 ack 就是指定要手动确认消息,没带就是自动确认
	},headers);

直连交换机direct

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第6张图片

var headers = {ack: 'client'};
	交换机/交换机名/routingkey
	client.subscribe("/exchange/amq.direct/www", function(data) {
	var msg = data.body;
	console.log("收到数据:");
	console.log(msg);
	data.ack(); //如果后面带了参数 ack 就是指定要手动确认消息,没带就是自动确认
	},headers);

主题交换机 topic

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第7张图片

function on_connect(x) {
	var headers = {ack: 'client'};
	client.subscribe("/exchange/xxp/fast.*.*", function(data) {
	var msg = data.body;
	console.log("收到数据:");
	console.log(msg);
	data.ack(); //如果后面带了参数 ack 就是指定要手动确认消息,没带就是自动确认
	},headers);
 
};

发送消息

client.send("/queue/user1", {}, content);

前端配置

提示:前端代码演示 实现连接,接受消息,发送消息等具体功能,仅对JS代码做了简单分装以及断开自动重连

引入stomp.js相关文件



通过stomp建立对话

stompClient.connect('shop','eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJ4eHAiLCJpYXQiOiIyMDIyLTAxLTI4IDAwOjAwOjAwIiwiZXhwIjoiMjAyMi0wMS0zMSAwMDowMDowMCIsImF1ZCI6ImZyb20iLCJzdWIiOiJ0byIsInVzZXJuYW1lIjoieHhwIn0.J4fENLsLdHcTEGm6nr5AeQrsEnflVFRGItuBGqgZs1w', function (frame) {
		writeToScreen("connected: " + frame);
  		console.log("连接成功")
  
		}, function (error) {
				console.log("连接失败");
		},
    '/'
	)

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第8张图片

成功回调

 var on_connect = function(x) {
 			//subscribe 订阅消息,名为test的队列
       console.log(d.body);
    };

失败回调

 var on_error =  function(f) {
        console.log('error'+f);
};

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第9张图片

订阅

var subscribeHeader = {
    	"ack" : "client-individual",
    	'auto-delete': true
    	
    }
	stompClient.subscribe('/queue/15029149799', function (response) {
			writeToScreen(response.body);
			response.ack();

		},subscribeHeader);
rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第10张图片

消费确认 ACK

  1. 订阅subscribe,需要在header定义ack手动确认
  2. ack 有三种方式,auto(自动), client(批量手动确认), client-individual (逐条手动确认)

 var subscribeHeader = {
    	"ack" : "client-individual",
    }

  1. 需要在subscribe 回调函数中加入

response.ack();

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第11张图片

一对一通信

需要提前创建 交换机为 chat2,direct类型

js代码

var stompClient = null;
var wsCreateHandler = null;
var userId = null;
var ipPort = null;
function connect() {
	userId =  GetQueryString("userId");
	if(userId.replace(/(^s*)|(s*$)/g, "").length ==0){
		alert("请在URL带上你的参数");
		return;
	}
	var socket = new WebSocket(ipPort);
	stompClient = Stomp.over(socket);
	stompClient.connect({}, function (frame) {
	writeToScreen("connected: " + frame);

	stompClient.subscribe('/exchange/chat2/'+userId, function (response) {
			writeToScreen('>'+response.body);
		});

		}, function (error) {
			wsCreateHandler && clearTimeout(wsCreateHandler);
			wsCreateHandler = setTimeout(function () {
				console.log("重连...");
				connect();
			}, 10000);
		}
	)
}

function disconnect() {
	if (stompClient != null) {
		stompClient.disconnect();
	}
	writeToScreen("disconnected");
}

function writeToScreen(message) {
	if(DEBUG_FLAG)
	{
		$("#debuggerInfo").val($("#debuggerInfo").val() + "\n" + message);
	}
}

function GetQueryString(name) {
	var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i");
	var r = window.location.search.substr(1).match(reg); 
	var context = "";
	if (r != null)
		context = r[2];
	reg = null;
	r = null;
	return context == null || context == "" || context == "undefined" ? "" : context;
}

html代码



websocket View






    


  
URL参数:userId=xxx UserId我的会员ID
用户:
消息:

发布订阅代码演示

发布订阅模式,chat交换机必须提前定义,交换机类型为fanout

js代码

var stompClient = null;
var wsCreateHandler = null;
var userId = null;
var ipPort = null;

function connect() {
	userId =  GetQueryString("userId");
	var socket = new WebSocket(ipPort);
	stompClient = Stomp.over(socket);
	stompClient.connect({}, function (frame) {
		writeToScreen("connected: " + frame);


	stompClient.subscribe('/exchange/chat', function (response) {
			writeToScreen(response.body);
		});

		}, function (error) {
			wsCreateHandler && clearTimeout(wsCreateHandler);
			wsCreateHandler = setTimeout(function () {
				console.log("重连...");
				connect();
			}, 10000);
		}
	)
}

function disconnect() {
	if (stompClient != null) {
		stompClient.disconnect();
	}
	writeToScreen("disconnected");
}

function writeToScreen(message) {
	if(DEBUG_FLAG)
	{
		$("#debuggerInfo").val($("#debuggerInfo").val() + "\n" + message);
	}
}

function GetQueryString(name) {
	var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i");
	var r = window.location.search.substr(1).match(reg); 
	var context = "";
	if (r != null)
		context = r[2];
	reg = null;
	r = null;
	return context == null || context == "" || context == "undefined" ? "" : context;
}

html代码



websocket View








  
  
  
  
用户:
消息:

二、认证授权

一. rabbitmq 身份验证和授权是可插拔的,通过启用插件可实现授权,例如  LDAP, HTTP ,内部授权

二. 在rabbitmq中,认证和授权是分开的

  1. 认证是检查消息中心的用户是否有使用虚拟主机的权限,如果没有拒绝链接,当RabbitMQ客户端建立与服务器的连接并进行身份验证时,会指定一个虚拟主机,以便在其中运行。此时将实施一级访问控制,服务器将检查用户是否具有访问该虚拟主机的权限,否则将拒绝连接尝试。
  2. 授权检查是否有权限操作虚拟主机中的资源(交换机和队列),资源,即交换机和队列,是虚拟主机内的实体;相同的名称表示不同虚拟主机中的不同资源。当对资源执行某些操作时,将强制执行第二级访问控制。

开启http安全认证插件

rabbitmq-plugins enable rabbitmq_auth_backend_http

Rabbitmq有两种鉴权方式:

一种是利用内置数据库鉴权。

另一种是rabbitmq-auth-backend-http鉴权插件来实现后端鉴权。
Rabbitmq中,Authentication 和 authorisation是有区别的,

authentication 是“identifying who the user is”, 识别用户是谁

authorisation   是指“determining what the user is and isn’t allowed to do.” 该用户允许你做什么

Rabbitmq有一个默认的vhost和user Rabbitmq的内置数据库会在初始化的时候存入一个名为“/”的vhost,一个名为guest的用户名和密码,并且在“/”的vhost是被授权的。 但是这个默认的用户名和密码只允许连接localhost的rabbitmq 如果想要连接远程的,需要在rabbitmq的config文件配置。

配置文件rabbitmq.conf

rabbitmq版本3.7+

auth_backends.1 = http
auth_http.http_method   = post
auth_http.user_path     = http://some-server/auth/user
auth_http.vhost_path    = http://some-server/auth/vhost
auth_http.resource_path = http://some-server/auth/resource
auth_http.topic_path    = http://some-server/auth/topic

rabbitmq版本<3.7

[
  {rabbit, [{auth_backends, [rabbit_auth_backend_http]}]},
  {rabbitmq_auth_backend_http,
   [{http_method,   post},
    {user_path,     "http(s)://some-server/auth/user"},
    {vhost_path,    "http(s)://some-server/auth/vhost"},
    {resource_path, "http(s)://some-server/auth/resource"},
    {topic_path,    "http(s)://some-server/auth/topic"}]}
].

授权原理

权限如何工作

当 RabbitMQ 客户端与服务器建立连接并进行[身份验证]时,客户端打算操作的虚拟主机。此时执行第一级访问控制,服务器检查用户是否具有访问虚拟主机的任何权限,否则拒绝连接尝试。

资源,即交换和队列,是特定虚拟主机内的命名实体;相同的名称表示每个虚拟主机中的不同资源。当对资源执行某些操作时,会实施第二级访问控制。

RabbitMQ 区分资源上的配置写入读取操作。配置操作创建或销毁资源,或改变它们的行为。操作将 消息写入到资源中。读取操作从资源中取出消息。

为了对资源操作,用户必须已被授予相应的权限。下表显示了执行权限检查的所有 AMQP 命令需要什么类型的资源的权限

权限配置

#该命令仅对rabbitmq 自带内部授权(默认授权)起作用,不对 LDAP, HTTP

#新增一个用户
rabbitmqctl add_user root root

#查看`/`虚拟机权限
rabbitmqctl list_permissions --vhost /

#给admin分配权限
rabbitmqctl  set_permissions -p / admin '.*' '.*' '.*'

设置用户角色
rabbitmqctl set_user_tags admin administrator

MQ向HTTP提交参数

rabbitmq 服务器授权模块 向http验证服务器提交参数

注意! : http 权限认证, 如果websocket端 开启了心跳检测,则建立长链接后,临时更变该链接用户权限,则不会及时检测出权限变更,会继续接受消息,如果关闭了了心跳检测,则长链接过期后会自动重新建立长链接,如果此时临时更不用户权限,则会检测出权限更变,拒绝没有权限的请求,但这存在这个效率问题,因为长链接,建立链接比较耗费宽带资源

user_path

  • username - 用户名
  • password - 密码(ssl开启后密码会被忽略)

vhost_path

  • username - 用户名
  • vhost - 正在访问的资源虚拟主机的名
  • ip - 客户端 IP

resource_path

  • username - 用户名
  • vhost - 包含资源的虚拟主机的名称
  • resource - 资源类型 (exchange,queue,topic)
  • name - 资源的名称
  • permission - 资源的访问级别 ( configure, write, read)

topic_path

  • username - 用户名
  • vhost - 包含资源的虚拟主机的名称
  • resource - 资源的类型(topic在这种情况下)
  • name - 交换机名
  • permission - 资源的访问级别(writeread
  • routing_key - 发布消息时路由键(权限为 时write),订阅时路由(read

用户、角色、权限

php 代码

用户以及角色

权限:rabbitmq 默认给出的四个权限

  • administrator 超管,可以做任何事
  • monitoring  监控者 可登陆管理控制台(启用management plugin的情况下),同时可以查看rabbitmq节点的相关信息(进程数,内存使用情况,磁盘使用情况等)
  • policymaker 策略制定者 可登陆管理控制台(启用management plugin的情况下), 同时可以对policy进行管理。但无法查看节点的相关信息
  • management   普通管理者 仅可登陆管理控制台(启用management plugin的情况下),无法看到节点信息,也无法对策略进行管理
  • none 无法登陆管理控制台,通常就是普通的生产者和消费者。

格式

'用户名' => array(
'password' => '密码',
'roles' => array(
'角色',
),
)

array(
    //Admin user
    'Anthony' => array(
        'password' => 'a123456',
        'roles' => array(
            'administrator',
            // 'impersonator', // report to https://www.rabbitmq.com/validated-user-id.html
        ),
    ),
    'James' => array(
        'password' => 'a123456'
    ),
    'Roger' => array(
        'password' => 'a123456',
        'roles' => array(
            'monitoring',
        ),
    ),
    'Bunny' => array(
        'password' => 'a123456',
        'roles' => array(
            'policymaker',
        ),
    ),
    'admin' => array(
        'password' => 'a123456',
        'roles' => array(
            'administrator',
        ),
    ),
)

权限

格式

'用户名' => array(
'rabbitmq虚拟host' => array(
'rabbitmq ip' => '',
'读' => '.*',
'写' => '.*',
'配置' => '.*',
),
),

$permissions = array(

    'Anthony' => array(
        'isAdmin' => true,
        '/' => array(
            'ip' => '.*',
            'read' => '.*',
            'write' => '.*',
            'configure' => '.*',
        ),
    ),
    'James' => array(
        '/' => array(
            'ip' => '.*',
            'read' => '.*',
            'write' => '.*',
            'configure' => '.*',
        ),
    ),
    'admin' => array(
        '/' => array(
            'ip' => '.*',
            'read' => '.*',
            'write' => '.*',
            'configure' => '.*',
        ),
    ),
);

返回结果

Web 服务器应始终返回 HTTP 200 OK

  • deny - 拒绝访问用户/虚拟主机/资源
  • allow - 允许访问用户/虚拟主机/资源
  • allow [list of tags]- (仅会显示在 user_path时候) - 允许访问,并将用户标记为具有列出的标签

使用TLS/HTTPS 开启

[
  {rabbit, [{auth_backends, [rabbit_auth_backend_http]}]},
  {rabbitmq_auth_backend_http,
   [{http_method,   post},
    {user_path,     "https://some-server/auth/user"},
    {vhost_path,    "https://some-server/auth/vhost"},
    {resource_path, "https://some-server/auth/resource"},
    {topic_path,    "https://some-server/auth/topic"},
    {ssl_options,
     [{cacertfile, "/path/to/cacert.pem"},
      {certfile,   "/path/to/client/cert.pem"},
      {keyfile,    "/path/to/client/key.pem"},
      {verify,     verify_peer},
      {fail_if_no_peer_cert, true}]}]}
].

开启http验证缓存功能

描述

该插件为RabbitMQ 节点执行的[后台http权限验证]提供了一个缓存层。

该插件提供了一种用配置文件,设置缓存时间,缓存身份验证和授权结果的方法。它不是独立的身份验证后端,而是现有后端(例如内置(internal)LDAPHTTP后端)的缓存层 。

缓存过期当前是基于时间的。它对于内置((internal))不是很有用,但对于 LDAP、HTTP 或其他使用网络请求的后端非常有用

开启插件

rabbitmq-plugins enable rabbitmq_auth_backend_cache

配置文件

以http后端验证为例,cache 必须置顶,cache_ttl 为毫秒单位

auth_backends.1 = cache
auth_cache.cached_backend = http
auth_cache.cache_ttl = 5000

auth_http.http_method   = post
auth_http.user_path     = http://localhost:8080/auth/user
auth_http.vhost_path    = http://localhost:8080/auth/vhost
auth_http.resource_path = http://localhost:8080/auth/resource
auth_http.topic_path    = http://localhost:8080/auth/topic

设置缓存模型

提供4种类型

  • rabbit_auth_cache_dict 将缓存条目存储在内部进程字典中。此模块仅用于演示,不应在生产中使用
  • rabbit_auth_cache_ets 将缓存条目存储在ETS表中,并使用计时器进行缓存失效。这是默认实现
  • rabbit_auth_cache_ets_segmented将缓存条目存储在多个 ETS 表中,并且不会删除单个缓存项,而是使用单独的进程进行垃圾收集。
  • rabbit_auth_cache_ets_segmented_stateless与之前相同,但使用最少的gen_server状态,使用 ets 表来存储有关段的信息。

缓存默认实现

auth_cache.cache_module = rabbit_auth_backend_ets

RabbitMQ 权限组合后端

为了解决rabbitmq 不同的权限验证需求,可以开启混合模式

组合:使用多个后端。当使用多个身份验证后端时,配置中后端返回的第一个肯定结果被视为最终结果。

混合:这不应与混合后端混淆(例如,使用LDAP进行身份验证,使用内部后端进行授权)

1.组合身份验证&授权

#rabbitmq.conf 
# internal为RabbitMQ内部鉴权
# 这将首先检查 HTTP,如果用户无法通过 HTTP 进行身份验证,则回退到内部数据库进行权限验证:
auth_backends.1 = rabbit_auth_backend_http
# 使用模块名称而不是短别名,“http” 
auth_backends.2 = internal
#...

2.混合验证

#rabbitmq.conf 
# internal为RabbitMQ内部身份验证
# 通过HTTP进行权限验证
auth_backends.1.authn = internal
auth_backends.1.authz = rabbit_auth_backend_http

常用命令

#显示用户列表
rabbitmqctl list_users

#格式化json格式
rabbitmqctl list_users --formatter=json

#删除用户
rabbitmqctl delete_user 'username'

# 分配权限
# 第一个 ".*" 用于配置每个实体的权限
# 第二个 ".*" 用于每个实体的写权限
# 第三个 ".*" 对于每个实体的阅读许可
rabbitmqctl set_permissions -p "custom-vhost" "username" ".*" ".*" ".*"

#清楚权限
rabbitmqctl clear_permissions -p "custom-vhost" "username"

#授予所有虚拟主机的用户权限。
for v in $(rabbitmqctl list_vhosts --silent); do rabbitmqctl set_permissions -p $v "a-user" ".*" ".*" ".*"; done


# 查看虚拟机
 rabbitmqctl list_vhosts

三、公司业务场景

为了将公司各个应用系统之间进行业务解耦,对业务的透明化处理及技术架构的统一管理,方便对各业务模块对消息模块开发难度,保障消息推送服务器与业务系统的稳定性,也方便各应用的消息中间件的快速搭建,尤其对pc端直接操作消息服务器,提供整体的解决方案

目标

  1. 降低消息与业务耦合度,
  2. 提供统一接口,方便各端调用
  1. 新增更加灵活的访问资源授权模式

方案

服务端

消息可靠性投递流程图

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第12张图片

消息确认

消息的确认,是指生产者投递消息后,如果 Broker 收到消息,则会给我们生产者一个应答。生产者进行接收应答,用来确定这条消息是否正常的发送到 Broker ,这种方式也是消息的可靠性投递的核心保障!

Confirm 确认机制流程图

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第13张图片

如何实现Confirm确认消息

  • 第一步:在 channel 上开启确认模式: channel.confirmSelect()
  • 第二步:在 channel 上添加监听: channel.addConfirmListener(ConfirmListener listener);, 监听成功和失败的返回结果,根据具体的结果对消息进行重新发送、或记录日志等后续处理!

golang代码

//simple 简单路由模式
func confirms(){
	conn, err := amqp.Dial("amqp://shop:eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJ4eHAiLCJpYXQiOiIyMDIyLTAxLTI4IDAwOjAwOjAwIiwiZXhwIjoiMjAyMi0wMS0zMSAwMDowMDowMCIsImF1ZCI6ImZyb20iLCJzdWIiOiJ0byIsInVzZXJuYW1lIjoieHhwIn0.J4fENLsLdHcTEGm6nr5AeQrsEnflVFRGItuBGqgZs1w@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open an channel")
	defer ch.Close()

	ch.Confirm(false)

	q, err := ch.QueueDeclare(
		"hello", // name
		true,   // durable
		false,   // delete when unused
		false,   // exclusive
		false,   // no-wait
		nil,     // arguments
	)
	failOnError(err, "Failed to declare a queue")
	//处理确认逻辑
	confirms := ch.NotifyPublish(make(chan amqp.Confirmation,1))
	//处理方法
	defer confirmOne(confirms)

	now := time.Now()
	year := now.Year()
	month := now.Month()
	day := now.Day()
	hour := now.Hour()
	minute := now.Minute()
	second := now.Second()
	dateFormat :=  fmt.Sprintf("formart out: %02d-%02d-%02d  %02d:%02d:%02d\n", year, month, day, hour, minute, second)


	body := bodyFrom("hello 我是golang2,我是简单模式1" + dateFormat)

	err = ch.Publish(
		"",            // exchange
		q.Name,
		false,
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
		})
	failOnError(err, "Failed to publish a message")

	log.Printf(" [x] sent %s", body)
}

// 消息确认
func confirmOne(confirms <-chan amqp.Confirmation) {
	if confirmed := <-confirms; confirmed.Ack {
		fmt.Printf("已送达到RabbitMQ broker tag: %d", confirmed.DeliveryTag)
	} else {
		fmt.Printf("未送达到RabbitMQ brokertag: %d", confirmed.DeliveryTag)
	}
}

正常Broker 接收到消息

D:\go\rabbitmq-server>go run main.go
2022/02/09 13:42:25  [x] sent hello 我是golang2,我是简单模式1formart out: 2022-02-09  13:42:25
已送达到RabbitMQ broker tag: 1

如果不给shop账户权限则

D:\go\rabbitmq-server>go run main.go
2022/02/09 13:44:29  [x] sent hello 我是golang2,我是简单模式1formart out: 2022-02-09  13:44:29
未送达到RabbitMQ brokertag: 0

java代码

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmListener;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;

public class ConfirmProducer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setVirtualHost("/");
        factory.setUsername("guest");
        factory.setPassword("guest");

        Connection connection = factory.newConnection();

        Channel channel = connection.createChannel();

        String exchangeName = "test_confirm_exchange";
        String routingKey = "item.update";

        //指定消息的投递模式:confirm 确认模式
        channel.confirmSelect();

        //发送
        final long start = System.currentTimeMillis();
        for (int i = 0; i < 5 ; i++) {
            String msg = "this is confirm msg ";
            channel.basicPublish(exchangeName, routingKey, null, msg.getBytes());
            System.out.println("Send message : " + msg);
        }

        //添加一个确认监听, 这里就不关闭连接了,为了能保证能收到监听消息
        channel.addConfirmListener(new ConfirmListener() {
            /**
             * 返回成功的回调函数
             */
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("succuss ack");
                System.out.println(multiple);
                System.out.println("耗时:" + (System.currentTimeMillis() - start) + "ms");
            }
            /**
             * 返回失败的回调函数
             */
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                System.out.printf("defeat ack");
                System.out.println("耗时:" + (System.currentTimeMillis() - start) + "ms");
            }
        });
    }
}
Copyimport com.rabbitmq.client.*;
import java.io.IOException;

public class ConfirmConsumer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setVirtualHost("/");
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setAutomaticRecoveryEnabled(true);
        factory.setNetworkRecoveryInterval(3000);

        Connection connection = factory.newConnection();

        Channel channel = connection.createChannel();
      
        String exchangeName = "test_confirm_exchange";
        String queueName = "test_confirm_queue";
        String routingKey = "item.#";
        channel.exchangeDeclare(exchangeName, "topic", true, false, null);
        channel.queueDeclare(queueName, false, false, false, null);

        //一般不用代码绑定,在管理界面手动绑定
        channel.queueBind(queueName, exchangeName, routingKey);

        //创建消费者并接收消息
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };

        //设置 Channel 消费者绑定队列
        channel.basicConsume(queueName, true, consumer);

    }
}

我们此处只关注生产端输出消息

CopySend message : this is confirm msg 
Send message : this is confirm msg 
Send message : this is confirm msg 
Send message : this is confirm msg 
Send message : this is confirm msg 
succuss ack
true
耗时:3ms
succuss ack
true
耗时:4ms

注意事项

  • 我们采用的是异步 confirm 模式:提供一个回调方法,服务端 confirm 了一条或者多条消息后 Client 端会回调这个方法。除此之外还有单条同步 confirm 模式、批量同步 confirm 模式,由于现实场景中很少使用我们在此不做介绍,如有兴趣直接参考官方文档。
  • 我们运行生产端会发现每次运行结果都不一样,会有多种情况出现,因为 Broker 会进行优化,有时会批量一次性 confirm ,有时会分开几条 confirm。

Return 消息机制

  • Return Listener 用于处理一-些不可路 由的消息!
  • 消息生产者,通过指定一个 ExchangeRoutingkey,把消息送达到某一个队列中去,然后我们的消费者监听队列,进行消费处理操作!
  • 但是在某些情况下,如果我们在发送消息的时候,当前的 exchange 不存在或者指定的路由 key 路由不到,这个时候如果我们需要监听这种不可达的消息,就要使用 Return Listener !
  • 在基础API中有一个关键的配置项:Mandatory:如果为 true,则监听器会接收到路由不可达的消息,然后进行后续处理,如果为 false,那么 broker 端自动删除该消息!

Return 消息机制流程图

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第14张图片

Return 消息示例

  • 首先我们需要发送三条消息,并且故意将第 0 条消息的 routing Key设置为错误的,让他无法正常路由到消费端。
  • mandatory 设置为 true 路由不可达的消息会被监听到,不会被自动删除.即channel.basicPublish(exchangeName, errRoutingKey, true,null, msg.getBytes());
  • 最后添加监听即可监听到不可路由到消费端的消息channel.addReturnListener(ReturnListener r))

go代码

//Return 消息机制
func ReturnListeningProducer(){
	conn, err := amqp.Dial("amqp://shop:eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJ4eHAiLCJpYXQiOiIyMDIyLTAxLTI4IDAwOjAwOjAwIiwiZXhwIjoiMjAyMi0wMS0zMSAwMDowMDowMCIsImF1ZCI6ImZyb20iLCJzdWIiOiJ0byIsInVzZXJuYW1lIjoieHhwIn0.J4fENLsLdHcTEGm6nr5AeQrsEnflVFRGItuBGqgZs1w@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open an channel")
	defer ch.Close()


	q, err := ch.QueueDeclare(
		"hello", // name
		true,   // durable
		false,   // delete when unused
		false,   // exclusive
		false,   // no-wait
		nil,     // arguments
	)
	failOnError(err, "Failed to declare a queue")
	//处理确认逻辑
	returns := ch.NotifyReturn(make(chan amqp.Return))
	//处理方法
	go returnsMe(returns)

	now := time.Now()
	year := now.Year()
	month := now.Month()
	day := now.Day()
	hour := now.Hour()
	minute := now.Minute()
	second := now.Second()
	dateFormat :=  fmt.Sprintf("formart out: %02d-%02d-%02d  %02d:%02d:%02d\n", year, month, day, hour, minute, second)


	body := bodyFrom("hello 我是golang2,我是简单模式1,也是return 消息机制" + dateFormat)

	log.Printf("q",q)
	err = ch.Publish(
		"",            // exchange
		"eee",
		true,
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
		})
	failOnError(err, "Failed to publish a message")

	log.Printf(" [x] sent %s", body)
}

// 消息确认
func returnsMe(confirms <- chan amqp.Return) {
	confirmed := <-confirms;
	log.Printf("confirmed:",confirmed)
	//_, ok :=confirmed.Headers["x-delay"]
	if string(confirmed.Body)!=""  {
		// 如果生产者消息没有放入队列中,这里需要处理未投递成功的消息,可以放入死信队列还是持久化再次投递
		log.Println("消息没有正确入列:", string(confirmed.Body))
	}else{
	//消息发布成功
	}

}

D:\go\rabbitmq-server>go run main.go
2022/02/09 14:47:39 消息没有正确入列: hello 我是golang2,我是简单模式1,也是return 消息机制formart out: 2022-02-09  14:47:39

java代码

import com.rabbitmq.client.*;
import java.io.IOException;

public class ReturnListeningProducer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setVirtualHost("/");
        factory.setUsername("guest");
        factory.setPassword("guest");
      
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        String exchangeName = "test_return_exchange";
        String routingKey = "item.update";
        String errRoutingKey = "error.update";

        //指定消息的投递模式:confirm 确认模式
        channel.confirmSelect();

        //发送
        for (int i = 0; i < 3 ; i++) {
            String msg = "this is return——listening msg ";
            //@param mandatory 设置为 true 路由不可达的消息会被监听到,不会被自动删除
            if (i == 0) {
                channel.basicPublish(exchangeName, errRoutingKey, true,null, msg.getBytes());
            } else {
                channel.basicPublish(exchangeName, routingKey, true, null, msg.getBytes());
            }
            System.out.println("Send message : " + msg);
        }

        //添加一个确认监听, 这里就不关闭连接了,为了能保证能收到监听消息
        channel.addConfirmListener(new ConfirmListener() {
            /**
             * 返回成功的回调函数
             */
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("succuss ack");
            }
            /**
             * 返回失败的回调函数
             */
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                System.out.printf("defeat ack");
            }
        });

        //添加一个 return 监听
        channel.addReturnListener(new ReturnListener() {
            public void handleReturn(int replyCode, String replyText, String exchange, String routingKey, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("return relyCode: " + replyCode);
                System.out.println("return replyText: " + replyText);
                System.out.println("return exchange: " + exchange);
                System.out.println("return routingKey: " + routingKey);
                System.out.println("return properties: " + properties);
                System.out.println("return body: " + new String(body));
            }
        });

    }
}


Copyimport com.rabbitmq.client.*;
import java.io.IOException;

public class ReturnListeningConsumer {
    public static void main(String[] args) throws Exception {
        //1. 创建一个 ConnectionFactory 并进行设置
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setVirtualHost("/");
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setAutomaticRecoveryEnabled(true);
        factory.setNetworkRecoveryInterval(3000);

        //2. 通过连接工厂来创建连接
        Connection connection = factory.newConnection();

        //3. 通过 Connection 来创建 Channel
        Channel channel = connection.createChannel();

        //4. 声明
        String exchangeName = "test_return_exchange";
        String queueName = "test_return_queue";
        String routingKey = "item.#";

        channel.exchangeDeclare(exchangeName, "topic", true, false, null);
        channel.queueDeclare(queueName, false, false, false, null);

        //一般不用代码绑定,在管理界面手动绑定
        channel.queueBind(queueName, exchangeName, routingKey);

        //5. 创建消费者并接收消息
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };

        //6. 设置 Channel 消费者绑定队列
        channel.basicConsume(queueName, true, consumer);
    }
}

我们只关注生产端结果,消费端只收到两条消息。

CopySend message : this is return——listening msg 
Send message : this is return——listening msg 
Send message : this is return——listening msg 
return relyCode: 312
return replyText: NO_ROUTE
return exchange: test_return_exchange
return routingKey: error.update
return properties: #contentHeader(content-type=null, content-encoding=null, headers=null, delivery-mode=null, priority=null, correlation-id=null, reply-to=null, expiration=null, message-id=null, timestamp=null, type=null, user-id=null, app-id=null, cluster-id=null)
return body: this is return——listening msg 
succuss ack
succuss ack
succuss ack

客户端

客户端接收到消息服务器的消息,需要保存到本地,这里需要做ack手动确认以及幂等性操作

pc客户端流程图

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第15张图片

幂等性

由于网络闪断等问题,可能出现重复消息,

  1. 生成唯一ID + 指纹码 ,利用数据库主键去重
    1. 生成唯一ID,利用数据库主键去重
    2. SELECT COUNT(*) FROM msg WHERE id = 唯一ID + 指纹码, 如果查询已存在,则表示已消费
    1. 好处是简单,易操作
    2. 坏处是,高并发下,对数据库的写操作,带来性能瓶颈,解决的办法就是通过分库分表,通过算法(例如hash)把ID路由到不同的字表中,提高数据库读写
  1. 利用redis原子性实现
    1. 好处是利用redis set方法可是轻松实现幂等性
    2. 使用redis做幂等性,如果需要持久化如数据库,带来的问题是,数据库与缓存之间如何做到原子性
    1. 如果不落库,在缓存中存储,如何设置定时同步策略

Ack 和 Nack 机制

消费端进行消费的时候,如果由于业务异常我们可以进行日志的记录,然后进行补偿!如果由于服务器宕机等严重问题,那我们就需要手工进行ACK保障消费端消费成功!消费端重回队列是为了对没有处理成功的消息,把消息重新会递给Broker!一般我们在实际应用中,都会关闭重回队列,也就是设置为False。

参考 api

订阅subscribe,需要在header定义ack手动确认, ack 有三种方式,auto(自动), client(批量手动确认), client-individual (逐条手动确认)

var subscribeHeader = {
    	"ack" : "client-individual",
}
stompClient.subscribe('/amq/queue/hello', function (response) {
			writeToScreen(response.body);
			response.ack();

},subscribeHeader);

如何设置手动 Ack 、Nack 以及重回队列

  • 首先我们发送五条消息,将每条消息对应的循环下标 i 放入消息的 properties 中作为标记,以便于我们在后面的回调方法中识别。
  • 其次, 我们将消费端的 ·channel.basicConsume(queueName, false, consumer); 中的 autoAck属性设置为 false,如果设置为true的话 将会正常输出五条消息。
  • 我们通过 Thread.sleep(2000)来延时一秒,用以看清结果。我们获取到properties中的num之后,通过channel.basicNack(envelope.getDeliveryTag(), false, true);num为0的消息设置为 nack,即消费失败,并且将 requeue属性设置为true,即消费失败的消息重回队列末端。

消费端限流

默认自动确认模式可能会压倒消费者,因为它们无法像生产者那样快速地处理消息,这可能会导致消费者内存使用 或操作系统CPU暴涨,导致奔溃。

如果RabbitMQ服务器有上万条未处理的消息,我们打开一个消费者客户端,会出现下面情况:
巨量的消息瞬间全部推送过来,但是我们单个客户端无法同时处理这么多数据。(导致服务器崩溃,线上故障)
生产端一次推送几百条数据,客户端只接收一两条,在高并发的情况下,不能在生产端做限流,只能在消费端处理

前端代码

var stompClient = null;
var wsCreateHandler = null;
var userId = null;
var ipPort = null;

function connect() {
	userId =  GetQueryString("userId");
	var socket = new WebSocket(ipPort);
	stompClient = Stomp.over(socket);
	stompClient.heartbeat.outgoing = 0; //发送频率
	stompClient.heartbeat.incoming = 0; //接收频率
	stompClient.connect('shop','eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJ4eHAiLCJpYXQiOiIyMDIyLTAxLTI4IDAwOjAwOjAwIiwiZXhwIjoiMjAyMi0wMS0zMSAwMDowMDowMCIsImF1ZCI6ImZyb20iLCJzdWIiOiJ0byIsInVzZXJuYW1lIjoieHhwIn0.J4fENLsLdHcTEGm6nr5AeQrsEnflVFRGItuBGqgZs1w', function (frame) {
		writeToScreen("connected: " + frame);

    var subscribeHeader = {
    	"ack" : "client-individual",
    	'auto-delete': true
    	
    }
	stompClient.subscribe('/queue/15029149799', function (response) {
			writeToScreen(response.body);
			response.ack();

		},subscribeHeader);


		}, function (error) {
			wsCreateHandler && clearTimeout(wsCreateHandler);
			wsCreateHandler = setTimeout(function () {
				console.log("重连...");
	
				console.log(stompClient);
				connect();
			}, 10000);
		},'/'
	)
}

function disconnect() {
	if (stompClient != null) {
		stompClient.disconnect();
	}
	writeToScreen("disconnected");
}

function writeToScreen(message) {
	if(DEBUG_FLAG)
	{
		$("#debuggerInfo").val($("#debuggerInfo").val() + "\n" + message);
	}
}

function GetQueryString(name) {
	var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i");
	var r = window.location.search.substr(1).match(reg); 
	var context = "";
	if (r != null)
		context = r[2];
	reg = null;
	r = null;
	return context == null || context == "" || context == "undefined" ? "" : context;
}

定义消息体

msg_id : 消息id,唯一,可用于消息体

user_id : 用户ID

cat_id : 消息分类 ,1系统通知,2 登录消息,3支付消息,

client_id :客户端分类,0全部客户端,1网络货运,2车后,3财务,4 OA, 5 商城,6统一用户

model: 消息模式 ,0点对点推送,1广播模式

timestamp : 时间戳

data :内容

status :消息状态,默认为0,0未消费,1已消费

{
"msg_id":"xxxxx",
"user_id" : "12345",
"cat_id" : 1,
"client_id" : 0,
"model" : 0,
"level" : 2,
"durable" : 1,
"compensate" : 0,
"timestamp" : "1644463941",
"data" : "您刚在西安登录了",
"status" : 0
}

实例化数据库表

DROP TABLE IF EXISTS `rabbitmq_msg_log`;
CREATE TABLE `rabbitmq_msg_log` (
  `msg_id` varchar(100) NOT NULL AUTO_INCREMENT COMMENT '消息id,唯一,可用于消息体',
  `user_id` varchar(100) NOT NULL DEFAULT '' COMMENT '用户ID',
  `cat_id` varchar(100) NOT NULL DEFAULT '' COMMENT '消息分类 ,1系统通知,2 登录消息,3支付消息',
  `client_id` varchar(20) NOT NULL DEFAULT '' COMMENT '客户端分类,0全部客户端,1网络货运,2车后,3财务,4 OA, 5 商城,6统一用户',
  `model` int(8) NOT NULL DEFAULT 0 COMMENT '消息模式 ,0点对点推送,1广播模式',
  `data` text NOT NULL COMMENT '内容',
  `status` varchar(20) NOT NULL DEFAULT '' COMMENT '消息状态,默认为0,0未消费,1已消费,如果为0,当用户上线,就继续推送',
  `timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '时间',
  PRIMARY KEY (`msg_id`),
  KEY `user_id` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='rabbitmq消息';

js封装目标

精简、安全、

一、简单,业务端使用时0学习成本,引入一段js代码即可

二、自动连接到服务器

三、仅提供订阅地址,即可实现点对点推送

四、仅提供订阅地址,即可实现直推模式

五、重连,如果连接断开,则发起自动重连,每20秒重连一次,如果重连5次,依然无法连接,则每1分钟重连一次

六、拉取的数据具有存储本地缓存的功能

七、具有自动去重的功能,如果拉取的数据相同,则丢弃,不再重复存储

八、拉取数据后,需要回调函数返回拉取的消息

九、具有新消息提示功能

十、具有自定义配置功能

  1. 封装连接服务器方法connect (host,username,token,outgoing,incoming)
    参数:
    host 服务器地址(string)
    username:用户名(string)
    token:秘钥(string)
    outgoing:发送心跳 (int)(ms毫秒)
    incoming:接收心跳 (int)(ms毫秒)
  2. 封装订阅方法 subscribe(destination,header,ask)
    参数:
    destination:订阅地址(string)例如:/queue/15029149794_ios ,则路由到用户为15029149794的ios端
    header:头信息 {}  json格式
    ask 消息应答模式 默认为false,自动应答,为true则手动应答,需要和header参数结合使用,subscribeHeader = {
    "ack" : "client-individual"}
  1. 封装自动重连方法reconnect(second)
    second 自动重连秒数(int)
  2. 封装断开连接方法disconnect()
  1. 封装发送消息方法send()

各端定义

考虑到各端消息安全性,各端将以随机数方式展示

destination  /queue/用户名-dtybyWnjPwDIQNDsAE6M

dtybyWnjPwDIQNDsAE6M 网络货运
4nhO0hglWmkAw2sCDn0a 车逅
IPXpOnmCnO9fFbdlB4kZ AO
YJvu4HxWDyMj5hm4Q8GK 财务
58acsSg3jMPs39lOo4NP 统一平台
MqjOMAwJWbo5aDJV9L3S 商城

点对点流程图

rabbitmq,stomp.js,rabbitmq-auth-backend-http,消息调研,消息设计_第16张图片

生产者

1.双方生产端和消费端共同约束 队列名,
2.生产端只负责推送消息,不负责队列的维护
3.开启消息确认生产端消息确认模式,主要作用是否有权限投递以及是否投递到交换机,
4.Return 消息机制,确保消息被推送到指定队列,如果队列存在则,则投递成功,如果队列不存在,则触发renturn 机制,rabbitmq向生产者返回消息被拒绝提示,这样就可以做后续处理,这样保障了,只有客户端在线才能被消费,不在线则不发送到队列,节省了rabbitmq服务器资源

  1. 生产者发消息的同时,需要持久化消息到mysql数据库,如果触发reteurn 则 ,修改数据库,标记该用户未在线,投递被打回

消息服务器

  1. 用户以及token的验证验证,通过则继续,未通过则直接拒绝
  2. 登录验证通过后,校验该用户时候有读写权限,
  1. 路由到具体的交换机和队列,对数据开始读写操作

消费者

  1. rabbitmq 与客户端 连接 需要建立在 websocket +stomp协议
  2. 客户端 用户,token必须合法,才能建立连接,实现长链接,负责会被拒绝,无法访问
  1. stomp 通过subscribe 订阅地址 ,接受消息消费
  2. 客户端可以把消息存储在本地缓存,展示给消费者,展示方式需产品经理设计

总结

web-stomp插件

优点:

  1. 解决了web 应用,http协议,无法保持长连接困境
  2. 使得html页面与rabbitmq通信成为可能
  1. 长连接节约了频繁握手带来的资源损耗
  2. 提供了简单便捷的订阅,和发布功能
  1. rabbitmq 通过 stomp插件, 实现了 websocket 与rabbitmq数据交换,开发成本较低

问题:

  1. stomp 利用websocket通讯协议,实现了服务器与浏览器之间的全双工通讯,但是大量的websocket 链接,对rabbitmq服务器造成压力
  2. 由于stomp在与rabbitmq通讯是,需要添加用户名与token,这样把账号曝露给用户。造成安全隐患

HTTP后台权限验证

优点

  1. 统一授权验证服务,降低维护成本,实现了业务与消息的解耦
  2. 提高灵活度,降低对rabbtimq开发难度,开发者只负责推送或订阅消息,不再维护或交换机和队列
  1. cache 插件,rabbitmq 与http授权服务器之间搭建缓存中间件,有效解决对授权服务器的压力
  2. 真正做到一个账号一个只能看到自身的消息,解决了传统的一个rabbitmq账号负责所有交换机,队列,消息的创建,维护,一旦该账号泄露,后果严重
  1. 账号,权限更加细分变的方便,简单,灵活

缺点

  1. 频繁访问http后台服务,给授权服务器带来很大的压力,可以使用backend-cache插件来弥补
  2. 只能用于http后台授权与校验,不负责数据是否送达,存储或日志打印等权限之外的工作

附件

  1. web-stomp demo,见该文档随带压缩包
  2. http 授权源码 spring_boot

https://github.com/rabbitmq/rabbitmq-auth-backend-http/tree/master/examples/rabbitmq_auth_backend_spring_boot

参考资料

以上文档文献来源原文连接

  1. rabbitmq配置
    Configuration — RabbitMQ
  2. stomp 文档
    STOMP Plugin — RabbitMQ
    STOMP
    http://stomp.github.io/stomp-specification-1.1.html
  1. web stomp
    RabbitMQ Web STOMP Plugin — RabbitMQ
  2. webstomp简单demo, rabbitmq-web-stomp-examples
    https://github.com/rabbitmq/rabbitmq-web-stomp-examples
  1. 权限控制 access-control
    Authentication, Authorisation, Access Control — RabbitMQ
    Authentication, Authorisation, Access Control — RabbitMQ
    Authentication, Authorisation, Access Control — RabbitMQ
  2. http后台认证 rabbitmq-auth-backend-http
    GitHub - rabbitmq/rabbitmq-auth-backend-http: HTTP-based authorisation and authentication for RabbitMQ
  1. 后台认证缓存 rabbitmq-auth-backend-cache

https://github.com/rabbitmq/rabbitmq-auth-backend-cache

  1. 生产者publishers
    Publishers — RabbitMQ
  2. 队列queues
    Queues — RabbitMQ
  1. 消费者consumers
    Consumers — RabbitMQ

你可能感兴趣的:(消息中间件,rabbitmq,websocket,分布式)