RabbitMQ基础（简单易懂）

最新推荐文章于 2024-09-04 21:54:41 发布
最新推荐文章于 2024-09-04 21:54:41 发布
阅读量128 收藏
点赞数
分类专栏： Java 消息中间件 文章标签： java-rabbitmq rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shier12jfjcj/article/details/134041247
版权

1、MQ概念

MQ：消息队列，底层为先进先出数据结构的消息服务器；

MQ作用：实现两个系统中的数据传输，消息即为传输的数据。 

 - 系统间传输数据的传统方式

 - 系统间传输数据的队列方式

传统方式：同步，能够立刻拿到被调用接口处理后的数据；

消息队列（MQ）：异步，效率高，无法拿到消费者处理后的数据

MQ的应用场景：系统解耦，流量消峰，数据分发

2、RabbitMQ工作原理

  • Producer（生产者）：负责进行消息的发送
  • Consumer（消费者）：负责从MQ中获取消息进行消费
  • Broker（代理）：RabbitMQ的服务端
  • Exchange（交换机）：不存储消息，只转发消息，把消息转发给指定队列
  • Queue（队列）：负责存储消息

3、使用

（1）环境搭建

  • 使用docker拉取镜像，本次使用版本为3.8 
docker pull rabbitmq:3.8-management
  • 使用docker安装rabbitMQ容器，设置端口，挂载点等
docker run -d --name rabbit01 -e RABBITMQ_DEFAULT_USER=admin \
-e RABBITMQ_DEFAULT_PASS=admin \
-p 15672:15672 -p 5672:5672 \
--hostname rabbit01 --restart=always \
-v rabbit01_data:/var/lib/rabbitmq \
-v rabbit01_conf:/etc/rabbitmq \
rabbitmq:3.8-management
  • 使用ip和端口查看rabbitMQ的后台管理系统

（2）编写代码

2.1 简单队列模型的实现

 使用重点：注入RabbitTemplate发消息，给方法添加@RabbitListener（queues="simple_queue"）注解收消息

  •  创建Maven工程，导入springboot与mq的启动项与springboot与junit的启动项
<!-- 指定父工程 -->
<parent>
  <artifactId>spring-boot-starter-parent</artifactId>
  <groupId>org.springframework.boot</groupId>
  <version>2.3.6.RELEASE</version>
</parent>

<dependencies>
  <!-- spring boot和rabbitmq整合的时候所需要的起步依赖 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
  </dependency>

  <!-- spring boot和junit整合的起步依赖 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
  </dependency>
</dependencies>
  • 创建producer（生产者）子模块，在子模块中创建Application启动器
@SpringBootApplication
public class RabbitmqProducerApplication {
    public static void main(String[] args) {
        SpringApplication.run(RabbitmqProducerApplication.class,args);
    }
}
  • 在yml文件中配置rabbitMQ的参数 
spring:
  rabbitmq:
    host: 192.168.126.137
    port: 5672
    username: admin
    password: admin
    virtual-host: /
  •  在producer模块中创建测试方法，注入rabbitTemplate依赖，调用其方法发送消息
@SpringBootTest
    public class Producer01 {

        @Autowired
        RabbitTemplate rabbitTemplate;

        //生产者1，测试简单模式
        @Test
        public void test01(){
            rabbitTemplate.convertAndSend("simple_queue","测试消息1");
        }
    }
  • 创建consumer（消费者）子模块；在其中创建Application启动器 
@SpringBootApplication
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}
  • 配置参数 
spring:
  rabbitmq:
    host: 192.168.126.137
    port: 5672
    username: admin
    password: admin
    virtual-host: /
  • 在子模块中创建listener01包，并创建一个监听类，类上加@Component注解，创建方法并在方法上加@RabbitListener注解，方法中带参数Message，注解中带参数（queues=“simple_queue”）
@Component
public class Listen01 {
//    创建监听器用来消费消息队列中的消息
//    简单队列消费者
    @RabbitListener(queues = "simple_queue01")
    public void consumer01(Message message){
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println("msg------>"+s);
    }
}

 2.2 工作队列模型的实现

 使用重点：降低生产速度，提高消费速度；注入RabbitTemplate发消息，给方法添加@RabbitListener（queues="simple_queue"）注解收消息

  • 创建生产模块方法，使用循环发送多个消息 
//生产者2，测试工作模式
    @Test
    public void test02(){
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend("simple_queue01","测试消息2"+i);
        }
    }
  •  在消费模块中再创建一个listener02包，并创建消费方法
@Component
public class Listen02 {
//    创建监听器用来消费消息队列中的消息
//    简单队列消费者
    @RabbitListener(queues = "simple_queue01")
    public void consumer01(Message message){
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println("consumer-02------>"+s);
    }
}

2.3 发布订阅模型

使用重点：多了一个exchange（交换机）的角色，需要手动指定消息转发的队列；使用的交换机为Fanout交换机，自动将生产者的消息发送给所有与交换机绑定的队列；

Fanout交换机

特点：将消息转发给所有绑定的队列，创建方法为ExchangeBuilder，QueueBuilder，BindingBuilder

  • 在生产者中创建配置类
@Configuration
public class ProducerConfiguration {
//    创建交换机
    @Bean
    public Exchange fanoutExchange(){
         Exchange fanoutexchange = ExchangeBuilder.fanoutExchange("fanout_exchange")
                .durable(true).build();
        return fanoutexchange;
    }
//    创建队列01
    @Bean
    public Queue queue01(){
        Queue queue01 = QueueBuilder.durable("queue01").build();
        return queue01;
    }

//    创建队列02
    @Bean
    public Queue queue02(){
        Queue queue02 = QueueBuilder.durable("queue02").build();
        return queue02;
    }

//    创建绑定1
    @Bean
    public Binding binding01(){
        Binding binding01 = BindingBuilder.bind(queue01()).to(fanoutExchange()).with("").noargs();
        return binding01;
    }

//    创建绑定2
    @Bean
    public Binding binding02(){
        Binding binding02 = BindingBuilder.bind(queue02()).to(fanoutExchange()).with("").noargs();
        return binding02;
    }
}
  • 在消费者中创建两个监听类消费消息
@Component
public class Listen01 {
    @RabbitListener(queues = "queue01")
    public void consumer01(Message message){
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println("consumer01---->"+s);
    }
}


@Component
public class Listen02 {
    @RabbitListener(queues = "queue02")
    public void consumer02(Message message){
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println("consumer02---->"+s);
    }
}
  • 在消费者中创建测试方法给交换机发送消息
//生产者3，测试订阅模式
    @Test
    public void test03(){
        rabbitTemplate.convertAndSend("fanout_exchange","","你好fanout交换机！！");
    }

 2.4 路由模型

 重点：交换机将消息通过路由（字符串匹配）发送到响应队列

 Direct交换机

 特点：将消息转发给指定路由的队列

  •  在生产者模块中创建配置类
@Configuration
public class DirectConfigurarion {
//    创建交换机
    @Bean
    public Exchange directExchange(){
        Exchange directExchange = ExchangeBuilder.directExchange("direct_exchange").durable(true).build();
        return directExchange;
    }

//    创建队列03
    @Bean
    public Queue queue03(){
        Queue queue03 = QueueBuilder.durable("queue03").build();
        return queue03;
    }

//    创建队列04
    @Bean
    public Queue queue04(){
        Queue queue04 = QueueBuilder.durable("queue04").build();
        return queue04;
    }

//    创建绑定error
    @Bean
    public Binding binding03(){
        Binding binding03 = BindingBuilder.bind(queue03()).to(directExchange()).with("error").noargs();
        return binding03;
    }

//    创建绑定error
    @Bean
    public Binding binding04(){
        Binding binding04 = BindingBuilder.bind(queue04()).to(directExchange()).with("error").noargs();
        return binding04;
    }

//    创建绑定info
    @Bean
    public Binding binding05(){
        Binding binding04 = BindingBuilder.bind(queue04()).to(directExchange()).with("info").noargs();
        return binding04;
    }
}
  •  在消费者模块创建监听类
@Component
public class Listen03 {
    @RabbitListener(queues = "queue03")
    public void consumer03(Message message){
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println("consumer03---->"+s);
    }
}
  •  在生产者中创建测试方法
//生产者4，测试路由模式
    @Test
    public void test04(){
        rabbitTemplate.convertAndSend("direct_exchange","error","测试error消息，同时发送给03和04");
        rabbitTemplate.convertAndSend("direct_exchange","info","测试info消息，只发送给04");
    }

 2.5 主题模型

重点：动态路由，在绑定时可以使用通配符，路由路径分为*和#

Topic交换机

特点：路径中通配符为#，可以匹配0个或多个词；路径中通配符为*，可以只能匹配1个词

  • 在生产模块中创建配置类
@Configuration
public class TopicConfiguration {

//    创建交换机
    @Bean
    public Exchange topicExchange(){
        Exchange topicExchange = ExchangeBuilder.topicExchange("topic_exchange").durable(true).build();
        return topicExchange;
    }

//    创建队列
    @Bean
    public Queue queue05(){
        Queue queue05 = QueueBuilder.durable("queue05").build();
        return queue05;
    }

//    创建队列
    @Bean
    public Queue queue06(){
        Queue queue06 = QueueBuilder.durable("queue06").build();
        return queue06;
    }

//    创建绑定05
    @Bean
    public Binding binding5(){
        Binding binding05 = BindingBuilder.bind(queue05())
                .to(topicExchange()).with("*.orange.*").noargs();
        return binding05;
    }

//    创建绑定06
    @Bean
    public Binding binding6(){
        Binding binding06 = BindingBuilder.bind(queue06())
                .to(topicExchange()).with("lazy.#").noargs();
        return binding06;
    }
}
  • 在消费模块中创建监听器
@Component
public class Listen05 {
    @RabbitListener(queues = "queue05")
    public void consumer05(Message message){
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println("consumer05---->"+s);
    }
}

@Component
public class Listen06 {
    @RabbitListener(queues = "queue06")
    public void consumer06(Message message){
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println("consumer06---->"+s);
    }
}
  • 在生产模块中创建测试方法
//生产者5，测试主题模式
    @Test
    public void test05(){
        rabbitTemplate.convertAndSend("topic_exchange","a.orange.b","测试*.orange.*匹配一个路径");
        rabbitTemplate.convertAndSend("topic_exchange","orange.a.b","测试*.orange.*匹配零个路径");
        rabbitTemplate.convertAndSend("topic_exchange","lazy.a","测试lazy.*匹配一个路径");
        rabbitTemplate.convertAndSend("topic_exchange","lazy.a.b","测试lazy.*匹配两个路径");
        rabbitTemplate.convertAndSend("topic_exchange","lazy","测试lazy.*匹配零个路径");
    }

4、注解方式创建配置

重点：在使用时常规操作较为繁琐，需要创建配置类，而@RabbitListener注解则可以将步骤简化；

注解操作为：生产者发送消息，创建监听器，在监听器注解中配置参数，主要参数为@RabbitListener(bindings (value,exchange,key))

  • 创建监听类，在注解中配置参数
@Component
public class Listen07 {
//    使用注解直接监听消息,以路由模式为例
//    监听器07
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "queue07",durable = "true"),
            exchange = @Exchange(name = "direct02_exchange",durable = "true",type = ExchangeTypes.DIRECT),
            key = {"error"}
    ))
    public void listen07(Message message){
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println("consumer07----->"+s);
    }

//    监听器08
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "queue08",durable = "true"),
            exchange = @Exchange(name = "direct02_exchange"),
            key = {"error","info"}
    ))
    public void listen08(Message message){
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println("consumer08----->"+s);
    }
}
  • 创建测试类，模拟生产者发送消息
生产者6，测试使用注解监听消息，以订阅模式为例
    @Test
    public void test06(){
        rabbitTemplate.convertAndSend("direct02_exchange","error","测试error消息，7和8都要听到");
        rabbitTemplate.convertAndSend("direct02_exchange","info","测试info消息，8都要听到");
    }

 

5、总结

重点：     （1）RabbitMQ概念：是一个底层数据结构为队列的服务器；

                （2）RabbitMQ作用：实现系统之间的数据传输；

                （3）RabbitMQ应用：流量消峰，系统解耦，分发数据

                （4）RabbitMQ使用：熟练掌握以上五种模式的操作，熟练掌握注解的使用。

小棕熊121
关注
专栏目录
RabbitMQ的入门
尽力漂亮的博客
02-26 440
RabbitMQ的入门消息中间件所有消息中间件本次的主题RabbitRabbitMQ的安装使用docker 安装使用centos安装更新基本系统安装Erlang安装RabbitMQ开始RabbitMQ常用操作命令 消息中间件 所有消息中间件 结论： activiMq老牌消息中间件，api全面，但是吞吐量不大 Kafaka吞吐量大，但是数据无法保证不丢失，主要面向大数据 rokectMQ：吞吐量...
RabbitMQ基础知识
weixin_30723433的博客
01-07 174
RabbitMQ基础知识 一、背景 RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue ）的开源实现。AMQP 的出现其实也是应了广大人民群众的需求，虽然在同步消息通讯的世界里有很多公开标准（如 COBAR的 IIOP ，或者是 SOAP 等），但是在异步消息处理中却不是这样，只有大企业有一些商业实现（如微软的 MSMQ ，IBM...
RabbitMQ学习笔记
最新发布
m0_74293254的博客
09-04 1581
MQ 是“消息队列”（Message Queue）的缩写，是一种用于异步通信的中间件系统。它允许不同应用程序或服务之间通过消息传递进行数据交换，而不需要它们直接连接或实时交互。MQ 的核心功能包括消息的存储、路由和分发，使得消息生产者和消费者可以解耦，从而提高系统的可伸缩性和可靠性。常见的 MQ 系统包括 RabbitMQ、Apache Kafka 和 ActiveMQ等。RabbitMQActiveMQRocketMQKafka公司/社区RabbitApache阿里Apache。
RabbitMQ入门（1）--介绍
weixin_34304013的博客
02-24 553
2019独角兽企业重金招聘Python工程师标准>>> ...
RabbitMQ 入门
lishuaigell的博客
06-13 289
MQ全称为Message Queue 消息队列（MQ）是一种应用程序对应用程序的通信方法。MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取队列中的消息。这样发布者和使用者都不用知道对方的存在。我们先不管消息(Message)这个词，来看看队列(Queue)。这一看，队列大家应该都熟悉吧。消息队列可以简单理解为：把要传输的数据放在队列中。消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使
RabbitMQ之消息模式简单易懂，超详细分享~~~
m0_56069948的博客
09-13 691
上一篇对RabbitMQ的流程和相关的理论进行初步的概述，如果小伙伴之前对消息队列不是很了解，那么在看理论时会有些困惑，这里以消息模式为切入点，结合理论细节和代码实践的方式一起来学习。RabbitMQ提供了多种模式应对各种业务，但匹配条件越是模糊或者参数化，那性能相对比较弱。再回顾一些常用的消息队列组件，是不是很多都是默认使用Direct模式，精确匹配的RoutingKey可以针对具体不同业务处理，匹配性能也相对比较高；当然其他模式小伙伴也可以针对业务情况进行使用。
RabbitMQ使用示例教程：简单易懂的学习指南
1. RabbitMQ基础概念: RabbitMQ是一个在内存中执行的AMQP消息代理（Broker），也支持磁盘存储。它允许应用之间通过异步消息传递进行通信。RabbitMQ运行在Erlang虚拟机上，并且可以用多种语言编写客户端。消息代理的...
【RabbitMQ】RabbitMQ快速入门 通俗易懂 初学者入门
专注于Java领域开发 关注我 带你玩转Java
11-30 1703
【推荐】RabbitMQ快速入门 1小时上手学会RabbitMQ
RabbitMQ消息队列入门篇（环境配置+Java实例+基础概念）
热门推荐
小宝鸽
01-09 4万+
一、消息队列使用场景或者其好处消息队列一般是在项目中，将一些无需即时返回且耗时的操作提取出来，进行了异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。在项目启动之初来预测将来项目会碰到什么需求，是极其困难的。消息队列在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口。这允许你独立的扩展或修改两边的处理过程，只要确保它们遵守同样的接口
RabbitMQ集群搭建及实践
AI天才研究院
08-05 814
RabbitMQ 是用 Erlang 语言开发的开源消息队列系统，它是一种支持多种消息中间件协议的 AMQP（高级消息队列协议）实现。RabbitMQ 的主要特征有易学性、稳定性、灵活性、适应性和扩展性等。RabbitMQ 是当下最流行的开源消息代理之一，被越来越多的公司和组织所采用。RabbitMQ 在性能上具有很好的表现力，尤其是在单机情况下能够处理几百万个连接。因此，在分布式计算和大数据量场景下，RabbitMQ 也是一款非常优秀的分布式消息队列解决方案。
rabbitMq入门
08-08
NULL 博文链接：https://zhaoshijie.iteye.com/blog/2161345
RabbitMQ简单入门
Jumpingyyds的博客
03-26 2658
一、关于MQ的介绍 消息队列MQ是一种应用之间异步通信的方式，主要是由三个部分组成：第一个是生产者（producer），生产者也就是说生产消息的这一端，然后主要是负责消息所承载业务信息的一个实例化，是我们整个消息的发起方；第二个是Broker，它是我们整个消息的服务端，主要是去处理我们这个消息单元，它负责消息的存储、投递以及队列的一些其他附加功能的实现，它是整个消息队列里面最核心的组成部分；第三个消费者（consumer），主要负责消息的消费，具体是根据消息所承载的一个信息去处理各种业务逻辑。市面上几款比
Rabbitmq基础
从基础到源码解析的学习记录
12-08 1422
文章目录一、RabbitMQ入门介绍1、RabbitMQ的工作原理二、RabbitMQ五种消息发送模式1、简单队列模式2、工作队列模式2.1、轮询分发（公平分发）2.2、能者多劳（不公平分发）3、发布订阅模式4、路由模型模式5、主题模式 一、RabbitMQ入门介绍 1、RabbitMQ的工作原理 组成部分说明： Broker：消息队列服务进程，此进程包括两个部分：Exchange和Queue Exchange：消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过虑 Queue：消息队列，
spring boot RabbitMq基础教程
个人博客，记录了本人学习的各种有趣的技术。
10-12 1623
描述下Direct交换机与Fanout交换机的差异？Fanout交换机将消息路由给每一个与之绑定的队列Direct交换机根据RoutingKey判断路由给哪个队列如果多个队列具有相同的RoutingKey，则与Fanout功能类似以上的代码已上传到Github。
RabbitMQ：基础篇
kaiwawah的博客
07-17 674
在MQ中创建虚拟主机实现数据隔离。
RabbitMQ基础概念详细介绍
woailuohui的专栏
08-14 9168
RabbitMQ简介 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。RabbitMQ是一个开源的AMQP实现，服务器端用Erl...
RabbitMQ 入门介绍
qq_24991197的博客
06-17 2613
MQ 的相关概念 什么是 MQ MQ(message queue)，从字面意思上看，本质是个队列，FIFO 先入先出，只不过队列中存放的内容是message 而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ 是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用了 MQ 之后，消息发送上游只需要依赖 MQ，不用依赖其他服务。 为什么要用 MQ 1.流量消峰 举个例子，如果订单系统最多能处理一万次订单，这个处理能力应付正常时段的下单时绰绰有余，正常时段我们下单一秒后就能返回结
RabbitMQ入门篇
daimeijin的博客
12-23 148
文章目录前言MQ 的基本概念MQ 的优势MQ 的劣势常见的 MQ 产品RabbitMQRabbitMQ 简介RabbitMQ 中的相关概念：RabbitMQ工作模式Work queues 工作队列模式Pub/Sub 订阅模式Routing 路由模式Topics 通配符模式工作模式总结消息确认生产者 前言 记录RabbitMQ MQ 的基本概念 MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信 MQ 的优势 应用解耦 提高系统容错性和可维
RabbitMQ基础使用与实践教程
资源摘要信息: "RabbitMQ入门教程" RabbitMQ是一个开源的消息代理软件（亦称面向消息的中间件），它是基于高级消息队列协议（AMQP）的实现，最初由LShift公司开发，后来被Pivotal收购。RabbitMQ被广泛使用在各种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值