MQ消息队列的简单入门

最新推荐文章于 2024-05-27 13:42:30 发布
最新推荐文章于 2024-05-27 13:42:30 发布
阅读量2.1k 收藏 7
点赞数
文章标签： java-rabbitmq rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52942832/article/details/129622146
版权

一、介绍

1.消息队列（MQ）

1.1 什么是消息队列

消息队列，即MQ，Message Queue。

在这里插入图片描述

消息队列是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。

如果以后有其它系统也依赖商品服务的数据，同样监听消息即可，商品服务无需任何代码修改。

1.2 AMQP和JMS

MQ是消息通信的模型，并不是具体实现。现在实现MQ的有两种主流方式：AMQP （RabbitMQ）、JMS（ActiveMQ，RocketMQ）。

​ 网络协议7层，应用层，表示层，会话层，传输层，网络链路层，数据层，物理层

在这里插入图片描述

在这里插入图片描述

两者间的区别和联系：

  • JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式
  • JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。
  • JMS规定了两种消息模型；而AMQP的消息模型更加丰富

1.3 常见MQ产品

在这里插入图片描述

  • ActiveMQ：基于JMS, 社区不活跃，导致应用较少。
  • RabbitMQ：基于AMQP协议，erlang语言开发，稳定性好
  • RocketMQ：基于JMS，阿里巴巴产品，目前交由Apache基金会，支持分布式事务的
  • Kafka：分布式消息系统，高吞吐量 , 数据传输可能会有遗漏

1.4 MQ的应用场景

  1. 异步处理。不需要等待

  2. 流量削峰填谷。秒杀活动

  3. 应用解耦

  4. 日志处理

二、RabbitMQ安装

1.docker镜像下载

docker pull rabbitmq:3.8.9-management

注意：如果docker pull rabbitmq 后面不带management，启动rabbitmq后是无法打开管理界面的，所以我们要下载带management插件的rabbitmq.

2.查看docker镜像

docker images

#### [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FH23W3ug-1679042347718)(assets/image-20210303114254928.png)]

3.创建RabbitMQ容器

docker run -di -p 5672:5672 -p 15672:15672 --name rabbitmq rabbitmq:3.8.9-management

4.访问管理界面

访问管理界面的地址就是 http://192.168.188.128:15672，可以使用默认的账户登录，用户名和密码都guest
在这里插入图片描述

在这里插入图片描述

三、SpringBoot整合AMQP

1. 简单队列模式（Queue）

RabbitMQ是一个消息代理：它接受和转发消息。 你可以把它想象成一个邮局：当你把邮件放在邮箱里时，你可以确定邮差先生最终会把邮件发送给你的收件人。 在这个比喻中，RabbitMQ是邮政信箱，邮局和邮递员。

RabbitMQ与邮局的主要区别是它不处理纸张，而是接受，存储和转发数据消息的二进制数据块。

在这里插入图片描述

P（producer/ publisher）：生产者，一个发送消息的用户应用程序。

C（consumer）：消费者，消费和接收有类似的意思，消费者是一个主要用来等待接收消息的用户应用程序

队列（红色区域）：RabbitMQ内部类似于邮箱的一个概念。虽然消息流经RabbitMQ和你的应用程序，但是它们只能存储在队列中。队列只受主机的内存和磁盘限制，实质上是一个大的消息缓冲区。许多生产者可以发送消息到一个队列，许多消费者可以尝试从一个队列接收数据。

总之：

生产者将消息发送到队列，消费者从队列中获取消息，队列是存储消息的缓冲区。

我们将用SpringBoot编写两个程序;发送单个消息的生产者，以及接收消息并将其打印出来的消费者。

我们将调用我们的消息发布者（发送者）Send和我们的消息消费者（接收者）Recv。发布者将连接到RabbitMQ，发送一条消息，然后退出。

1.1 导入依赖

在这里插入图片描述
在这里插入图片描述
pom.xml 代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.af</groupId>
    <artifactId>spring-amqp-demo01</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-amqp-demo01</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

1.2 修改配置文件

application.yml，代码如下

spring:
  rabbitmq:
    host: 192.168.188.128
    port: 5672
    username: guest
    password: guest

1.3 创建配置类

package com.af.config;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SimpleQueueConfig {

    /**
     * 定义简单队列名
     */
    private String simpleQueue = "spring.test.queue";

    @Bean
    public Queue simpleQueue() {
        return new Queue(simpleQueue);
    }
}

1.4 发送端

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SendController {
    @Autowired
    private RabbitTemplate rabbitTemplate;


    @RequestMapping("/")
    public void send() {
        for(int i=0;i<5;i++) {
            rabbitTemplate.convertAndSend("spring.test.queue", "简单队列消息"+i);
        }
    }
}

1.5 接收端

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ReceiveListener {
    @RabbitListener(queues= "spring.test.queue")
    public void recieve(String message) {
        System.out.println(message);
    }
}

1.6 输出

访问http://localhost:8080/

控制台输出

在这里插入图片描述

2.work消息模型

工作队列或者竞争消费者模式
在这里插入图片描述
创建一个工作队列，在多个工作者之间分配耗时任务。

工作队列，又称任务队列。主要思想就是避免执行资源密集型任务时，必须等待它执行完成。相反我们稍后完成任务，我们将任务封装为消息并将其发送到队列。 在后台运行的工作进程将获取任务并最终执行作业。当你运行许多工人时，任务将在他们之间共享，但是一个消息只能被一个消费者获取。

这个概念在Web应用程序中特别有用，因为在短的HTTP请求窗口中无法处理复杂的任务。

接下来我们来模拟这个流程：

​ P：生产者：任务的发布者

​ C1：消费者，领取任务并且完成任务，假设完成速度较快

​ C2：消费者2：领取任务并完成任务，假设完成速度慢

2.1 发送端

@RestController
public class SendController {
    @Autowired
    private RabbitTemplate rabbitTemplate;


    @RequestMapping("/")
    public void send() {
        for (int i = 0; i < 50; i++) {
            String message = "工作队列消息" + i;
            rabbitTemplate.convertAndSend("work_queue", message);
        }
    }
}

这里我们循环发送50条消息

2.2 接收端

@Component
public class ReceiveListener {
    @RabbitListener(queues = "work_queue")
    public void recieve1(String message) {
        System.out.println("listener1:" + message);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @RabbitListener(queues = "work_queue")
    public void recieve2(String message) {
        System.out.println("listener2:" + message);
    }
}

我们在消费者1里设置延时时间，模式消费耗时

2.3 输出

访问http://localhost:8080/

控制台输出
在这里插入图片描述
可以发现，两个消费者各自消费了25条消息，而且各不相同，这就实现了任务的分发，并且平均分配。

2.4 能者多劳

刚才的实现有问题吗？

  • 消费者1比消费者2的效率要低，一次任务的耗时较长
  • 然而两人最终消费的消息数量是一样的
  • 消费者2大量时间处于空闲状态，消费者1一直忙碌

现在的状态属于是把任务平均分配，正确的做法应该是消费越快的人，消费的越多。

怎么实现呢？

我们可以设置每次只处理一个信息，告诉RabbitMQ一次不要向消费端发送多于一条消息。 或者换句话说，不要向消费端发送新消息，直到它处理并确认了前一个消息。 相反，它会将其分派给不是处于忙碌状态的下一个消费端。

修改配置文件，如下：

在这里插入图片描述

再次运行程序，效果如下：
在这里插入图片描述

3. 发布者订阅者模式（Publish/Subscribe）

在之前的模式中，我们创建了一个工作队列。 工作队列背后的假设是：每个任务只被传递给一个工作人员。 在这一部分，我们将做一些完全不同的事情 - 我们将会传递一个信息给多个消费者。 这种模式被称为“发布/订阅”。

解读：

1、1个生产者，多个消费者

2、每一个消费者都有自己的一个队列

3、生产者没有将消息直接发送到队列，而是发送到了交换机

4、每个队列都要绑定到交换机

5、生产者发送的消息，经过交换机到达队列，实现一个消息被多个消费者获取的目的

X（Exchanges）：交换机一方面：接收生产者发送的消息。另一方面：知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。

Exchange类型有以下几种：

​ Fanout：广播，将消息交给所有绑定到交换机的队列

​ Direct：定向，把消息交给符合指定routing key 的队列 (默认)

​ Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

我们这里先学习

​ Fanout：即广播模式

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

3.1 发送端

package com.af.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SendController {
    @Autowired
    private RabbitTemplate rabbitTemplate;


    @RequestMapping("/")
    public void send() {
        for (int i = 0; i < 5; i++) {
            String message = "订阅模式消息" + i;
            // 第二个参数路由  不需要
            rabbitTemplate.convertAndSend("fanoutExchange", "", message); 
        }
    }
}

3.2 接收端

package com.af.listener;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ReceiveListener {
    @RabbitListener(bindings =
        @QueueBinding(
                value = @Queue, // 临时创建队列
                exchange = @Exchange(value = "fanoutExchange",type="fanout") // 交换机
        )
    )
    public void recieve1(String message) {
        System.out.println("listener1:" + message);
    }

    @RabbitListener(bindings =
        @QueueBinding( // 绑定队列
                value = @Queue, // 临时创建队列
                exchange = @Exchange(value = "fanoutExchange",type="fanout") // 交换机
        )
    )
    public void recieve2(String message) {
        System.out.println("listener2:" + message);
    }
}

3.3 输出

访问 http://localhost:8080/

输出

在这里插入图片描述

控制台打印 ，发现两个绑定了不同队列的消费者都接受到了同一条消息
查看RabbitMq 服务器：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.路由模式（Direct）

有选择性的接收消息

在订阅模式中，生产者发布消息，所有消费者都可以获取所有消息。

在路由模式中，我们将添加一个功能 - 只能订阅一部分消息。 例如，我们只能将重要的错误消息引导到日志文件（以节省磁盘空间），同时仍然能够在控制台上打印所有日志消息。

但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

在Direct模型下，队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）

消息的发送方在向Exchange发送消息时，也必须指定消息的routing key。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6x4Q8sog-1679042843697)(assets/1532766437787.png)]

P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。

X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与routing key完全匹配的队列

C1：消费者，其所在队列指定了需要routing key 为 error 的消息

C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息

4.1 发送端

@RestController
public class SendController {
    @Autowired
    private RabbitTemplate rabbitTemplate;


    @RequestMapping("/send01")
    public void sendMessageA() {
        for (int i = 0; i < 5; i++) {
            String message = "路由模式--routingKey=update消息" + i;
            System.out.println("我是生产信息的：" + message);
            rabbitTemplate.convertAndSend("directExchange", "update", message);
        }
    }
    @RequestMapping("/send02")
    public void sendMessageB() {
        for (int i = 0; i < 5; i++) {
            String message = "路由模式--routingKey=add消息" + i;
            System.out.println("我是生产信息的：" + message);
            rabbitTemplate.convertAndSend("directExchange", "add", message);
        }
    }
}

4.2 接收端

@Component
public class ReceiveListener {
    @RabbitListener(bindings =
        @QueueBinding(
                value = @Queue, // 临时创建队列
          			// 交换机  direct是默认值，可以不定义
                exchange = @Exchange(value = "directExchange",type = "direct"), 
                key = {"update","add"} // 接收的路由
        )
    )
    public void recieve_direct(String message) {
        System.out.println("listener_direct_1:" + message);
    }

    @RabbitListener(bindings =
        @QueueBinding(
                value = @Queue, // 临时创建队列
          			// 交换机  direct是默认值，可以不定义
                exchange = @Exchange(value = "directExchange",type = "direct"), 
                key = {"add"}  // 接收的路由
        )
    )
    public void recieve_direct2(String message) {
        System.out.println("listener_direct_2:" + message);
    }
}

4.4 输出

访问http://localhost:8080/send01

在这里插入图片描述

访问http://localhost:8080/send02

在这里插入图片描述

5. 主题模式（Topic）

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

​ #：匹配一个或多个词

​ *：匹配不多不少恰好1个词

举例：

​ audit.#：能够匹配audit.irs.corporate 或者 audit.irs

​ audit.*：只能匹配audit.irs

在这里插入图片描述

在这个例子中，我们将发送所有描述动物的消息。消息将使用由三个字（两个点）组成的routing key发送。路由关键字中的第一个单词将描述速度，第二个颜色和第三个种类：“..”。

我们创建了三个绑定：Q1绑定了绑定键“* .orange.”，Q2绑定了“.*.rabbit”和“lazy.＃”。

Q1匹配所有的橙色动物。

Q2匹配关于兔子以及懒惰动物的消息。

5.1 发送端

package com.af.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SendController {
    @Autowired
    private RabbitTemplate rabbitTemplate;


   @RequestMapping("/send01")
    public void send01() {
        for (int i = 0; i < 5; i++) {
            String message = "通配符模式--routingKey=topic.keyA消息" + i;
            System.out.println("我是生产信息的：" + message);
            rabbitTemplate.convertAndSend("topicExchange", "topic.keyA", message);
        }
    }
    @RequestMapping("/send02")
    public void send02(){
        for (int i = 0; i < 5; i++) {
            String message = "通配符模式--routingKey=topic.#消息" + i;
            System.out.println("我是生产信息的：" + message);
            rabbitTemplate.convertAndSend("topicExchange", "topic.keyD.keyE", message);
        }
    }
}

5.2 接收端

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ReceiveListener {
    @RabbitListener(bindings =
        @QueueBinding(
                value = @Queue, // 临时创建队列
                exchange = @Exchange(type = "topic" , name = "topicExchange"), // 交换机
                key = {"topic.*"} // 接收的路由 topic.后有一个词
        )
    )
    public void recieve_direct(String message) {
        System.out.println("listener_direct_1:" + message);
    }

    @RabbitListener(bindings =
        @QueueBinding(
                value = @Queue, // 临时创建队列
                exchange = @Exchange(type = "topic" , name = "topicExchange"), // 交换机
                key = {"topic.#"}  // 接收的路由 topic.后有多个词
        )
    )
    public void recieve_direct2(String message) {
        System.out.println("listener_direct_2:" + message);
    }
}

5.3 输出

访问http://localhost:8080/send01

输出，发现两个消费者都能消费

在这里插入图片描述

访问http://localhost:8080/send02

输出，发现只有消费者2 可以消费

在这里插入图片描述

查看RabbitMq 服务器：
在这里插入图片描述

阿飞的小笔记
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
5.RabbitMQ消息队列类型（7个）详细使用
相互学习 共同进步
05-22 2341
RabbitMQ是消息代理：接受并转发消息。可以将其视为邮局 将要发布的邮件放在邮箱中时，可以确保邮递员最终将邮件传递给收件人。以此类推，RabbitMQ是一个邮箱、一个邮局和一个邮递员 RabbitMQ与邮局之间的主要区别在于，它不处理纸张。只是做接收、存储和转发数据消息的二进制码 AMQP（Advanced Message Queuing Protocol，高级消息队列协议） 应用层协议的一个开放标准，为面向消息的中间件设计。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性
消息队列MQ
sinat_34814635的博客
03-27 2151
消息队列概述 消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ mq的使用场景 1.应用解耦 2.异步处理 3.流量削锋 4.消息通讯（实时消息） 5.日志处理（待应用验证） 参考资料： 1.MQ的使用场...
Java项目之消息队列（手写java模拟实现mq）【一、实现mq必须知道的内容！！！】✔ ★
最新发布
蓝天it（让亿万孩子在蓝天下共享优质教育）
05-27 1060
另⼀⽅⾯, Producer 和 Consumer 则通过⽹络的⽅式, 远程调⽤这些 API, 实现 ⽣产者消费者模型.• Topic 是发⼀个画图红包, 发 10 块钱红包, 同时出个题, 得画的像的⼈, 才能领. 也是每个领到的⼈。⼿动应答的⽬的, 是为了保证消息确实被消费者处理成功了. 在⼀些对于数据可靠性要求⾼的场景, ⽐较常⻅.在实际的后端开发中, 尤其是分布式系统⾥, 跨主机之间使⽤⽣产者消费者模型, 也是⾮常普遍的需求.
RabbitMq------初级+高级（一）
weixin_54406708的博客
08-02 2128
基于spring-boot-AMQP来对rabbitmq进行消息的异步发送，以及对应的队列。
【消息队列MQ】各类MQ比较
热门推荐
sunxinhere的专栏
09-11 33万+
目前业界有很多MQ产品，我们作如下对比： RabbitMQ 是使用Erlang编写的一个开源的消息队列，本身支持很多的协议：AMQP，XMPP, SMTP, STOMP，也正是如此，使的它变的非常重量级，更适合于企业级的开发。同时实现了一个经纪人(Broker)构架，这意味着消息在发送给客户端时先在中心队列排队。对路由(Routing)，负载均衡(Load balance)或者数据持久化都有很
RabbitMQ使用教程(超详细)
丶自定义
05-24 1870
推荐springCloud教程：https://blog.csdn.net/hellozpc/article/details/83692496 推荐Springboot2.0教程：https://blog.csdn.net/hellozpc/article/details/82531834 文章目录 RabbitMQ实战教程 1.什么是MQ 2.RabbitMQ 2.1.RabbitMQ的简介 2.2.官网 2.3.MQ的其他产品 2.4.学习
消息队列-activemq入门实例.zip
08-26
消息队列-activemq入门实例 博客地址：https://blog.csdn.net/u010476739/article/details/100076646
消息队列RabbitMQ入门与5种模式详解
01-27
MQ全称为MessageQueue，消息队列是应用程序和应用程序之间的通信方法； RabbitMQ是开源的，实现了AMQP协议的，采用Erlang(面向并发编程语言)编写的，可复用的企业级消息系统； AMQP（高级消息队列协议）是一个异步...
MQ消息队列简单的发送和接受示例
09-18
适合新手入门学习MQ消息队列，并通过最基本的方式实现p2p模式的消息传递，让新手了解mq最底层的实现方式，方便理解过程。
activeMq消息队列demo
04-28
使用activeMq开发的一个简单demo，供入门者学习参考用。
利用消息中间件RabbitMQ创建队列以及扇出（Fanout）、订阅（Direct）、主题（Topic）交换机来完成消息的发送和监听接收（完整版）
c_xiao_dian_dian的博客
07-10 4083
5.1交换机的作用是什么？接收publisher发送的消息、将消息按照规则路由到与之绑定的队列、不能缓存消息，路由失败，消息丢失、FanoutExchange的会将消息路由到每个绑定的队列 5.2声明队列、交换机、绑定关系的Bean是什么？Queue、FanoutExchange、Binding
rabbitmq根据配置文件动态生成队列
03-23
支持配置文件动态生成队列，创建交换器，根据配置好的对应关系绑定队列和交换器
rabbit使用动态队列
恨_别离的博客
09-30 1388
rabbitmq
SpringBoot下RabbitMQ的实战应用：动态创建和动态监控队列、死信、备份交换机
土味儿
01-07 3864
每个用户对应一个普通队列；当用户过多时，相应的队列也会很多，并且队列是持久化的，会占用较多的系统资源；交换机收到消息，但无法投递时，转发至备份交换机，再广播至对应队列。缓存操作不是本文的重点，用模型类代替；缓存中未得到确认的消息，由定时器重新发送；用户登录后，动态切换要监控的队列；未发送成功的消息，由缓存保存，定时重发。如果用户退出后，也要更新监控列表；是接收不到的，消息会存储在相应对列中。发消息，消息应该不会被消费，存在。项目要足够稳健，消息不能丢失。交换机、队列、消息持久化。，这时再向上一个登录用户。
MQ消息队列（一）--RabbitMQ的简单入门，在SpringBoot环境
m0_45101736的博客
08-25 751
！！
MQ 本地队列 和远程队列的创建
hh337的博客
12-04 7865
首先先来个我安装好的MQ图形界面7.0版本 1.现在简单创建MQ队列 1创建队列管理器→新增→队列管理器→完成（侦听器端口不能重复，别的暂时全部默认 就可以） 2.创建队列→本地队列→完成（暂时全都默认） 添加消息查看
创建MQ队列管理器过程
sckehan1的专栏
07-05 1412
       01、创建mqm用户组      02、创建mqm用户，将用户mqm添加到mqm用户组下      03、创建队列管理器          crtmqm  -u DEADLETTERQUEUE03.OUTSOURCE.PBDRCB  MANAGER03.OUTSOURCE.PBDRCB       04、启动队列管理器          strmqm  MAN...
消息队列ActiveMQ-（入门篇简单易懂）
蓝星花
04-16 9148
最近遇到一个问题：我们如何同步solr的索引库，那这牵连到服务与服务之间的调用。方案一：添加商品的业务逻辑中，添加一个同步索引库的业务逻辑。缺点：业务逻辑耦合度高，业务拆分不明确方案二：业务逻辑在taotao-search中实现，调用服务在taotao-manager实现。业务逻辑分开。缺点：服务之间的耦合度变高。服务的启动有先后顺序。方案三：使用消息队列。MQ是一个消息中间件。ActiveMQM...
RabbitMQ消息队列创建
web18224617243的博客
04-22 872
操作环境 centos 7.9 RabbitMQ 3.8.23 Erlang 24.1.2 局域网（内网） 本文章是通过RabbitMQ图形管理界面，进行消息创建与队列绑定 首先在RabbitMQ安装时 图形操作(15672)端口是要打开，通过地址在浏览器进行访问，如是安装在云服务器上，可在安全组中将当前端口开放，也可以通过putty工具代理到本地进行访问。 接下来可以通过RabbitMQ自带的图形管理进行队列创建、把exchange和queue按照路由规则绑定起来 首先介绍一下图形中功能的意思 .

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值