消息队列-RabbitMQ

最新推荐文章于 2024-10-12 08:00:19 发布
最新推荐文章于 2024-10-12 08:00:19 发布
阅读量1k 收藏
点赞数
文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43204767/article/details/121418682
版权

一、Docker安装Rabbitmq

1.1Docker环境搭建

1、下载docker离线安装包
https://download.docker.com/linux/static/stable/x86_64/docker-20.10.6.tgz
选择版本
https://download.docker.com/linux/static/stable/
2、离线安装工具
https://github.com/Jrohy/docker-install/
3、将下载的安装文件放在一个目录中
4、把目录上传虚拟机上
5、修改docker-install执行权限
6、执行安装

# 进入 docker-install 文件夹
cd docker-install
# 为 docker-install 添加执行权限
chmod +x install.sh
# 安装
./install.sh -f docker-20.10.6.tgz

7、设置镜像加速
修改配置文件 /etc/docker/daemon.json

cat <<EOF > /etc/docker/daemon.json
{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "http://hub-mirror.c.163.com"
  ],
  "max-concurrent-downloads": 10,
  "log-driver": "json-file",
  "log-level": "warn",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
    },
  "data-root": "/var/lib/docker"
}
EOF

然后dockers就安装好了，可以愉快的使用docker搞事情了

1.2 Rabbitmq 搭建

1、配置管理员用户名密码

mkdir /etc/rabbitmq
vim /etc/rabbitmq/rabbitmq.conf
# 添加两行配置：
default_user = admin
default_pass = admin

2、启动Rabbitmq

docker run -d --name rabbit \
-p 5672:5672 \
-p 15672:15672 \
-v /etc/rabbitmq/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf \
-e RABBITMQ_CONFIG_FILE=/etc/rabbitmq/rabbitmq.conf \
--restart=always \
rabbitmq:management

访问管理控制台 http://192.168.64.140:15672
在这里插入图片描述
主要端口介绍
4369 – erlang发现口
5672 – client端通信口
15672 – 管理界面ui端口
25672 – server间内部通信口

二、RabbitMq使用场景

2.1 服务解耦

背景：传统的架构，上游的A服务调用下游的服务，业务之间的耦合性过于紧密。代码维护困难。
解决方法：A服务只需要向消息服务器发送消息,而不用考虑谁需要这些数据;下游服务如果需要数据,自行从消息服务器订阅消息,不再需要数据时则取消订阅即可

在这里插入图片描述

2.2 流量削峰

背景：当特殊时间突发的访问压力，后台服务器可能顶不住访问压力而崩溃。
解决方案：使用RabbitMQ来进行流量削峰,高峰情况下,瞬间出现的大量请求数据,先发送到消息队列服务器,排队等待被处理,而我们的应用,可以慢慢的从消息队列接收请求数据进行处理,这样把数据处理时间拉长,以减轻瞬时压力
在这里插入图片描述

2.3 异步调用

同步调用存在的问题：系统响应时间长，每个服务执行完成，调用链才算完成。但是由于网络问题，整个执行链都无法完成。
异步调用优势：消息生产者把生产的消息放入消息队列，消费者订阅消息队列，消费消息。系统响应时间短，

三、RabbitMq六种工作模式

3.1 简单模式

3.1.1 消息生产者

1、创建连接工程
2、配置连接参数
3、创建队列
4、创建通讯通道
5、向服务器发送消息

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1、连接
        ConnectionFactory f = new ConnectionFactory();
        //5672
        f.setHost("192.168.64.128");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        //创建连接
        //2、在服务器上创建队列
        Connection connection = f.newConnection();
        //创建通讯通道
        Channel c = connection.createChannel();
        /**     queue – the name of the queue
        1、是否为持久队列，服务器重启后还存在
        durable – true if we are declaring a durable queue (the queue will survive a server restart)
        2、是否为排他队列，多个消费者能不能从同一个队列消费消息。
        exclusive – true if we are declaring an exclusive queue (restricted to this connection)
        3、没有消费者时，该队列是否被删除。
        autoDelete – true if we are declaring an autodelete queue (server will delete it when no longer in use)
        4、队列的其他属性
        arguments – other properties (construction arguments) for the queue*/
        c.queueDeclare("hello-rabbitmq",false,false,false,null);
        //3、向队列发送消息
         /**Params:
         1、交换机：空串默认的交换机
         exchange – the exchange to publish the message to
         2、队列名
         routingKey – the routing key
         3、消息的其他参数属性
         props – other properties for the message - routing headers etc
         4、消息体，为字节数组
         body – the message body*/
        c.basicPublish("","hello-rabbitmq",null,"helloworld".getBytes());
    }
}

3.2.1 消息消费者

public class ConSumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1、连接
        ConnectionFactory f = new ConnectionFactory();
        //5672
        f.setHost("192.168.64.128");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        //创建连接
        //2、在服务器上创建队列
        Connection connection = f.newConnection();
        //创建通讯通道
        //2、创建队列(谁先启动谁创建队列)
        Channel c = connection.createChannel();
        c.queueDeclare("hello-rabbitmq",false,false,false,null);
        //3、从队列 接收消息，把消息传递给回调对象处理
        //创建回调对象
        DeliverCallback deliverCallback = (consumerTag,message) -> {
            byte[] body = message.getBody();
            System.out.println(new String(body));
        };
        CancelCallback cancelCallback = consumerTag -> {};
        /**
         * Params:
         * queue – the name of the queue
         1、手动确认：可以防止消息没有被消费；手动消费：消费者宕机，可能存在消息丢失的情况。
         * autoAck – true if the server should consider messages acknowledged once delivered;
         * false if the server should expect explicit acknowledgements
         * deliverCallback – callback when a message is delivered
         * cancelCallback – callback when the consumer is cancelled*/
        c.basicConsume("hello-rabbitmq",true,deliverCallback,cancelCallback);

3.2 工作模式

工作模式：
一个生产者，多个消费者，每个消费者获取到的消息唯一。
1、 自动模式
消费者从消息队列获取消息后，服务端就认为该消息已经成功消费。
2、 手动模式
消费者从消息队列获取消息后，服务端并没有标记为成功消费
消费者成功消费后需要将状态返回到服务端
在这里插入图片描述

3.2.1 消息生产者

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1、连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.128");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        //创建连接
        //2、在服务器上创建队列
        Connection connection = f.newConnection();
        //创建通讯通道
        Channel c = connection.createChannel();
        c.queueDeclare("hello-rabbitmq",false,false,false,null);
        //3、循环输入消息
        while (true){
            System.out.print("请输入消息");
            String msg = new Scanner(System.in).nextLine();
            c.basicPublish("","hello-rabbitmq", MessageProperties.PERSISTENT_BASIC,msg.getBytes());
        }
    }
}

3.2.2 消息消费者

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.128");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        //创建连接
        //2、在服务器上创建队列
        Connection connection = f.newConnection();
        //创建通讯通道
        //2、创建队列(谁先启动谁创建队列)
        Channel c = connection.createChannel();
        //1、回调对象
        //2、接收消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String msg = new String(message.getBody(), "UTF-8");
            System.out.println("收到消息:" + msg);
            for (int i = 0; i < msg.length(); i++) {
                if (msg.charAt(i) == '.'){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            /**1、在message对象中有一个tag回执，发给服务器,第二个参数：是否同时确认过收到的所有消息*/
            c.basicAck(message.getEnvelope().getDeliveryTag(),false);
            System.out.println("处理完成");
        };
        CancelCallback cancelCallback = consumerTag -> {
        };
        /**每次只收一条，处理完之前不收下一条*/
        c.basicQos(1);
        /**qos=1不许再手动确认模式下生效*/
        c.basicConsume("hello-rabbitmq", false, deliverCallback, cancelCallback);
    }
}

3.3 发布订阅模式

在这里插入图片描述

3.4 路由模式

在这里插入图片描述
再消息上携带一个关键词，再

3.6 主题模式

四、RabbitMq六种工作模式(整合springboot)

4.1 依赖导入

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

yml配置

spring:
  rabbitmq:
    host: 192.168.64.128
    port: 5672
    username: admin
    password: admin

4.2 简单模式(模式一)

@RabbitListener(queues = “helloworld”) 监听队列
@RabbitHandler //收消息，一个类中只能有一个@RabbitHandler，配合@RabbitListener使用

4.2.1 生产者

在这里插入图片描述

4.2.2 消费者

在这里插入图片描述

4.2.2 启动类配置队列参数

@SpringBootApplication
public class M1Application {
    public static void main(String[] args) {
        SpringApplication.run(M1Application.class,args);
    }

    /**设置队列参数:import org.springframework.amqp.core.Queue;
*         /**     queue – the name of the queue
*         1、是否为持久队列，服务器重启后还存在
*         durable – true if we are declaring a durable queue (the queue will survive a server restart)
*         2、是否为排他队列，多个消费者能不能从同一个队列消费消息。
*         exclusive – true if we are declaring an exclusive queue (restricted to this connection)
*         3、没有消费者时，该队列是否被删除。
*         autoDelete – true if we are declaring an autodelete queue (server will delete it when no longer in use)
*         4、队列的其他属性
*         arguments – other properties (construction arguments) for the queue*/
    @Bean
    public Queue helloworldQueue(){
        return new Queue("helloworld",false,false,false);
    }

    /**注入生成者*/
    @Autowired
    private Producer producer;

    /**Spring的主线程执行流程
     * 自动扫描创建实例--》完成依赖注入---》执行@PostConstruct--->后续步骤*/
    @PostConstruct
    public void test(){
        //新建一个线程，不不阻塞主线程
        new Thread(() -> {
            try {
                //等待消费者先启动
                Thread.sleep(3000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            producer.send();
        }).start();
    }

}

4.3 工作模式(模式二)

工作模式解决的问题：
合理分发：
1、自动确认设置为false
spring封装的rabbitmq默认手动保存
2、qos=1，与抓取消息数量

spring:
  rabbitmq:
    host: 192.168.64.128
    port: 5672
    username: admin
    password: admin
    listener:
      simple:
        prefetch: 1 #每次抓取一条，处理完之前不接收下一条，默认250

消息持久化：
1、队列持久化
在这里插入图片描述
2、消息数据的持久化
spring发送的消息默认就是持久消息

4.3.1 生产者

@Component
public class Producer {
    //发送消息的封装工具
    @Autowired
    private AmqpTemplate amqpTemplate;
    public void send(String s){
        //向队列中发送数据-自动转换为Bye数组
        //队列的参数在启动类中或则配置类中设置
        amqpTemplate.convertAndSend("tesk-queue",s);
    }
}

4.3.2 消费者

@Component
public class Consumer {

    @RabbitListener(queues = "tesk-queue")
    public void getmq1(String msg){
        System.out.println("消费者1收到消息:"+msg);
    }

    @RabbitListener(queues = "tesk-queue")
    public void getmq2(String msg){
        System.out.println("消费者2收到消息:"+msg);
    }
}

4.3.3 启动类

@SpringBootApplication
public class M2Application {
    public static void main(String[] args) {
        SpringApplication.run(M2Application.class, args);
    }

    @Bean
    public Queue helloworldQueue() {
        return new Queue("tesk-queue", false, false, false);
    }

    /**
     * 注入生成者
     */
    @Autowired
    private Producer producer;

    /**
     * Spring的主线程执行流程
     * 自动扫描创建实例--》完成依赖注入---》执行@PostConstruct--->后续步骤
     */
    @PostConstruct
    public void test() {
        //新建一个线程，不不阻塞主线程
        new Thread(() -> {
            while (true) {
                System.out.println("输入消息:");
                String s = new Scanner(System.in).nextLine();
                producer.send(s);
            }

        }).start();
    }
}

4.3 发布订阅模式(模式三)

生产者：指定交换机
消费者：创建队列，绑定交换机

4.3.1 生产者

生产者向指定的交换机 logs 发送数据.
不需要指定队列名或路由键, 即使指定也无效, 因为 fanout 交换机会向所有绑定的队列发送数据, 而不是有选择的发送.

@Component
public class Producer {
    //发送消息的封装工具
    @Autowired
    private AmqpTemplate amqpTemplate;
    public void send(String s){
        //向队列中发送数据-自动转换为Bye数组
        //队列的参数在启动类中或则配置类中设置
        amqpTemplate.convertAndSend("logs",s);
    }
}

4.3.2 消费者

消费者需要执行以下操作:
定义随机队列(随机命名,非持久,排他,自动删除)
定义交换机(可以省略, 已在主程序中定义)
将队列绑定到交换机
spring boot 通过注解完成以上操作:

@Component
public class Consumer {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(),//队列，随机命名，false,true
            //declare=false不创建交换机，而使用已存在的交换机
            exchange = @Exchange(value = "logs",declare = "false") //交换机

    ))
    public void getmq1(String msg){
        System.out.println("消费者1收到消息:"+msg);
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(),//队列，随机命名，false,true
            //declare=false不创建交换机，而使用已存在的交换机
            exchange = @Exchange(value = "logs",declare = "false") //交换机

    ))
    public void getmq2(String msg){
        System.out.println("消费者2收到消息:"+msg);
    }
}

4.3.3 主程序

@SpringBootApplication
public class M3Application {
    public static void main(String[] args) {
        SpringApplication.run(M3Application.class, args);
    }
    @Bean
    public FanoutExchange logs(){
        //非持久不自动删除
        return new FanoutExchange("logs",false,false);
    }
    
    @Autowired
    AmqpTemplate amqpTemplate;

    /**
     * Spring的主线程执行流程
     * 自动扫描创建实例--》完成依赖注入---》执行@PostConstruct--->后续步骤
     */
    @PostConstruct
    public void test() {
        //新建一个线程，不不阻塞主线程
        new Thread(() -> {
            while (true) {
                System.out.println("输入消息:");
                String s = new Scanner(System.in).nextLine();
                amqpTemplate.convertAndSend("logs","",s);
            }
        }).start();
    }
}

4.3 工作模式

4.3.1 生产者

4.3.2 消费者

4.3.3 主程序

4.3 工作模式

4.3.1 生产者

4.3.2 消费者

4.3.3 启动类

四、RabbitMQ服务配置刷新

主题模式：实现有选择的配置刷新

五、RabbitMQ订单流量削峰

提高系统高并发能力，削掉短时间的流量峰值，拉长订单处理时间，

白鹤青洲依旧
关注
Docker for rabbitmq
02-28
Windows操作系统下，基于Docker，创建rabbitmq容器，建立消息队列服务
【Docker】之安装 RabbitMQ
热门推荐
王廷云的博客
03-20 1万+
1、下载 RabbitMQ 镜像 下载最新版本的镜像： docker pull rabbitmq 更多版本的镜像可以访问 Docker 官网：https://hub.docker.com/_/rabbitmq?tab=tags 2、创建并运行 RabbitMQ 容器 启动命令： docker run -d -p 15672:15672 -p 5672:5672 \ -e RABBITMQ_DEFAULT_VHOST=my_vhost \ -e RABBITMQ_DEFAULT_USER=adm
Docker下安装RabbitMQ
最新发布
Zhaof_Notes
10-12 735
Docker下安装RabbitMQ, Docker安装RabbitMQ镜像
docker rabbitmq
dang7758的博客
06-17 319
docker run -d --hostname rabbitmq-p 5672:5672 -p 15672:15672 rabbitmq:3.7.14-management 如上会创建一个默认账号/密码 guest/guest docker run -d --hostname rabbitmq -e RABBITMQ_DEFAULT_USER=root -e RABBITMQ_DEFAUL...
docker-rabbitmq
dongfengpo25的博客
03-03 226
启动并创建admin-9999帐户 docker run -d --name rabbitmq -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=9999 -p 15672:15672 -p 5672:5672 rabbitmq:management
贝岭的matlab的代码-belling-spring-rabbitmq:Spring项目集成了消息队列-RabbitMQ，实现了普通消息订阅
06-16
贝岭的matlab的代码 ...rabbitmq-server-3.6.12.exe rabbitmq_delayed_message_exchange-0.0.1.ez （延时消息插件-必备） 注意事项 RabbitMQ本身是不支持延迟消息发送，需要下载rabbitmq_delayed_mess
108、AMQP消息队列-RabbitMQ1
08-04
总结：本案例主要介绍了如何在Symfony应用中集成RabbitMQ作为消息队列，利用Docker容器部署RabbitMQ服务，配置`.env`文件进行连接，并通过Symfony Messenger组件实现消息的发送和消费。同时，也展示了使用Doctrine ...
消息队列服务 - rabbitmq安装包 - 可视化界面管理
06-24
内容概要：这是一个包含 RabbitMQ 消息队列服务的安装包，RabbitMQ 是一个开源的消息代理软件，实现了高级消息队列协议（AMQP）的标准，支持多种消息格式，具有高度的消息传递可靠性，高并发性，用途广泛。...
Docker_RabbitMQ
水陌轻寒
08-27 338
文章目录1.寻找合适版本2.拉取镜像3.创建&启动容器4.查看正在运行容器 1.寻找合适版本 进入docker hub镜像仓库地址：https://hub.docker.com/ 搜索RabbitMQ，进入官方的镜像，可以看到以下几种类型的镜像； 选择带有“mangement”的版本（包含web管理页面） 2.拉取镜像 docker pull rabbitmq:3.7.7-management #查看所有镜像 docker images 3.创建&启动容器 # 运行 dock
docker使用rabbitmq
秒怂_z
09-16 141
docker使用rabbitmq 1.拉取rabbitmq（标签为management的是带web管理的，下载这个） docker pull rabbitmq:management 2.查看已下载的镜像 docker images 3.启动rabbitmq docker run -d --name rabbitmq -p 5671:5671 -p 5672:5672 -p 4369:4369 -p 25672:25672 -p 15671:15671 -p 15672:15672 rabbitmq:
Docker安装Rabbitmq(附带安装包)
qq_43980434的博客
06-07 451
没安装Docker看这篇Linux安装Docker。
Docker 安装 RabbitMQ
qq_33240755的博客
07-17 428
1.获取带有管理页面的rabbitmq镜像，此处选择rabbitmq:management，等待下载完成 docker pull rabbitmq:management                 2. 查看镜像是否已下载到本地 docker images       3. 使用镜像生成容器 docker run -d --name rabbitmq -...
Docker 安装 RabbitMQ
cat_watch的博客
06-19 96
拉取镜像 需要指定版本：拉取的镜像包含 web 控制台 docker pull rabbitmq:management 创建本地文件夹 mkdir /etc/rabbitmq 启动容器 docker run -d --name rabbit -v /etc/rabbitmq:/var/lib/rabbitmq --hostname rabbit -e RABBITMQ_DEFAULT_USER=root -e RABBITMQ_DEFAULT_PASS=123456 -p 15672:15
docker 启动 rabbitMQ
u012565281的博客
04-01 322
1.拉取镜像 docker pull rabbitmq:management 拉取带控制台的镜像版本 2、启动镜像 docker run -d -p 8080:15672 rabbitmq:management 启动端口可自定义设置 本次设置为8080 映射rabbitmq启动端口 默认启动端口为15672 3、进入控制台 启动成功 ...
Docker安装rabbitMQ
Brave_heart4pzj的博客
07-04 151
环境描述：Centos7上已安装Docker工具 第一步：下载rabbitMQ镜像命令 下载带management的镜像包，它有web页面供测试使用 docker pull rabbitmq:3-management 查看下载结果： docker images 第二步：运行rabbitMQ镜像命令 运行，并做端口映射： docker run -d -p 5672:5672 -p 15672:15672 --name myrabbitmq 415614b8c071 查看运行结果： docker ps
Docker安装RabbitMQ
qq_1801743621的博客
04-11 2300
docker run安装RabbitMQ，docker-compose安装RabbitMQ。RabbitMQ 是实现高级消息队列协议 (AMQP) 的开源消息代理软件（有时称为面向消息的中间件）。RabbitMQ 服务器是用 Erlang 编程语言编写的，并建立在 Open Telecom Platform 框架上，用于集群和故障转移。与代理交互的客户端库可用于所有主要编程语言。RabbitMQ 是轻量级的，是最受欢迎的开源消息代理之一，易于在本地和云端部署。它支持多种消息传递协议。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值