RabbitMQ 使用教程

已于 2024-08-11 16:18:18 修改
阅读量722 收藏 11
点赞数 13
文章标签： rabbitmq 分布式 java 开发语言 spring boot 后端 spring
于 2024-08-11 16:16:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49171365/article/details/140954483
版权

目录

一、RabbitMQ 简介

二、相关概念

三、安装及配置

Windows下的安装

 Linux下的安装

管理页面访问及配置

说明

四、5 种消息模式 

简单模式

模式示意图

Spring AMQP实现

工作模式

模式示意图

Spring AMQP实现

发布/订阅模式

模式示意图

Spring AMQP实现

路由模式

模式示意图

Spring AMQP实现

通配符模式

特殊匹配符号

Spring AMQP实现

五、总结：

一、RabbitMQ 简介

        RabbitMQ是最受欢迎的开源消息中间件之一，在全球范围内被广泛应用。RabbitMQ是轻量级且易于部署的，能支持多种消息协议。RabbitMQ可以部署在分布式系统中，以满足大规模、高可用的要求。

参考资料

RabbitMQ官方文档：RabbitMQ Tutorials | RabbitMQ

二、相关概念

RabbitMQ中的相关概念，这里以5种消息模式中的通配符模式为例。

标志

中文名

英文名

描述

P

生产者

Producer

消息的发送者，可以将消息发送到交换机

C

消费者

Consumer

消息的接收者，从队列中获取消息并进行消费

X

交换机

Exchange

接收生产者发送的消息，并根据路由键发送给指定队列

Q

队列

Queue

存储从交换机发来的消息

type

交换机类型

type

不同类型的交换机转发消息方式不同

fanout

发布/订阅模式

fanout

广播消息给所有绑定交换机的队列

direct

路由模式

direct

根据路由键发送消息

topic

通配符模式

topic

根据路由键的匹配规则发送消息

三、安装及配置

接下来我们介绍下RabbitMQ的安装和配置，提供Windows和Linux两种安装方式。

Windows下的安装

 Release OTP 25.0.1 · erlang/otp (github.com)

  • 安装Erlang，直接双击安装包安装即可；

  • 安装完成后，进入RabbitMQ安装目录下的sbin目录；

  • 在地址栏输入cmd并回车启动命令行，然后输入以下命令启动管理功能。
rabbitmq-plugins enable rabbitmq_management

 这样启动起来就可以在网页端进行访问了

 Linux下的安装

  • 下载rabbitmq3.9-management的docker镜像：
docker pull rabbitmq:3.9-management
  • 使用如下命令启动RabbitMQ服务：
docker run -p 5672:5672 -p 15672:15672 --name rabbitmq \
-d rabbitmq:3.9-management
  • 开启防火墙便于外网访问。
firewall-cmd --zone=public --add-port=15672/tcp --permanent
firewall-cmd --zone=public --add-port=5672/tcp --permanent
firewall-cmd --reload

管理页面访问及配置

  • 访问RabbitMQ管理页面地址，查看是否安装成功（Linux下使用服务器IP访问即可），默认账号密码为guest:guest，访问地址：http://localhost:15672/

  • 创建一个我们需要使用的帐号mall:mall，并设置其角色为管理员；

 账号密码都是设置成 mall 

  • 创建一个新的虚拟host为，名称为 /mall；

  • 点击mall用户进入用户配置页面；

  • 给mall用户配置该虚拟host的权限，至此，RabbitMQ的配置完成。

此时，mall 用户可以访问 /mall 虚拟路径了 

说明

设置 virtual-host 是为了在 RabbitMQ 中创建一个逻辑上的分区或者说是命名空间。在实际应用中，通常会为不同的应用程序或者服务分配不同的 virtual-host，以达到隔离和管理的目的。

virtual-host 的作用有以下几点：

  1. 隔离性: 不同的 virtual-host 之间的消息队列和交换器是相互隔离的。这意味着在同一个 RabbitMQ 实例上运行的不同应用程序可以彼此独立地使用消息队列，互不干扰。

  2. 权限控制: RabbitMQ 允许为每个 virtual-host 配置独立的权限和访问控制。这样可以确保不同应用程序之间的消息通信是安全可控的。

  3. 管理和维护: 使用 virtual-host 可以更方便地管理和维护 RabbitMQ 的实例。通过将相关的队列、交换器和绑定组织在一个 virtual-host 下，可以提高管理效率。

在你的配置中，virtual-host: /mall 表示创建了一个名为 /mall 的虚拟主机。这个命名约定通常会反映出你的应用程序或服务的名称或者标识。选择 /mall 这样的名字可能是因为你的应用程序或者服务与商城相关。

因此，通过设置 virtual-host，可以确保你的应用程序与其他应用程序之间的消息通信是隔离的，并且能够更好地管理和控制访问权限。

四、5 种消息模式 

        5种消息模式是构建基于RabbitMQ的消息应用的基础，这里我们使用Spring AMQP的形式来实现它们。

简单模式

简单模式是最简单的消息模式，它包含一个生产者、一个消费者和一个队列。生产者向队列里发送消息，消费者从队列中获取消息并消费。

模式示意图

Spring AMQP实现

  • 首先需要在pom.xml中添加Spring AMQP的相关依赖；
<!--Spring AMQP依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
  • 然后修改application.yml，添加RabbitMQ的相关配置；
spring:
  rabbitmq:
    host: localhost
    port: 5672
    virtual-host: /mall
    username: mall
    password: mall
    publisher-confirms: true #消息发送到交换器确认
    publisher-returns: true #消息发送到队列确认
  • 添加简单模式相关Java配置，创建一个名为simple.hello的队列、一个生产者和一个消费者；
@Configuration
public class SimpleRabbitConfig {

    @Bean
    public Queue hello() {
        return new Queue("simple.hello");
    }

    @Bean
    public SimpleSender simpleSender(){
        return new SimpleSender();
    }

    @Bean
    public SimpleReceiver simpleReceiver(){
        return new SimpleReceiver();
    }

}
  • 生产者通过send方法向队列simple.hello中发送消息；
public class SimpleSender {

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

    @Autowired
    private RabbitTemplate template;

    private static final String queueName="simple.hello";

    public void send() {
        String message = "Hello World!";
        this.template.convertAndSend(queueName, message);
        LOGGER.info(" [x] Sent '{}'", message);
    }

}
  • 消费者从队列simple.hello中获取消息；
@RabbitListener(queues = "simple.hello")
public class SimpleReceiver {

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

    @RabbitHandler
    public void receive(String in) {
        LOGGER.info(" [x] Received '{}'", in);
    }

}
  • 在controller中添加测试接口，调用该接口开始发送消息；
@Controller
@Api(tags = "RabbitController")
@Tag(name = "RabbitController", description = "RabbitMQ功能测试")
@RequestMapping("/rabbit")
public class RabbitController {

    @Autowired
    private SimpleSender simpleSender;

    @ApiOperation("简单模式")
    @RequestMapping(value = "/simple", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult simpleTest() {
        for(int i=0;i<10;i++){
            simpleSender.send();
            ThreadUtil.sleep(1000);
        }
        return CommonResult.success(null);
    }
}

  • 运行后结果如下，可以发现生产者往队列中发送消息，消费者从队列中获取消息并消费。

安装  Grep Console 既可以对控制台日志信息进行过滤显示：

 

工作模式

        工作模式是指向多个互相竞争的消费者发送消息的模式，它包含一个生产者、两个消费者和一个队列。两个消费者同时绑定到一个队列上去，当消费者获取消息处理耗时任务时，空闲的消费者从队列中获取并消费消息。

模式示意图

Spring AMQP实现

  • 添加工作模式相关Java配置，创建一个名为work.hello的队列、一个生产者和两个消费者；
@Configuration
public class WorkRabbitConfig {

    @Bean
    public Queue workQueue() {
        return new Queue("work.hello");
    }

    @Bean
    public WorkReceiver workReceiver1() {
        return new WorkReceiver(1);
    }

    @Bean
    public WorkReceiver workReceiver2() {
        return new WorkReceiver(2);
    }

    @Bean
    public WorkSender workSender() {
        return new WorkSender();
    }

}
  • 生产者通过send方法向队列work.hello中发送消息，消息中包含一定数量的.号；
public class WorkSender {

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

    @Autowired
    private RabbitTemplate template;

    private static final String queueName = "work.hello";

    public void send(int index) {
        StringBuilder builder = new StringBuilder("Hello");
        int limitIndex = index % 3+1;
        for (int i = 0; i < limitIndex; i++) {
            builder.append('.');
        }
        builder.append(index+1);
        String message = builder.toString();
        template.convertAndSend(queueName, message);
        LOGGER.info(" [x] Sent '{}'", message);
    }

}
  • 两个消费者从队列work.hello中获取消息，名称分别为instance 1和instance 2，消息中包含.号越多，耗时越长；
@RabbitListener(queues = "work.hello")
public class WorkReceiver {

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

    private final int instance;

    public WorkReceiver(int i) {
        this.instance = i;
    }

    @RabbitHandler
    public void receive(String in) {
        StopWatch watch = new StopWatch();
        watch.start();
        LOGGER.info("instance {} [x] Received '{}'", this.instance, in);
        doWork(in);
        watch.stop();
        LOGGER.info("instance {} [x] Done in {}s", this.instance, watch.getTotalTimeSeconds());
    }

    private void doWork(String in) {
        for (char ch : in.toCharArray()) {
            if (ch == '.') {
                ThreadUtil.sleep(1000);
            }
        }
    }

}
  • 在controller中添加测试接口，调用该接口开始发送消息；
@Controller
@Api(tags = "RabbitController")
@Tag(name = "RabbitController", description = "RabbitMQ功能测试")
@RequestMapping("/rabbit")
public class RabbitController {
    
    @Autowired
    private WorkSender workSender;

    @ApiOperation("工作模式")
    @RequestMapping(value = "/work", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult workTest() {
        for(int i=0;i<10;i++){
            workSender.send(i);
            ThreadUtil.sleep(1000);
        }
        return CommonResult.success(null);
    }
}
  • 运行后结果如下，可以发现生产者往队列中发送包含不同数量.号的消息，instance 1和instance 2消费者互相竞争，分别消费了一部分消息。

发布/订阅模式

发布/订阅模式是指同时向多个消费者发送消息的模式（类似广播的形式），它包含一个生产者、两个消费者、两个队列和一个交换机。两个消费者同时绑定到不同的队列上去，两个队列绑定到交换机上去，生产者通过发送消息到交换机，所有消费者接收并消费消息。

模式示意图

Spring AMQP实现

  • 添加发布/订阅模式相关Java配置，创建一个名为exchange.fanout的交换机、一个生产者、两个消费者和两个匿名队列，将两个匿名队列都绑定到交换机；
@Configuration
public class FanoutRabbitConfig {

    @Bean
    public FanoutExchange fanout() {
        return new FanoutExchange("exchange.fanout");
    }

    @Bean
    public Queue fanoutQueue1() {
        return new AnonymousQueue();
    }

    @Bean
    public Queue fanoutQueue2() {
        return new AnonymousQueue();
    }

    @Bean
    public Binding fanoutBinding1(FanoutExchange fanout, Queue fanoutQueue1) {
        return BindingBuilder.bind(fanoutQueue1).to(fanout);
    }

    @Bean
    public Binding fanoutBinding2(FanoutExchange fanout, Queue fanoutQueue2) {
        return BindingBuilder.bind(fanoutQueue2).to(fanout);
    }

    @Bean
    public FanoutReceiver fanoutReceiver() {
        return new FanoutReceiver();
    }

    @Bean
    public FanoutSender fanoutSender() {
        return new FanoutSender();
    }

}
  • 生产者通过send方法向交换机exchange.fanout中发送消息，消息中包含一定数量的.号；
public class FanoutSender {
    private static final Logger LOGGER = LoggerFactory.getLogger(FanoutSender.class);
    @Autowired
    private RabbitTemplate template;

    private static final String exchangeName = "exchange.fanout";

    public void send(int index) {
        StringBuilder builder = new StringBuilder("Hello");
        int limitIndex = index % 3 + 1;
        for (int i = 0; i < limitIndex; i++) {
            builder.append('.');
        }
        builder.append(index + 1);
        String message = builder.toString();
        template.convertAndSend(exchangeName, "", message);
        LOGGER.info(" [x] Sent '{}'", message);
    }

}
  • 消费者从绑定的匿名队列中获取消息，消息中包含.号越多，耗时越长，由于该消费者可以从两个队列中获取并消费消息，可以看做两个消费者，名称分别为instance 1和instance 2；
public class FanoutReceiver {

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

    @RabbitListener(queues = "#{fanoutQueue1.name}")
    public void receive1(String in) {
        receive(in, 1);
    }

    @RabbitListener(queues = "#{fanoutQueue2.name}")
    public void receive2(String in) {
        receive(in, 2);
    }

    private void receive(String in, int receiver) {
        StopWatch watch = new StopWatch();
        watch.start();
        LOGGER.info("instance {} [x] Received '{}'", receiver, in);
        doWork(in);
        watch.stop();
        LOGGER.info("instance {} [x] Done in {}s", receiver, watch.getTotalTimeSeconds());
    }

    private void doWork(String in) {
        for (char ch : in.toCharArray()) {
            if (ch == '.') {
                ThreadUtil.sleep(1000);
            }
        }
    }
}
  • 在controller中添加测试接口，调用该接口开始发送消息；
@Controller
@Api(tags = "RabbitController")
@Tag(name = "RabbitController", description = "RabbitMQ功能测试")
@RequestMapping("/rabbit")
public class RabbitController {
    
    @Autowired
    private FanoutSender fanoutSender;

    @ApiOperation("发布/订阅模式")
    @RequestMapping(value = "/fanout", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult fanoutTest() {
        for(int i=0;i<10;i++){
            fanoutSender.send(i);
            ThreadUtil.sleep(1000);
        }
        return CommonResult.success(null);
    }
}

路由模式

路由模式是可以根据路由键选择性给多个消费者发送消息的模式，它包含一个生产者、两个消费者、两个队列和一个交换机。两个消费者同时绑定到不同的队列上去，两个队列通过路由键绑定到交换机上去，生产者发送消息到交换机，交换机通过路由键转发到不同队列，队列绑定的消费者接收并消费消息。

模式示意图

Spring AMQP实现

  • 添加路由模式相关Java配置，创建一个名为exchange.direct的交换机、一个生产者、两个消费者和两个匿名队列，队列通过路由键都绑定到交换机，队列1的路由键为orange，队列2的路由键为green和black；
/**
 * @description 路由模式消息队列配置
 */
@Configuration
public class DirectRabbitConfig {

    @Bean
    public DirectExchange direct() {
        return new DirectExchange("exchange.direct");
    }

    @Bean
    public Queue directQueue1() {
        return new AnonymousQueue();
    }

    @Bean
    public Queue directQueue2() {
        return new AnonymousQueue();
    }

    @Bean
    public Binding directBinding1a(DirectExchange direct, Queue directQueue1) {
        return BindingBuilder.bind(directQueue1).to(direct).with("orange");
    }

    @Bean
    public Binding directBinding2a(DirectExchange direct, Queue directQueue2) {
        return BindingBuilder.bind(directQueue2).to(direct).with("green");
    }

    @Bean
    public Binding directBinding2b(DirectExchange direct, Queue directQueue2) {
        return BindingBuilder.bind(directQueue2).to(direct).with("black");
    }

    @Bean
    public DirectReceiver receiver() {
        return new DirectReceiver();
    }


    @Bean
    public DirectSender directSender() {
        return new DirectSender();
    }

}
  • 生产者通过send方法向交换机exchange.direct中发送消息，发送时使用不同的路由键，根据路由键会被转发到不同的队列；
/**
 * @description 路由模式生产者
 */
public class DirectSender {

    @Autowired
    private RabbitTemplate template;

    private static final String exchangeName = "exchange.direct";

    private final String[] keys = {"orange", "black", "green"};

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

    public void send(int index) {
        StringBuilder builder = new StringBuilder("Hello to ");
        int limitIndex = index % 3;
        String key = keys[limitIndex];
        builder.append(key).append(' ');
        builder.append(index+1);
        for (int i = 0; i <= limitIndex; i++) {
            builder.append('.');
        }
        String message = builder.toString();
        template.convertAndSend(exchangeName, key, message);
        LOGGER.info(" [x] Sent '{}'", message);
    }

}
  • 消费者从自己绑定的匿名队列中获取消息，由于该消费者可以从两个队列中获取并消费消息，可以看做两个消费者，名称分别为instance 1和instance 2；
/**
 * @description 路由模式消费者
 */
public class DirectReceiver {
    private static final Logger LOGGER = LoggerFactory.getLogger(DirectReceiver.class);

    @RabbitListener(queues = "#{directQueue1.name}")
    public void receive1(String in){
        receive(in, 1);
    }

    @RabbitListener(queues = "#{directQueue2.name}")
    public void receive2(String in){
        receive(in, 2);
    }

    private void receive(String in, int receiver){
        StopWatch watch = new StopWatch();
        watch.start();
        LOGGER.info("instance {} [x] Received '{}'", receiver, in);
        doWork(in);
        watch.stop();
        LOGGER.info("instance {} [x] Done in {}s", receiver, watch.getTotalTimeSeconds());
    }

    private void doWork(String in){
        for (char ch : in.toCharArray()) {
            if (ch == '.') {
                ThreadUtil.sleep(1000);
            }
        }
    }

}
  • 在controller中添加测试接口，调用该接口开始发送消息；
/**
 * @description RabbitMQ功能测试Controller
 */
@Controller
@Api(tags = "RabbitController")
@Tag(name = "RabbitController", description = "RabbitMQ功能测试")
@RequestMapping("/rabbit")
public class RabbitController {

    @Autowired
    private DirectSender directSender;

    @ApiOperation("路由模式")
    @RequestMapping(value = "/direct", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult directTest() {
        for(int i=0;i<10;i++){
            directSender.send(i);
            ThreadUtil.sleep(1000);
        }
        return CommonResult.success(null);
    }
}
  • 运行后结果，可以发现生产者往队列中发送包含不同路由键的消息，instance 1获取到了orange和black消息，instance 2获取到了green和black消息。

通配符模式

通配符模式是可以根据路由键匹配规则选择性给多个消费者发送消息的模式，它包含一个生产者、两个消费者、两个队列和一个交换机。两个消费者同时绑定到不同的队列上去，两个队列通过路由键匹配规则绑定到交换机上去，生产者发送消息到交换机，交换机通过路由键匹配规则转发到不同队列，队列绑定的消费者接收并消费消息。

特殊匹配符号

  • *：只能匹配一个单词；
  • #：可以匹配零个或多个单词。

Spring AMQP实现

  • 添加通配符模式相关Java配置，创建一个名为exchange.topic的交换机、一个生产者、两个消费者和两个匿名队列，匹配*.orange.*发送到队列1，匹配和*.*.rabbit和lazy.#发送到队列2；
/**
 * @description 通配符模式消息队列配置
 */
@Configuration
public class TopicRabbitConfig {

    @Bean
    public TopicExchange topic() {
        return new TopicExchange("exchange.topic");
    }

    @Bean
    public Queue topicQueue1() {
        return new AnonymousQueue();
    }

    @Bean
    public Queue topicQueue2() {
        return new AnonymousQueue();
    }

    @Bean
    public Binding topicBinding1a(TopicExchange topic, Queue topicQueue1) {
        return BindingBuilder.bind(topicQueue1).to(topic).with("*.orange.*");
    }

    @Bean
    public Binding topicBinding2a(TopicExchange topic, Queue topicQueue2) {
        return BindingBuilder.bind(topicQueue2).to(topic).with("*.*.rabbit");
    }

    @Bean
    public Binding topicBinding2b(TopicExchange topic, Queue topicQueue2) {
        return BindingBuilder.bind(topicQueue2).to(topic).with("lazy.#");
    }

    @Bean
    public TopicReceiver topicReceiver() {
        return new TopicReceiver();
    }

    @Bean
    public TopicSender topicSender() {
        return new TopicSender();
    }

}
  • 生产者通过send方法向交换机exchange.topic中发送消息，消息中包含不同的路由键；
/**
 * @description 通配符模式生产者
 */
public class TopicSender {

    @Autowired
    private RabbitTemplate template;

    private static final String exchangeName = "exchange.topic";

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


    private final String[] keys = {"quick.orange.rabbit", "lazy.orange.elephant", "quick.orange.fox",
            "lazy.brown.fox", "lazy.pink.rabbit", "quick.brown.fox"};

    public void send(int index) {
        StringBuilder builder = new StringBuilder("Hello to ");
        int limitIndex = index%keys.length;
        String key = keys[limitIndex];
        builder.append(key).append(' ');
        builder.append(index+1);
        for (int i = 0; i <= limitIndex; i++) {
            builder.append('.');
        }
        String message = builder.toString();
        template.convertAndSend(exchangeName, key, message);
        LOGGER.info(" [x] Sent '{}'",message);
        System.out.println(" [x] Sent '" + message + "'");
    }

}
  • 消费者从自己绑定的匿名队列中获取消息，由于该消费者可以从两个队列中获取并消费消息，可以看做两个消费者，名称分别为instance 1和instance 2；
/**
 * @description 通配符模式消费者
 */
public class TopicReceiver {

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

    @RabbitListener(queues = "#{topicQueue1.name}")
    public void receive1(String in){
        receive(in, 1);
    }

    @RabbitListener(queues = "#{topicQueue2.name}")
    public void receive2(String in){
        receive(in, 2);
    }

    public void receive(String in, int receiver){
        StopWatch watch = new StopWatch();
        watch.start();
        LOGGER.info("instance {} [x] Received '{}'", receiver, in);
        doWork(in);
        watch.stop();
        LOGGER.info("instance {} [x] Done in {}s", receiver, watch.getTotalTimeSeconds());
    }

    private void doWork(String in){
        for (char ch : in.toCharArray()) {
            if (ch == '.') {
                ThreadUtil.sleep(1000);
            }
        }
    }

}
  • 在controller中添加测试接口，调用该接口开始发送消息；
/**
 * @description RabbitMQ功能测试Controller
 */
@Controller
@Api(tags = "RabbitController")
@Tag(name = "RabbitController", description = "RabbitMQ功能测试")
@RequestMapping("/rabbit")
public class RabbitController {

    @Autowired
    private TopicSender topicSender;

    @ApiOperation("通配符模式")
    @RequestMapping(value = "/topic", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult topicTest() {
        for(int i=0;i<10;i++){
            topicSender.send(i);
            ThreadUtil.sleep(1000);
        }
        return CommonResult.success(null);
    }
}
  • 运行后结果，可以发现生产者往队列中发送包含不同路由键的消息，instance 1和instance 2分别获取到了匹配的消息。

五、总结：

1.生产者发消息给 Broker
2. Broker 存储消息
3.消费者从 Broker 拉取消费  4.消费者通知 Broker 消费成功
5.生产者、Broker、消费者与 NameSrv 的交互

        学习 RabbitMQ 需要先有一个整体的认识，然后再深入学习，钻研细节，最后再抓住核心脉络总结整理消化在自己脑海中形成体系。好比阅读一些经典书籍，先粗读 (建立大概的认识)、后细读 (深入去学习思考) 、最后总结整理(消化变成自己的东西) 

进阶：MQ源码apache/rocketmq: Apache RocketMQ is a cloud native messaging and streaming platform, making it simple to build event-driven applications. (github.com)

白白白鲤鱼
关注
  • 13
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMQ教程(安装与使用详解,Spring集成)
鸟哥哥的专栏
12-26 50万+
RabbitMQ教程，面试题。消息队列(MQ)，本质是个队列，队列中存放的内容是message。MQ用于不同进程Process/线程Thread之间通信。本文介绍RabbitMQ的使用。RabbitMQ实战教程。
消息模式1
Zhangrunhong的博客
12-06 431
文章目录1、消息如何保证100%的投递？2、幂等性概念3、Confirm确认消息4、Return返回消息5、自定义消费者 1、消息如何保证100%的投递？ 消息如何保障100%的投递成功？ 什么是生产端的可靠性投递？ 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点（Broker）确认应答 完善的消息进行补偿机制 BAT/TMD互联网大厂的解决方案： 消息落库，对消息状态进...
【消息队列】六万字长文详细带你RabbitMQ从入门到精通
最新发布
Hanson的博客
06-24 510
六万字长文深入了解RabbitMQ，从基础到精通
花了3天总结的RabbitMQ实用技巧，有点东西
weixin_50666791的博客
10-14 125
以前看过的关于RabbitMQ核心消息模式的文章都是基于Java API的，最近看了下官方文档，发现这些核心消息模式都可以通过Spring AMQP来实现。于是总结了下RabbitMQ的实用技巧，包括RabbitMQ在Windows和Linux下的安装、5种核心消息模式的Spring AMQP实现，相信对于想要学习和回顾RabbitMQ的朋友都会有所帮助。 简介 RabbitMQ是最受欢迎的开源消息中间件之一，在全球范围内被广泛应用。RabbitMQ是轻量级且易于部署的，能支持多种消息协议。Rabb.
RabbitMQ 使用（一）
weixin_30834019的博客
08-17 72
RabbitMQ中的使用这篇文章将会介绍关于RabbbitMQ的使用，并且使用的是kombo（客户端的Python实现）来实现；安装如果使用的是mac安装的话，可以先安装到指定的位置，接着配置命令访问路径：cd ~vi .bash_profile，输入下面两行RABBIT_HOME=/usr/local/Cellar/rabbitmq/3.6.9_1 PATH=$PATH:$RABBIT_HOM...
RabbitMQ的使用
qq_47387991的博客
03-03 1310
1.初识MQ 1.1.同步和异步通讯 微服务间通讯有同步和异步两种方式： 同步通讯：就像打电话，需要实时响应。 异步通讯：就像发邮件，不需要马上回复。
rabbitmq安装教程
07-11
RabbitMQ是一款开源的消息中间件，它遵循AMQP（Advanced...遵循上述安装教程，你就能在自己的环境中部署并使用RabbitMQ了。记得在实际应用中，要根据业务需求来设计和调整消息队列的结构，确保系统的稳定性和可扩展性。
RabbitMQ系列教程1
08-03
通过本系列教程，我们将探讨如何安装和配置RabbitMQ，以及如何使用AMQP协议创建和管理消息。此外，我们还将学习如何使用RabbitMQ提供的管理界面监控和管理消息队列。在后续教程中，我们将进一步探讨RabbitMQ的高级...
rabbitmq教程
08-05
### rabbitmq教程 #### 什么是MQ (Message Queue) 消息队列是一种用于进程间通信的机制，它遵循先进先出(FIFO)的原则，其中传输的是消息数据。消息队列的引入主要是为了解决以下问题： 1. **降低系统耦合度**：...
RabbitMQ Linux安装教程
06-09
- 安装RabbitMQ通常使用预编译的二进制包，可以使用`wget`或直接上传到服务器。 - 解压缩RabbitMQ的二进制包。 - 移动解压后的文件到一个适当的目录，如`/usr/local/rabbitmq`。 - 设置环境变量`RABBITMQ_HOME`...
rabbitMq安装教程以及软件
09-19
在本教程中，我们将详细介绍RabbitMQ的安装过程，并提供最新的软件包。 首先，我们需要下载RabbitMQ的安装包。在提供的压缩文件中，有两个重要的文件：`otp_win64_20.2.exe` 和 `rabbitmq-server-3.7.4 (1).exe`。`...
Rabbitmq安装 教程
05-26
本教程使用的 Erlang 版本为 18.3。 1. **下载 Erlang RPM 包**: - 使用 wget 命令下载所需的 RPM 包。 ```shell wget http://example.com/erlang-18.3-1.el7.centos.x86_64.rpm ``` - 其中 URL 地址需要...
RabbitMQ 入门教程（JAVA）
08-01
通过本教程的学习，我们了解了 RabbitMQ 的基本概念及其在 Java 应用程序中的简单使用方法。RabbitMQ 作为一个高效的消息传递系统，不仅可以帮助开发者构建分布式应用程序，还能提供灵活的消息路由机制。接下来，你...
linux安装RabbitMQ详细教程
09-15
### Linux安装RabbitMQ详细教程 #### 一、RabbitMQ概述 RabbitMQ是一款基于Erlang语言开发的开源消息中间件系统，遵循AMQP（Advanced Message Queuing Protocol）标准，广泛应用于分布式系统中。它以其良好的性能...
.Net RabbitMQ教程
04-21
总的来说，这份.NET RabbitMQ教程提供了丰富的信息，涵盖了从基础的连接设置到高级特性的实现，包括异步操作、并发处理和故障恢复策略，为.NET开发者提供了全面的指导。通过学习和实践，开发者能够熟练地将RabbitMQ...
CentOS 7 下安装RabbitMQ教程配套的离线文件
03-24
在本教程中，我们将深入探讨如何在 CentOS 7 操作系统上安装 RabbitMQ，这是一个流行的开源消息代理，基于AMQP（Advanced Message Queuing Protocol）协议。RabbitMQ 使用 Erlang 语言开发，它提供了一个可靠的平台...
rabbitMQ
missA_fei的博客
03-25 453
文章目录 RabbitMQ实战教程 1.什么是MQ 2.RabbitMQ 2.1.RabbitMQ的简介 2.2.官网 2.3.MQ的其他产品 2.4.学习5种队列 2.5....
RabbitMQ使用教程
热门推荐
Mr. Wu's blog
10-07 1万+
RabbitMQ使用教程，一文解决入门难题
RabbitMQ使用 详解
lxlsygxs2017的博客
04-06 1472
RabbitMQ单机安装 RabbitMQ消息模型：基本消息队列、工作消息队列、发布订阅（Fanout、Direct、Topic） RabbitMQ集群部署 RabbitMQ生产者消息确认 RabbitMQ消费者消息确认 RabbitMQ消息失败重试机制 RabbitMQ死信交换机 RabbitMQ惰性队列 RabbitMQ消息延迟发送 RabbitMQ镜像集群 RabbitMQ仲裁队列 RabbitMQ集群扩容
rabbitmq使用教程
08-29
您可以按照以下步骤学习 RabbitMQ 的使用教程： 1. 首先，您需要安装 RabbitMQ。可以按照引用中的课程提供的教程来进行环境搭建。如果您使用的是命令行方式管理 RabbitMQ，可以按照引用中的命令启用 RabbitMQ 的管理插件。 2. 学习 RabbitMQ 的基本概念和术语。了解消息队列、生产者、消费者、交换机和队列等概念的含义，以及它们在 RabbitMQ 中的作用和关系。 3. 学习如何发送和接收消息。了解如何使用 RabbitMQ 的 API 或者其他支持库，通过生产者发送消息到交换机，然后消费者从队列中接收消息。 4. 学习消息的确认机制。了解如何确保消息的可靠性传输，以及如何处理发送失败或者消费失败的情况。 5. 如果您使用的是 Spring Boot，可以学习如何集成 RabbitMQ。了解如何配置 RabbitMQ 连接工厂，创建消息监听器容器，以及如何在应用程序中发送和接收消息。 6. 探索更高级的功能。学习如何使用 RabbitMQ 的主题交换机、路由交换机等高级功能来实现更灵活的消息路由。 您可以根据您的实际需求选择适合您的学习资源。引用中提供了附带资料的视频教程，可以帮助您更好地理解和学习 RabbitMQ。希望这些信息对您有所帮助！<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [RabbitMQ使用教程](https://blog.csdn.net/weixin_45486926/article/details/127170831)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [硬核，RabbitMQ入门使用教程，详细到哭](https://blog.csdn.net/Javanewspaper/article/details/122251486)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值