【无标题】rabbitmq的docker安装及使用

最新推荐文章于 2024-05-07 12:49:21 发布
最新推荐文章于 2024-05-07 12:49:21 发布
阅读量624 收藏 16
点赞数 29
文章标签： rabbitmq docker 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sncot/article/details/137602733
版权

rabbitmq的介绍、容器安装及使用

1、rabbitmq的介绍

#####什么是AMQP 和 JMS？

AMQP：即Advanced Message Queuing Protocol，是一个应用层标准高级消息队列协议，提供统一消息服务。是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现有RabbitMQ等。

JMS：即Java消息服务（Java Message Service）应用程序接口，由sun公司提出，并且sun公司定义好了接口。包括create、send、recieve。只要想使用它，就得实现它定义的接口。 消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。不好的地方是语言层面的限制，只能为JAVA，这其实稍微有点和微服务的观点相违背。要求语言只能是JAVA，而不能是py等。

常见的MQ产品

ActiveMQ：基于JMS，Apache

RocketMQ：（Rocket，火箭）阿里巴巴的产品，基于JMS，目前由Apache基于会维护

Kafka：分布式消息系统，亮点：吞吐量超级高，没秒中数十万的并发。

RabbitMQ：（Rabbit，兔子）由erlang语言开发，基于AMQP协议，在erlang语言特性的加持下，RabbitMQ稳定性要比其他的MQ产品好一些，而且erlang语言本身是面向高并发的编程的语言，所以RabbitMQ速度也非常快。且它基于AMQP协议，对分布式、微服务更友好。

rabbitmq的几个概念
  • virtual host
  • exchange（交换机）
  • routing key
  • binding key
  • 队列
  • channel
2、docker安装rabbitmq

拉取镜像 docker pull rabbitmq:latest

把rabbitmq镜像跑起来 docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:latest

进入容器 docker exec -it rabbitmq /bin/sh

运行rabbitmq的web管理器 rabbitmq-plugins enable rabbitmq-management

列出rabbitmq的用户 rabbitmqctl list_users

修改用户密码 rabbitmqctl change_password guest '950629'

使超级用户可以远程登陆（默认guest用户不可以远程登陆）echo loopback_users = none >> etc/rabbitmq/conf.d/10-defaults.conf

注意： 解决rabbitmq management API return status code 500 报错问题 echo management_agent.disable_metrics_collector = false > etc/rabbitmq/conf.d/20-management_agent.disable_metrics_collector.conf

退出容器 exit

重启容器 docker restart rabbitmq

连接管理页面 47.92.232.226:15672

3、rabbitmq的五种消息模型
简单模型

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

P（producer/ publisher）：生产者，发送消息的服务

C（consumer）：消费者，接收消息的服务

红色区域就是MQ中的Queue，可以把它理解成一个邮箱

  • 首先信件来了不强求必须马上马去拿
  • 其次,它是有最大容量的(受主机和磁盘的限制,是一个缓存区)
  • 允许多个消费者监听同一个队列，争抢消息，此时便是worker模型

示例：

//生产者
package main

import (
	"log"
	"strconv"
	"time"
	"github.com/streadway/amqp"
)

func main() {
	conn, err := amqp.Dial("amqp://guest:950629@47.92.232.226:5672//test")
	if err != nil {
		log.Fatal("连接失败")
		return
	}
	defer conn.Close()
	//创建channel
	chann, err := conn.Channel()
	if err != nil {
		log.Fatal("创建channel失败")
		return
	}
	defer chann.Close()

	//发送消息前必须声明一个queue，往这个队列中发送消息
	queue, err := chann.QueueDeclare(
		"hello",
		false, // 消息持久化
		false,
		false, //独有的，排他的
		false,
		nil)
	if err != nil {
		log.Fatal("创建队列失败！")
		return
	}
	//均衡策略 收到消费者的确认ack后再消费消息
	err = chann.Qos(
		1,
		0,
		false)
	if err != nil {
		return
	}
	message := "hello 潘丽萍！"
	i := 0
	for {
		err = chann.Publish(
			"",
			queue.Name,
			false,
			false,
			amqp.Publishing{
				//DeliveryMode: amqp.Persistent, //将mq中的消息持久化
				ContentType: "text/plain",
				Body:        []byte(message + strconv.Itoa(i)),
			})
		if err != nil {
			log.Fatal("发送消息失败")
			return
		}
		i++
		time.Sleep(time.Millisecond * 1000)
	}
}

//消费者
package main

import (
	"fmt"
	"log"

	"github.com/streadway/amqp"
)

func main() {
	//连接到rabbitmq
	conn, err := amqp.Dial("amqp://guest:950629@47.92.232.226:5672//test")
	if err != nil {
		log.Fatal("连接失败")
		return
	}
	defer conn.Close()
	// 创建一个channel
	chann, err := conn.Channel()
	if err != nil {
		log.Fatal("创建channel失败")
		return
	}
	defer chann.Close()

	//声明要消费的channel
	queue, err := chann.QueueDeclare(
		"hello",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		log.Fatal("声明消费的队列失败")
		return
	}

	delieverMsg, err := chann.Consume(
		queue.Name,
		"",
		true, //自动ACK 默认开启（有丢失消息的风险）
		false,
		false,
		false,
		nil,
	)
	if err != nil {
		log.Fatal("消费消息失败")
		return
	}
	err = chann.Qos(
		1,
		0,
		false)
	if err != nil {
		fmt.Println("设置均衡策略")
		return
	}

	for msg := range delieverMsg {
		fmt.Printf("RECV:%s\n", msg.Body)
		//msg.Ack(false) //手动ack，把上方自动ack设置为false
	}
}
worker模型

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Worker模型中也只有一个工作队列。但它是一种竞争消费模式。可以看到同一个队列我们绑定上了多个消费者

相较于简单模型多增加一个consumer

发布/订阅模型

注意： 以下三种模型，定义一个exchange后，可以绑定多个不同键（key）的队列，可以创建多个消费者向此exchange发送消息，exchange根据routing key向绑定的队列发送消息

发布/订阅之direct

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

注意交换机的名称为direct 以及添加 特定的routingkey，不支持通配符

示例：

//生产者1
package main

import (
	"fmt"
	"strconv"
	"time"

	"github.com/streadway/amqp"
)

func main() {
	conn, err := amqp.Dial("amqp://guest:950629@47.92.232.226:5672//test")
	if err != nil {
		fmt.Println("连接rabbitmq失败")
		return
	}
	defer conn.Close()
	chann, err := conn.Channel()
	if err != nil {
		fmt.Println("创建channel失败")
		fmt.Println(err)
		return
	}
	//声明一个交换机
	err = chann.ExchangeDeclare(
		"direct-ttt",
		"direct",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("创建channel失败")
		fmt.Println(err)
		return
	}
	//声明两个队列并绑定到交换机上
	queue, err := chann.QueueDeclare(
		"direct-log2",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("创建queue失败")
		return
	}
	err = chann.QueueBind(
		queue.Name,
		"error",
		"direct-ttt",
		false,
		nil)
	if err != nil {
		fmt.Println("绑定queue到change logs失败")
		return
	}
	queue1, err := chann.QueueDeclare(
		"direct-log3", //队列名称
		false,         //持久化
		false,         //自动删除
		false,         //唯一的
		false,         //不等待
		nil)           //参数
	if err != nil {
		fmt.Println("创建队列1失败")
		return
	}
	err = chann.QueueBind(
		queue1.Name,
		"info",
		"direct-ttt",
		false,
		nil)
	if err != nil {
		fmt.Println("queue1绑定change失败")
		return
	}
	msg := "你好！小潘"
	i := 0
	for {
		err = chann.Publish(
			"direct-ttt",
			"error",
			false,
			false,
			amqp.Publishing{
				ContentType: "text/plain",
				Body:        []byte(msg + strconv.Itoa(i)),
			})
		if err != nil {
			fmt.Println("生产者生产消息失败")
			return
		}
		i++
		time.Sleep(time.Second)
	}
}
//生产者2
package main

import (
	"fmt"
	"time"

	"github.com/streadway/amqp"
)

func main() {
	conn, err := amqp.Dial("amqp://guest:950629@47.92.232.226//test")
	if err != nil {
		fmt.Println("创建连接失败")
		return
	}
	defer conn.Close()

	chann, err := conn.Channel()
	if err != nil {
		fmt.Println("创建channel失败！")
		return
	}
	err = chann.ExchangeDeclare(
		"direct-ttt",
		"direct",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("声明exchange失败")
		return
	}
	queue1, err := chann.QueueDeclare(
		"direct-log3",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("创建queue1失败")
		return
	}
	err = chann.QueueBind(
		queue1.Name,
		"info",
		"direct-ttt",
		false,
		nil)
	if err != nil {
		fmt.Println("绑定队列失败")
		return
	}
	for {

		err = chann.Publish(
			"direct-ttt",
			"info",
			false,
			false,
			amqp.Publishing{ContentType: "test/plain",
				Body: []byte("小潘小潘")})
		if err != nil {
			fmt.Println("信息生产失败")
			return
		}
		time.Sleep(time.Second)
	}

}

//消费者1
package main

import (
	"fmt"

	"github.com/streadway/amqp"
)

func main() {
	conn, err := amqp.Dial("amqp://guest:950629@47.92.232.226//test")
	if err != nil {
		fmt.Println("创建连接失败")
		return
	}
	defer conn.Close()
	chann, err := conn.Channel()
	if err != nil {
		fmt.Println("创建channel失败")
		return
	}
	err = chann.ExchangeDeclare(
		"direct-ttt",
		"direct",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("exchange声明失败！")
		return
	}
	queue, err := chann.QueueDeclare(
		"direct-log2",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("queue声明失败")
		return
	}
	err = chann.QueueBind(
		queue.Name,
		"error",
		"direct-ttt",
		false,
		nil)
	if err != nil {
		fmt.Println("queue绑定exchange失败")
		return
	}
	msg, err := chann.Consume(
		queue.Name,
		"",
		true,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("消费者消费消息失败")
		return
	}
	for d := range msg {
		fmt.Printf("consumer2 RECV:%s\n", d.Body)
	}
}
//消费者2
package main

import (
	"fmt"

	"github.com/streadway/amqp"
)

func main() {
	conn, err := amqp.Dial("amqp://guest:950629@47.92.232.226:5672//test")
	if err != nil {
		fmt.Println("创建连接失败")
		return
	}
	defer conn.Close()
	chann, err := conn.Channel()
	if err != nil {
		fmt.Println("创建channel失败")
		return
	}
	err = chann.ExchangeDeclare(
		"direct-ttt",
		"direct",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("exchange声明失败！")
		return
	}
	queue, err := chann.QueueDeclare(
		"direct-log3",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("创建队列失败")
		return
	}
	err = chann.QueueBind(
		queue.Name,
		"info",
		"direct-ttt",
		false,
		nil)
	if err != nil {
		fmt.Println("queue绑定exchange失败")
		return
	}
	msg, err := chann.Consume(
		queue.Name,
		"",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("消费者消费消息失败")
		return
	}
	for d := range msg {
		fmt.Printf("consumer1 RECV:%s\n", d.Body)
		_ = d.Ack(false)
	}
}

以下两种模式和此模式类似，以下两种模式的示例省略部分代码。

发布/订阅之Topic

xxxxxxxxxx1 1{“msg”:{“date”:“date必须要晚于当前日期”}}go

和Direct模型相似，不同点：type为topic、并别routingkey支持正则表达式。#匹配一个至多个单词，*匹配一个单词。

示例：

//生产者  
package main

import (
	"fmt"
	"strconv"
	"time"

	"github.com/streadway/amqp"
)

func main() {
	conn, err := amqp.Dial("amqp://guest:950629@47.92.232.226:5672//test")
	if err != nil {
		fmt.Println("连接rabbitmq失败")
		return
	}
	defer conn.Close()
	chann, err := conn.Channel()
	if err != nil {
		fmt.Println("创建channel失败")
		fmt.Println(err)
		return
	}
	//声明一个交换机
	err = chann.ExchangeDeclare(
		"lllf",
		"topic",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("创建channel失败")
		fmt.Println(err)
		return
	}
	//声明两个队列并绑定到交换机上
	queue, err := chann.QueueDeclare(
		"topic-log",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("创建queue失败")
		return
	}
	err = chann.QueueBind(
		queue.Name,
		"c.*",
		"lllf",
		false,
		nil)
	if err != nil {
		fmt.Println("绑定queue到change logs失败")
		return
	}
	queue1, err := chann.QueueDeclare(
		"topic-log1", //队列名称
		false,        //持久化
		false,        //自动删除
		false,        //唯一的
		false,        //不等待
		nil)          //参数
	if err != nil {
		fmt.Println("创建队列1失败")
		return
	}
	err = chann.QueueBind(
		queue1.Name,
		"c.g",
		"lllf",
		false,
		nil)
	if err != nil {
		fmt.Println("queue1绑定change失败")
		return
	}
	msg := "你好！小潘"
	i := 0
	for {
		err = chann.Publish(
			"lllf",
			"c.k",
			false,
			false,
			amqp.Publishing{
				ContentType: "text/plain",
				Body:        []byte(msg + strconv.Itoa(i)),
			})
		if err != nil {
			fmt.Println("生产者生产消息失败")
			return
		}
		i++
		time.Sleep(time.Second)
       
	}
}
//消费者
package main

import (
	"fmt"

	"github.com/streadway/amqp"
)

func main() {
    conn, err := amqp.Dial("amqp://guest:950629@47.92.232.226:5672//test")
	if err != nil {
		fmt.Println("创建连接失败")
		return
	}
	defer conn.Close()
	chann, err := conn.Channel()
	if err != nil {
		fmt.Println("创建channel失败")
		return
	}
	err = chann.ExchangeDeclare(
		"lllf",
		"topic",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("exchange声明失败！")
		return
	}
	queue, err := chann.QueueDeclare(
		"topic-log",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("queue声明失败")
		return
	}
	err = chann.QueueBind(
		queue.Name,
		"c.*",
		"lllf",
		false,
		nil)
	if err != nil {
		fmt.Println("queue绑定exchange失败")
		return
	}
	msg, err := chann.Consume(
		queue.Name,
		"",
		true,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("消费者消费消息失败")
		return
	}
	for d := range msg {
		fmt.Printf("consumer2 RECV:%s\n", d.Body)
	}
}
发布/订阅之fanout

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

这个模型的特点就是它在发送消息的时候，并没有指明Rounting Key ， 或者说他指定了Routing Key，但是所有的消费者都知道，大家都能接收到消息,就像听广播。

生产者：在获取channel之后紧接着创建一个交换机，交换机的类型为 fanout 扇出。

注意，fanout模式会忽略路由规则和queue名称，所有绑定到该exchange的队列都会收到消息

示例：

//生产者
package main

import (
	"fmt"
	"strconv"
	"time"

	"github.com/streadway/amqp"
)

func main() {
	conn, err := amqp.Dial("amqp://guest:950629@47.92.232.226:5672//test")
	if err != nil {
		fmt.Println("连接rabbitmq失败")
		return
	}
	defer conn.Close()
	chann, err := conn.Channel()
	if err != nil {
		fmt.Println("创建channel失败")
		return
	}
	err = chann.ExchangeDeclare(
		"logs",//交换机名称
		"fanout",//交换机类型
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("创建channel失败")
		return
	}
	queue, err := chann.QueueDeclare(
		"",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("创建queue失败")
		return
	}
	err = chann.QueueBind(
		"",
		"",
		"logs",
		false,
		nil)
	if err != nil {
		fmt.Println("绑定queue到change logs失败")
		return
	}
	msg := "你好！小潘"
	i := 0
	for {
		err = chann.Publish(
			"logs",
			"",
			false,
			false,
			amqp.Publishing{
				ContentType: "text/plain",
				Body:        []byte(msg + strconv.Itoa(i)),
			})
		if err != nil {
			fmt.Println("生产者生产消息失败")
			return
		}
		i++
		time.Sleep(time.Second)
	}
}

//消费者  
package main

import (
	"fmt"

	"github.com/streadway/amqp"
)

func main() {
    conn, err := amqp.Dial("amqp://guest:950629@47.92.232.226:5672//test")
	if err != nil {
		fmt.Println("创建连接失败")
		return
	}
	defer conn.Close()
	chann, err := conn.Channel()
	if err != nil {
		fmt.Println("创建channel失败")
		return
	}
	err = chann.ExchangeDeclare(
		"logs",
		"fanout",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("exchange声明失败！")
		return
	}
	queue, err := chann.QueueDeclare(
		"fanout-log",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("queue声明失败")
		return
	}
	err = chann.QueueBind(
		"",
		"rrrrr",
		"logs",
		false,
		nil)
	if err != nil {
		fmt.Println("queue绑定exchange失败")
		return
	}
	msg, err := chann.Consume(
		"",
		"",
		true,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("消费者消费消息失败")
		return
	}
	for d := range msg {
		fmt.Printf("consumer2 RECV:%s\n", d.Body)
	}
}

注意： fanout、topic和direct模式的区别在于键（key）的不同

4、rabbitmq的消息持久化
交换机持久化
	err = chann.ExchangeDeclare(
		"direct-ttt",
		"direct",
		true,   //durable 设置为true
		false,
		false,
		false,
		nil)
队列持久化
queue, err := chann.QueueDeclare(
   	"direct-log2",
   	true,  //durable设置为true
   	false,
   	false,
   	false,
   	nil
持久化消息
err = chann.Publish(
			"direct-ttt",
			"error",
			false,
			false,
			amqp.Publishing{
				DeliveryMode: amqp.Persistent,//持久化消息
				ContentType:  "text/plain",
				Body:         []byte(msg + strconv.Itoa(i)),
			})
5、rabbitmq的消息确认机制
自动确认

消费端自动确认的部分代码

msg, err := chann.Consume(
		queue.Name,
		"",
		true,
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("消费者消费消息失败")
		return
	}
	for d := range msg {
		fmt.Printf("consumer2 RECV:%s\n", d.Body)
	}
手动确认

贴入消费者cli的部分代码

msg, err := chann.Consume(
		queue.Name,
		"",
		false,  //自动确认设置为false
		false,
		false,
		false,
		nil)
	if err != nil {
		fmt.Println("消费者消费消息失败")
		return
	}
	for d := range msg {
		fmt.Printf("consumer1 RECV:%s\n", d.Body)
		_ = d.Ack(false) // 设置了手动确认
	}
Sncot
关注
  • 29
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ARM版本的 rabbitmq docker镜像资源
12-20
ARM版本的 rabbitmq 镜像资源 版本 3.8.9 使用拷贝到主机 执行：docker load < rabbitmq_arm3.8.9.tar 生成docker镜像
华为云云耀云服务器L实例评测｜RabbitMQ的Docker版本安装 + 延迟插件安装 & QQ邮箱和阿里云短信验证码的主题模式发送
Perley620的博客，专注后端领域
10-04 1328
本篇博客介绍RabbitMQ的Docker版本安装和配置，延迟插件的安装；结合QQ邮箱和阿里云短信验证码服务，采用主题模式进行验证码的发送。
Windows关于Docker安装Rabbitmq后无法打开Web页面以及Channel报错的问题
shiyansama的博客
04-27 3742
对于标题描述的错误，网上已经有很多解决方法，这里仅作为对我遇到过的经历做一个总结，方便日后自己查阅 启动Web管理页面 首先是没有Web界面的问题。 出现如下图的界面： 或者在底部提示： 方法一：关闭代理（这个我试了，没有用处） 方法二：手动启动Web管理页面： Docker启动Rabbitmq Web页面的命令跟在Windows的方式一致。首先需要进入到容器内部： rabbitmq替换为自己的容器名或者id docker exec -it rabbitmq /bin/bash 然后运行下面的.
阿里云服务器 Docker安装Nginx,RabbitMQ
小白鼠丶
10-31 881
1 搜索nginx镜像. docker search nginx 2 拉取nginx最新的镜像 docker pull ngnix 3 启动一个容器 docker run --name nginx -p 8081:80 -d nginx nginx 容器名称。 -d设置容器在在后台一直运行。 -p端口进行映射，将本地 8081 端口映射到...
【无标题】Docker
weixin_68709205的博客
12-08 256
docker的简单介绍及了解
Docker RabbitMQ镜像的management、MQTT和STOMP插件配置
xuan602的博客
11-20 4500
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 • 参考ht...
RabbitMQ的安装
蜂蜜蘸鱿鱼脚的博客
08-22 675
rabbitmq安装
RabbitMQ+docker快速体验
ChristineTX的博客
06-24 372
1.什么是消息中间件 消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量 削锋等问题实现高性能，高可用，可伸缩和最终一致性[架构] 使用较多的消息队列有 ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ 以下介绍消息队列在实际应用中常用的使用场景：异步处理，应用解耦，流量削锋和消 息通讯四个场景 2. 简介 RabbitMQ 是一个...
RabbitMq介绍和使用
weixin_44353972的博客
01-05 2684
springboot+rabbitmq
史上最全，centos7安装rabbitmq3.7x(传统方式+Docker)
爆裂无球的程序空间
08-17 1538
史上最全，centos7安装rabbitmq3.7x 每天多学一点点~ 写博客的目的不仅在于分享，也是为了方便日后复习巩固 话不多说，这就开始吧… 文章目录史上最全，centos7安装rabbitmq3.7x1.序2.安装erlang3.安装rabbitmq4.配置rabbitmq的管理界面5.总结6.结语 1.序 国网服务器原本已经装好了rabbitmq，无奈版本太低，要装到制定版本。遂自己重新...
rabbitmq docker镜像压缩包
01-29
rabbitmq docker镜像压缩包
docker快速安装rabbitmq的方法步骤
09-29
主要介绍了docker快速安装rabbitmq的方法步骤，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
docker 安装 rabbitmq
11-14
docker 安装 rabbitmq
rabbitMq 0 到1
WindwirdBird的博客
05-01 702
工作中MQ的使用场景是数不胜数，每个公司的技术选型又不太一样，用的哪个MQ，我们必须要先玩起来，RabbitMQ在windows安装遇到很多问题，博客也是五花八门，算了还是自己搞吧，记录一下，希望可以帮助更多的兄弟，也方便自己查询。我们就以我们的windows为例进行实操。
【消息队列】RabbitMQ五种消息模式
weixin_62513677的博客
04-30 2197
Spring AMQP是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息，包含两部分，其中Spring-amqp是基础抽象，spring-rabbit是底层的默认实现。这是为了防止消息队列中的队列不存在，在进行消息队列初始化的时候不知道是先建立消费者，还是先建立生产者，所以都执行创建函数，但是创建的队列只有一个不会重复。发布者发送消息时，指定消息的RoutingKey，Exchange将消息路由到BindingKey与消息RoutingKey一致的队列。Work queue，工作队列。
RabbitMQ之生产批量发送
CSDN_LiMingfly的博客
05-01 534
timeout ：超过收集的时间的最大等待时长，单位：毫秒。不过要注意，这里的超时开始计时的时间，是以最后一次发送时间为起点。但是 RabbitMQ 并没有提供了批量发送消息的 API 接口,使用 spring-amqp 的 BatchingRabbitTemplate 实现批量能力。不过值得注意的是，我们一次发送十条消息到 RabbitMQ Broker 中去，在 RabbitMQ Broker 显示的也是 1 个消息。bufferLimit ：超过收集的消息占用的最大内存。
RabbitMQ：深入理解高性能消息队列
最新发布
shiranyyds的博客
05-07 1033
RabbitMQ是一个由Erlang语言开发的AMQP（高级消息队列协议）开源实现，它提供了丰富的API供开发者使用，并且支持多种消息协议。RabbitMQ的主要功能包括消息的生产、存储、消费和路由等，通过灵活的路由规则和消息队列机制，实现了系统间的解耦和异步通信。RabbitMQ作为一款高性能、高可靠性的开源消息队列系统，在分布式系统和服务化架构中发挥着重要作用。通过深入理解RabbitMQ的基本概念工作原理和使用场景等方面的知识，我们可以更好地利用RabbitMQ解决系统间的通信和协作问题。
RabbitMQ之事务机制
CSDN_LiMingfly的博客
05-01 649
事务要么成功 要么失败 传统事务有4个主要特性:原子性、一致性、隔离性、持久性。◆ Eventually consistent (最终一致性)◆ 分区容忍性 (Partition tolerance)◆ 随着后端架构的微服务化，事务无法在本地完成。◆ 在传统单体应用中，事务在本地即可完成。◆ 可用性(Availability)◆ 一致性(Consistency)◆ 一致性(Consistency)◆ 持久性(Durability)◆ 原子性(Atomicity)◆ 隔离性(Isolation)
RabbitMQ使用docker安装方法
01-27
以下是使用Docker安装RabbitMQ的方法： 1. 拉取RabbitMQ镜像： ```shell docker pull rabbitmq:3.12 ``` 2. 创建并运行容器： ```shell docker run -d --name myrabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值