RabbitMQ 详解

已于 2024-07-23 08:48:43 修改
阅读量1k 收藏 18
点赞数 10
文章标签： rabbitmq 分布式 中间件
于 2024-07-13 17:31:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59308271/article/details/140403272
版权

1、RabbitMQ 介绍

MQ全称为Message Queue，即消息队列. 它也是一个队列,遵循FIFO原则 。RabbitMQ则是一个开源的消息中间件，是一个具体的软件产品。RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue Protocol高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。

1. 消息中间件

  1. 中间件是一种独立的系统软件服务程序，位于客户机服务器的操作系统之上，管理着计算资源和网络通信。 分布式应用系统可以借助中间件这种软件在不同的技术之间共享资源。

  2. 消息中间件是支持在分布式系统之间发送和接收消息的软件。

2. AMQP 协议

AMQP 不是一个具体的消息中间件产品，而是一个协议规范。他是一个开放的消息产地协议，是一种应用层的标准协议，为面向消息的中间件设计。AMQP 提供了一种统一的消息服务，使得不同程序之间可以通过消息队列进行通信。 SpringBoot 框架默认就提供了对 AMQP 协议的支持。

  • AMQP协议概念

概念描述
Broker接收和分发消息的应用，RabbitMQ Server就是Message Broker。
Virtual Host为了在一个单独的代理上实现多个隔离的环境（用户、用户组、交换机、队列 等），AMQP 提供了一个虚拟主机（virtual hosts）的概念，当多个不同的用户使用同一个RabbitMQ时，可以划分出多个vhost，每个用户在自己的vhost创建exchange、queue等。
Connection生产者、消费者和Broker之间的TCP连接。
Channel是在Connection内部建立的逻辑连接，它作为轻量级的Connection，极大减少了操作系统建立TCP连接的开销。
Exchange交换机，用于接收消息，根据分发规则，匹配Routing Key，分发消息到队列中去。
Queue队列，消息最终被送到这里等待消费者取走。
Binding用于描述消息队列与交换机之间的关系。一个绑定就是基于路由键将交换机和消息队列连接起来的路由规则。因此可以将交换器看成一个由绑定构成的路由表
Routing Key路由规则，可用来确定如何路由一个特定消息。
Message消息
Publisher消息发布者
Consumer消费者

3. 应用场景

  1. 应用解耦

用户下单后，订单系统需要通知库存系统，传统的做法就是订单系统调用库存系统的接口。当库存系统出现故障时，订单就会失败。库存服务和订单服务高度耦合。

引入消息队列，用户下单后，订单系统完成持久化处理，将消息写入消息队列，返回用户订单下单成功。库存服务从消息队列中消费消息，消息队列做持久化处理，就算库存服务出现故障，也能保证消息的不丢失。

  1. 异步消息通信

用户注册后，需要发注册邮件和注册短信，客户端没有必要等着其发送完成才显示注册成功，应该是写入数据库后就返回。引入消息队列后，把发送邮件，短信不是必须的业务逻辑异步处理。

  1. 流量削峰

秒杀活动，一般会因为流量过大，导致应用挂掉，为了解决这个问题，一般在应用前端加入消息队列。用户的请求，服务器收到之后，首先写入消息队列，加入消息队列长度超过最大值，则直接抛弃用户请求或跳转到错误页面。等系统压力小了在执行消息队列中的消息。

2、RabbitMQ 工作原理

1. RabbitMQ 消息模型

  • 基本消息队列

    • P是生产者。

    • C是消费者。

    • 中间的Queue区域是一个队列，表示消息缓冲区。

  • 工作消息队列

    在使用消息系统时，一般情况下生产者往队列里插入数据的速度是比较快的，但是消费者消费数据往往涉及到一些业务逻辑处理导致速度跟不上生产者生产数据的速度。因此，如果一个队列只有一个消费者的话，很容易导致大量的消息堆积在队列里，这时，就可以使用工作队列，这样一个队列可以有多个消费者同时消费数据。

    当队列有多个消费者时，消息会被哪个消费者消费呢？这里主要有两种模式：

    1. 轮询分发：一个消费者消费一条；

    2. 公平分发：根据消费者的消费能力进行公平分发，处理快的处理的多，处理慢的处理的少；

2. RabbitMQ 交换机

  • Direct exchange（直连交换机）

    • 直连型交换机（direct exchange）是根据消息携带的路由键（routing key）将消息投递给对应队列的，步骤如下：

      • 将一个队列绑定到某个交换机上，同时赋予该绑定一个路由键（routing key）

      • 当一个携带着路由值为R的消息被发送给直连交换机时，交换机会把它路由给绑定值同样为R的队列。

      • 交换机和队列之间产生关联需要使用binding，可理解为交换机只向与其绑定的队列中发送消息，这里的绑定关系需要使用Routing Key；相对比fanout交换机，direct交换机在其基础上，多加了一层秘钥（Routing Key）。

  • Fanout exchange（扇型交换机）

    • 扇型交换机（funout exchange）将消息路由给绑定到它身上的所有队列。不同于直连交换机，路由键在此类型上不启任务作用。如果N个队列绑定到某个扇型交换机上，当有消息发送给此扇型交换机时，交换机会将消息的发送给这所有的N个队列

    • 在RabbitMQ中，一个队列上的一条消息只能被一个消费者消费，要实现一条消息被多个消费者同时消费，需要借助多个队列（也就是需要将这一条消息发送到多个队列）。

      fanout交换非常简单，它仅将收到的所有消息广播到所有队列。

      fanout交换机不设置路由键，我们只需要将队列绑定到交换机上，生产者发送到fanout交换机的消息都会被转发到与该交换机绑定的所有队列上，很像子网广播，每台子网内的主机都能获得了一份消息。

  • Topic exchange（主题交换机）

    • 主题交换机（topic exchanges）中，队列通过路由键绑定到交换机上，然后，交换机根据消息里的路由值，将消息路由给一个或多个绑定队列。

    • topic交换机是在direct交换机的基础上，支持了对routing key的通配符匹配（*号和#号），以满足更加复杂的消息分发场景。

      *：精确匹配一个词（一个字母、一个单词）

      #：匹配零个或多个词（多个字母、多个单词，都以"点"分割）

      注：

      • 如果队列绑定的路由键是#，那么这个队列可以接收所有数据，就类似于fanout交换机了

      • 如果队列绑定的路由键键当中没有#和*，那么是direct交换机了

3、RabbitMQ 使用

  • 配置Maven依赖

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
​
<!-- 整合RabbitMQ -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

  • 编写 application.ym 配置文件

    server:
  port: 8080
​
spring:
 #配置rabbitMq 服务器
  rabbitmq:
  # IP 地址
    host: 192.168.136.128
    # 端口号
    port: 5672
    # 虚拟主机
    virtual-host: /
    # 用户名
    username: et
    # 密码
    password: et

1. 扇型交换机（Fanout Exchang）

fanout交换机不设置路由键，我们只需要将队列绑定到交换机上，生产者发送到fanout交换机的消息都会被转发到与该交换机绑定的所有队列上，很像子网广播，每台子网内的主机都能获得了一份消息。

  • 配置交换机和队列

    import jakarta.servlet.http.PushBuilder;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
​
@Configuration
public class FanoutConfig {
​
    public static final String EXCHANGE = "etoak";
​
    public static final String QUEUE_ET2402 = "ET2402";
​
    public static final String QUEUE_ET2403 = "ET2403";
​
​
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange(EXCHANGE);
    }
​
    @Bean
    public Queue et2402(){
        //默认持久化
        return new Queue(QUEUE_ET2402);
    }
​
    @Bean
    public Queue et2403(){
        return new Queue(QUEUE_ET2403);
    }
​
    @Bean
    public Binding et2402Binding(){
        return BindingBuilder.bind(et2402()).to(fanoutExchange());
    }
​
    @Bean
    public Binding et2403Binding(Queue et2403,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(et2403).to(fanoutExchange);
    }
​
}

  • 发送消息

    import com.etoak.config.FanoutConfig;
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.RequestParam;
import org.springframework.web.bind.annotation.RestController;
​
@RestController
@RequestMapping("/fanout")
public class FanoutController {
​
    @Autowired
    RabbitTemplate rabbitTemplate;
​
    @RequestMapping("/send")
    public String send(@RequestParam String msg){
        rabbitTemplate.convertAndSend(FanoutConfig.EXCHANGE,"",msg);
        return "success";
    }
​
}

  • 执行结果

  • 消费消息

    import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
​
@Component
public class ConsumerService {
​
    @RabbitListener(queues = "ET2402")
    public void consume(String msg){
        System.out.println("消费ET2402消息:"+msg);
    }
​
    @RabbitListener(queues = "ET2403")
    public void consume2(String msg){
        System.out.println("消费ET2403消息:"+msg);
    }
​
}

2. 直连交换机（direct exchange）

  • 配置交换机和队列

    import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
​
@Configuration
public class DirectConfig {
​
    public static final String EXCHANGE = "amqp.color";
​
    public static final String QUEUE_1 = "Q1";
​
    public static final String QUEUE_2 = "Q2";
​
    public static final String  ORANGE = "orange";
​
    public static final String  BLACK = "black";
​
    public static final String  GREEN = "green";
​
​
    @Bean
    public DirectExchange colorExchange(){
        return new DirectExchange(EXCHANGE);
    }
​
    @Bean
    public Queue queue1(){
        return new Queue(QUEUE_1);
    }
​
    @Bean
    public Queue queue2(){
        return new Queue(QUEUE_2);
    }
​
    // 指定的routing key 为 orange 时 路由到Q1队列
    @Bean
    public Binding orangeBinding(Queue queue1,DirectExchange colorExchange){
        return BindingBuilder.bind(queue1).to(colorExchange).with(ORANGE);
    }
​
    // 指定的routing key 为 black 时 路由到Q2队列
    @Bean
    public Binding blackBinding(Queue queue2,DirectExchange colorExchange){
        return BindingBuilder.bind(queue2).to(colorExchange).with(BLACK);
    }
​
    // 指定的routing key 为 green 时 路由到Q2队列
    @Bean
    public Binding greenBinding(Queue queue2,DirectExchange colorExchange){
        return BindingBuilder.bind(queue2).to(colorExchange).with(GREEN);
    }
​
}

  • 发送消息

    import com.etoak.config.DirectConfig;
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.RequestParam;
import org.springframework.web.bind.annotation.RestController;
​
@RestController
@RequestMapping("/direct")
public class DirectController {
​
    @Autowired
    RabbitTemplate rabbitTemplate;
​
    @RequestMapping("/send")
    public String send(@RequestParam String key,@RequestParam String msg){
        rabbitTemplate.convertAndSend(DirectConfig.EXCHANGE,key,msg);
        return "success";
    }
​
}

  • 执行结果

3. 主题交换机（Topic Exchange）

topic交换机是在direct交换机的基础上，支持了对routing key的通配符匹配（*号和#号）

  • 配置交换机和队列

    import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
​
@Configuration
public class TopicConfig {
​
    public static final String EXCHANGE = "topic";
    public static final String QUEUE_3 = "Q3";
    public static final String QUEUE_4 = "Q4";
    public static final String ORANGE = "*.orange.*";
    public static final String RABBIT = "*.*.rabbit";
    public static final String LAZY = "lazy.#";
​
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(EXCHANGE);
    }
​
    @Bean
    public Queue queue3(){
        return new Queue(QUEUE_3);
    }
​
    @Bean
    public Queue queue4(){
        return new Queue(QUEUE_4);
    }
​
    @Bean
    public Binding queue3Binding(Queue queue3,TopicExchange topicExchange){
        return BindingBuilder.bind(queue3).to(topicExchange).with(ORANGE);
    }
​
    @Bean
    public Binding rabbitBinding(Queue queue4,TopicExchange topicExchange){
        return BindingBuilder.bind(queue4).to(topicExchange).with(RABBIT);
    }
​
    @Bean
    public Binding lazyBinding(Queue queue4,TopicExchange topicExchange){
        return BindingBuilder.bind(queue4).to(topicExchange).with(LAZY);
    }
​
}

  • 发送消息

    import com.etoak.config.TopicConfig;
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
@RequestMapping("/topic")
public class TopicController {
​
    @Autowired
    RabbitTemplate rabbitTemplate;
​
    @RequestMapping("/send")
    public String send(){
        // 匹配 Q3
        rabbitTemplate.convertAndSend(TopicConfig.EXCHANGE,"an.orange.juice","橙汁");
​
        //匹配 Q4
        rabbitTemplate.convertAndSend(TopicConfig.EXCHANGE,"big.white.rabbit","大白兔");
​
        // 匹配 Q4 Q3
        rabbitTemplate.convertAndSend(TopicConfig.EXCHANGE,"an.orange.rabbit","橙色兔子");
​
        // 匹配 Q4
        rabbitTemplate.convertAndSend(TopicConfig.EXCHANGE,"lazy.rabbit","懒兔子");
​
        return "success";
    }
}

4、延迟队列

延迟队列存储的消息一般都是 延时消息 ，所谓 延时消息 是指当消息被发送以后，并不想让消费者立即消费消息，而是等待指定时间 后，才允许消费者来消费这条消息；

1. 应用场景

  1. 用户下单后30分钟未支付，使用延迟队列功能取消超时的订单

  2. 注册一个网站，24小时（或几天）内未登录，发送邮件或短信通知

2.安装延迟交换机插件

  1. 插件安装目录： /usr/lib/rabbitmq/lib/rabbitmq_server-3.8.22/plugins

cd /usr/lib/rabbitmq/lib/rabbitmq_server-3.8.22/plugin

  1. 将 rabbitmq_delayed_message_exchange-3.8.0.ez 插件上传到插件安装目录

  2. 安装命令，在plugins目录下执行：

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

  1. 安装完成之后，RabbitMQ的Web控制台Exchanges选项卡下会出现一个交换机 ，如下图所示

配置延迟交换机和队列

package com.etoak.config;
​
import com.rabbitmq.client.BuiltinExchangeType;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.CustomExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
​
import java.util.HashMap;
import java.util.Map;
​
@Configuration
public class DelayedConfig {
​
    public static final String EXCHANGE = "amqp.delayed";
​
    public static final String QUEUE = "queue.delayed";
​
    public static final String KEY = "delay";
​
    /**
     * RabbitMQ 没有一个类型是表示延迟交换机
     * 交换机只有四个类型：fanout、direct、topic、headers
     * 可以使用四个中的其中一个来模拟延迟交换机
     * 使用CustomExchange定制延迟交换机
     */
    @Bean
    public CustomExchange delayedExchange() {
        Map<String, Object> args = new HashMap<>();
​
        // 使用哪种交换机模拟延迟交换机
        args.put("x-delayed-type", "direct");
        return new CustomExchange(EXCHANGE,
                "x-delayed-message", // 类型 - 延迟交换机
                true,
                false,
                args);
    }
​
    @Bean
    public Queue delayedQueue() {
        return new Queue(QUEUE);
    }
​
    @Bean
    public Binding delayedBinding(Queue delayedQueue, CustomExchange delayedExchange) {
        return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(KEY).noargs();
    }
}
​

消息生产者

import cn.hutool.core.date.DateUtil;
import com.etoak.config.DelayedConfig;
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.RequestParam;
import org.springframework.web.bind.annotation.RestController;
​
import java.util.Date;
​
@RestController
public class TestController {
​
    @Autowired
    RabbitTemplate rabbitTemplate;
​
    @RequestMapping("/send")
    public String send(int second, @RequestParam String msg) {
        rabbitTemplate.convertAndSend(DelayedConfig.EXCHANGE,
                DelayedConfig.KEY,
                msg,
                message -> {
                    // 设置延迟时间(不是过期时间), 单位ms
                    message.getMessageProperties().setDelay(1000 * second);
                    return message;
                });
        System.out.println(msg + "--发送时间--" + DateUtil.now());
        return "success";
    }
}
​

消息消费者

import cn.hutool.core.date.DateUtil;
import com.etoak.config.DelayedConfig;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;
​
import java.io.IOException;
​
@Service
public class ConsumerService {
​
    @RabbitListener(queues = DelayedConfig.QUEUE)
    public void consume(Channel channel, Message message) throws IOException {
        String msg = new String(message.getBody());
        System.out.println(msg + "--处理时间--" + DateUtil.now());
​
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        channel.basicAck(deliveryTag, false);
   }
}

✎ℳ₯㎕.baby℡825
关注
  • 10
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
RabbitMQ从原理到实战—基于Golang【万字详解】
weixin_44545838的博客
08-27 4322
最近秋招开始找工作，顺便回顾消息队列并且总结。
RabbitMQ详解（超详细整理，值得珍藏）
03-17
**RabbitMQ详解** 在IT行业中，消息队列（Message Queue）作为一种中间件，用于解耦应用程序的不同组件，实现异步通信，而RabbitMQ作为其中的佼佼者，深受开发者喜爱。本篇将深入探讨RabbitMQ的基本概念、系统架构...
RabbitMQ原理介绍
weixin_43923223的博客
08-25 210
介绍 RabbitMQ是一个由erlang开发的AMQP(Advanved Message Queue)的开源实现。 应用场景 用户注册后，需要发注册邮件和注册短信,传统的做法有两种1.串行的方式;2.并行的方式 串行 将注册信息写入数据库后,发送注册邮件,再发送注册短信,以上三个任务全部完成后才返回给客户端。 这有一个问题是,邮件,短信并不是必须的,它只是一个通知,而这种做法让客户端等待没有必要等待的东西. 并行 将注册信息写入数据库后,发送邮件的同时,发送短信,以上三个任务完成后,返回给客户端,并行的
【从零开始学习RabbitMQ | 第二篇】如何确保MQ的可靠性和消费者可靠性
最新发布
fckbb的博客
05-28 1402
在上一篇文章中，我们介绍了如何确保生产者的可靠性，确保消息一定可以到达MQ。但是MQ自己也是会丢失消息的，比如MQ的突然宕机或者消息过多造成的阻塞，因此我们这篇文章来介绍一下
RabbitMQ是什么?
你有看到我的史迪熊吗.
06-29 5035
一、RabbitMQ是什么?一款基于AMQP用于软件之间通信的中间件 。消费并不需要确保提供方存在,实现了服务之间的高度解耦AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，
RabbitMQ原理
tongtong_use的博客
11-23 901
RabbitMQ原理 RabbitMQ工作原理 RabbitMQ是AMQP协议的实现。   1. Server(broker): 接受客户端连接，实现AMQP消息队列和路由功能的进程。 2. Virtual Host:其实是一个虚拟概念，类似于权限控制组，一个Virtual Host里面可以有若干个Exchange和Queue，但是权限控制的最小粒度是Virtual Host
什么是RabbitMQ？
X_islu的博客
02-18 1447
RabbitMQ支持不同类型的交换机，其中最常用的类型之一是扇出交换机（Fanout Exchange），它会将消息广播到与之绑定的所有队列，无视消息的路由键。在RabbitMQ中，消息代理指的就是RabbitMQ服务器，它是一个中间件软件，负责接收、存储和转发消息，充当了消息的中介。请求/响应模型（Request/Reply）： 通过引入一个中间人（通常是一个处理请求的队列），请求者发送请求消息到中间人队列，而处理请求的服务则接收请求消息并将响应消息发送回一个响应队列。请求者从响应队列中获取响应消息。
RabbitMQ详解搭建
03-19
RabbitMQ是一种广泛使用的开源消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，允许应用程序之间进行异步通信。RabbitMQ在分布式系统、微服务架构以及高并发场景中扮演着关键角色，...
springBoor集成RabbitMQ详解
12-24
springboot集成rabbitMq，此篇文档，不足之处请大家指正
RabbitMQ技术详解
01-27
RabbitMQ技术详解 RabbitMQ是一个开源的消息队列系统，其主要功能是作为消息中间件，用于在分布式系统中存储和转发消息。它基于AMQP（Advanced Message Queuing Protocol），这是一种开放标准，专为面向消息的...
什么是RabbitMQ
越努力越幸运的博客
09-28 1754
同步通讯：就像打电话，需要实时响应。异步通信：就像发微信，不需要马上回复。两种方式各有优劣，打电话可以立即得到响应，但是你却不能跟多个人同时通话。发微信可以同时与多个人收发信息，但是往往响应会有延迟。学SpringCloud的时候，我们的Feign 其实就是同步通讯的，他其实有以下这几个缺点耦合度高：（每次有新的需求，都需要更改代码）性能下降：（消费者需要等待提供者响应，如果调用链过长，那么响应的时间等于每次调用的时间之和）资源浪费。
RabbitMQ的交换机类型（三）
热门推荐
yeyun666的博客
12-20 1万+
RabbitMQ的交换机类型共有四种，是根据其路由过程的不同而划分成的 分别是Direct Exchange（直连交换机）， Fanout Exchange（扇型交换机）， Topic Exchange（主题交换机）与 Headers Exchange（头交换机） 以下是四种交换机的路由图及详解、   Direct Exchange（直连交换机）：将一个名为Q的消息队列与某个名为D的直...
什么是RabbitMQ? RabbitMQ详解
听风动的博客
04-22 1万+
1.什么是rabbitMQ RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue 高级消息队列协议 ）的开源实现， 能够实现异步消息处理 RabbitMQ是一个消息代理：它接受和转发消息。 你可以把它想象成一个邮局：当你把你想要发布的邮件放在邮箱中时，你可以确定邮差先生最终...
RabbitMq 有啥用
毅呀毅呀哟
09-01 3670
目录 一、MQ有啥用嘞 1、同步 2、异步 二、MQ的使用场景有哪些嘞。 1、注册操作成功信息的异步发送 2、典型应用-电商系统中的秒杀操作 一、MQ有啥用嘞 如下两个图可以看到同步和异步的区别。 1、同步 2、异步 二、MQ的使用场景有哪些嘞。 1、注册操作成功信息的异步发送 场景： 注册操作后要给用户发送注册成功的邮件和短信 分析： 这个过程中用户注册最核心的操作是将用户信息存入数据库中，而发送邮件和短信的操作对于用户而言是允许有稍许延迟的，如果在一个方...
RabbitMQ简介
weixin_58473601的博客
06-22 808
RabbitMQ
RabbitMQ 消费者
zyppxx的博客
08-23 1522
消费者就是针对某个队列进行消息监听和消息消费的。消费者消费消息存在拉模式和推模式，推模式的是使用场景相对比较多。为确保消息被合法的消费，RabbitMQ提供了消费确认机制，投递的消息并不能被理解完成了消费，仅消费者确认消费该消息才会被移除队列。默认的消息投递机制时轮询，轮询的消息分发并会关系消费者的性能以及消息积压的问题，因此需要限制每个消费者所能保持的最大未确认的消息数量。
RabbitMQ（三）消费者生产者
weixin_43189971的博客
08-09 1532
无
RabbitMq消费者和生产者模式
weixin_44895829的博客
04-01 4810
导入依赖： <dependencies> <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.8.0</version> </dependency> ..
RabbitMQ消费端之消息确认及消息预取
我的博客
07-31 675
默认情况下 消费者在拿到rabbitmq的消息时 已经自动确认这条消息已经消费了， 讲白话就是rabbitmq的队列里就会删除这条消息了， 但是 我们实际开发中 难免会遇到这种情况， 比如说 拿到这条消息 发现我处理不了 比如说 参数不对， 又比如说 我当前这个系统出问题了， 暂时不能处理这个消息， 但是 这个消息已经被你消费掉了 rabbitmq的队列里也删除掉了， 你自己这边又处理不了， 那么 ，这个消息就被遗弃了。关于这个预取的数量如何设置呢？那么批量确认， 就是对于我们预取的消息，进行统一的确认。
rabbitmq详解
07-28
RabbitMQ是一个开源的消息代理软件，它实现了高级消息队列协议（AMQP）并提供可靠的消息传递机制。它可以用于构建分布式系统，处理大量的消息传递和异步通信。以下是关于RabbitMQ的一些详解： 1. 下载和安装：你可以从RabbitMQ官方网站下载RabbitMQ的安装包。你可以使用wget命令下载RabbitMQ的rpm包，例如：wget https://www.rabbitmq.com/releases/rabbitmq-server/v3.6.10/rabbitmq-server-3.6.10-1.el7.noarch.rpm。安装完成后，你可以双击安装包进行安装。安装完成后，你可以运行rabbitmq-plugins enable rabbitmq_management命令来安装RabbitMQ-Plugins插件。然后，你可以运行rabbitmq-server.bat来启动RabbitMQ服务。\[1\]\[2\] 2. 后台运行：如果你想在后台运行RabbitMQ，你可以使用rabbitmq-server -detached命令来启动RabbitMQ服务。如果你想停止RabbitMQ服务，你可以使用rabbitmqctl stop命令。\[3\] 总结起来，RabbitMQ是一个功能强大的消息代理软件，它可以用于构建分布式系统和处理大量的消息传递。你可以通过下载和安装RabbitMQ来开始使用它，并且可以选择在前台或后台运行RabbitMQ服务。 #### 引用[.reference_title] - *1* *2* [RabbitMQ详解，用心看完这一篇就够了【重点】](https://blog.csdn.net/weixin_42039228/article/details/123493937)[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^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [RabbitMQ 详解](https://blog.csdn.net/m0_53067943/article/details/130578563)[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^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值