RabbitMQ学习记录

最新推荐文章于 2024-03-01 00:32:08 发布
最新推荐文章于 2024-03-01 00:32:08 发布
阅读量292 收藏
点赞数
分类专栏： java-springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RUIMENG061511332/article/details/84953747
版权

使用spring boot整合RabbitMQ，构建多模块工程学习rabbitMQ使用，学习记录如下：

搭建spring-boot多模块工程：

分别演示，RabbitMQ的工作模式：

第一种：

Direct Exchange
Direct Exchange是RabbitMQ默认的交换机模式，也是最简单的模式，根据key全文匹配去寻找队列。

这种工作模式，使用默认交换机，在生产者在发送消息时，直接指定队列名称，将消息发送到指定的队列中，消费者，在接受消息时，指定监听某一指定的队列。

代码演示如下：

公共初始化代码：

首先，在公共工程common，创建RabbitmqConfig类，此类主要用于项目初始化时，创建必要的bean,比如，创建队列，交换机，交换机绑定队列等。

@Configuration
public class RabbitmqConfig {
    @Bean
    public Queue Queue() {
        return new Queue("hello");
    }
}

使用@configation注解，默认初始化是创建里面声明的对象，注意要在，启动类开启扫描该包;@ComponentScan(...)

@SpringBootApplication
@ComponentScan(basePackages={"com.yunda.sb.rmq"})//扫描本项目下的所有类
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication .class, args);
    }
}

生产者代码:

在producer工程下，创建测试类：

使用测试类，发送消息，注入RabbitTemplate，使用convertAndSend方法，指定队列名称，和消息内容。也可以发送实体对象，但是实体类需要实现序列化接口。

@SpringBootTest
@RunWith(SpringRunner.class)
public class RMQProducerTest {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void send() {

     //   User user = new User("张三",18 );
     //   this.rabbitTemplate.convertAndSend("hello", user);
        String context = "hello " + new Date();
        System.out.println("Sender : " + context);
//注意第一个参数，队列名称，第二个参数，消息内容
        this.rabbitTemplate.convertAndSend("hello", context);
    }

}

在consumer工程下，创建类，用于监听队列消息

消费者代码：

注意启动类扫描到该包下，创建该监听类，方法上指定监听的队列名称，

@Component
public class ReceiveHandler {

    @RabbitListener(queues = "hello")
    public void process(String hello) {
        System.out.println("Receiver  : " + hello);
    }
  /*  @RabbitListener(queues = "hello")
    public void process(User user) {
        System.out.println("Receiver  : " + user.toString());
    }*/
}

另一中写法：一个类监听一个队列的方法。

@Component
@RabbitListener(queues = "hello")
public class ReceiveHandler {

    @RabbitHandler
    public void process(String hello) {
        System.out.println("Receiver  : " + hello);
    }
}

第二种：fanout

发布订阅模式，广播模式生产者将消息发送给交换机，交换机会把这个消息，发给每一个绑定到该交换机的队列，即一对多

                                                                    

代码演示如下：

公共初始化代码：

公共common，配置类初始化，声明交换机，队列，绑定队列与交换机，注意指定的交换机类型，为FanoutExchange，这里使用创建队列方式，一个声明常量方式，另一种直接在注解，使用字符串作为队列名称，注意，在绑定队列到交换机传入的参数，是FanoutExchange。

@Configuration
public class RabbitmqConfigFanout {
    //交换机名称
    public static final String EXCHANGE_TOPICS_INFORM="fanoutExchange";
    //队列名称
    public static final String QUEUE_INFORM_EMAIL = "queue01";
    public static final String QUEUE_INFORM_SMS = "queue02";
    /**
     * 交换机配置
     * ExchangeBuilder提供了fanout、direct、topic、header交换机类型的配置
     * @return the exchange
     */
    @Bean(EXCHANGE_TOPICS_INFORM)
    public FanoutExchange EXCHANGE_TOPICS_INFORM() {
        //durable(true)持久化，消息队列重启后交换机仍然存在
        //注意在这里指定的交换机类型，是fanout
        return new FanoutExchange(EXCHANGE_TOPICS_INFORM);
    }
    //声明队列
    @Bean(QUEUE_INFORM_SMS)
    public Queue QUEUE_INFORM_SMS() {
        Queue queue = new Queue(QUEUE_INFORM_SMS);
        return queue;
    }
    //声明队列
    @Bean(QUEUE_INFORM_EMAIL)
    public Queue QUEUE_INFORM_EMAIL() {
        Queue queue = new Queue(QUEUE_INFORM_EMAIL);
        return queue;
    }
    //声明队列
    @Bean("queue03")  //队列名称
    public Queue QUEUE_03() {
        Queue queue = new Queue("queue03");
        return queue;
    }
    /**
     * 绑定队列到交换机
     * @param queue the queue
     * @param exchange the exchange
     * @return the binding
     */
    @Bean
    public Binding bindQueue01(@Qualifier(QUEUE_INFORM_SMS) Queue queue,
                                            @Qualifier(EXCHANGE_TOPICS_INFORM) FanoutExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange);
    }
    @Bean
    public Binding bindQueue02(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue,
                                              @Qualifier(EXCHANGE_TOPICS_INFORM) FanoutExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange);
    }

    @Bean
    public Binding bindQueue03(@Qualifier("queue03") Queue queue,
                                              @Qualifier(EXCHANGE_TOPICS_INFORM) FanoutExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange);
    }

如上图，打开rabbit管理界面，找到创建的交换机，绑定的3个队列如上。

生产者代码：

在producer工程下，的测试类，中加入发送消息的测试方法，注意，这里的发送方法的参数，第一个，交换机名称，第二个路由键，默认给空串，第三个消息的内容。

@Test
    public void send2() {
        String context = "hi, fanout msg ==========> ";
        //注意这里是3个参数，第1个交换机名称，第2个路由键默认为空，第3个为消息内容。
        this.rabbitTemplate.convertAndSend("fanoutExchange","", context);
        System.out.println("Sender : " + context);
// this.rabbitTemplate.convertAndSend(RabbitmqConfigFanout.EXCHANGE_TOPICS_INFORM,"", context);
    }

消费者代码：

在consumer工程下，创建消息监听类，ReceiveHandlerFanout，分别监听三个队列，

@Component
public class ReceiveHandlerFanout {

      @RabbitListener(queues = "queue01")
      public void receive_queue01( String message){
          System.out.println(message);
    }
    @RabbitListener(queues = "queue02")
    public void receive_queue02( String message){
        System.out.println(message);
    }
    @RabbitListener(queues = "queue03")
    public void receive_queue03( String message){
        System.out.println(message);
    }

}

 

第三种方式：Routing模式

交换机为direct模式，队列绑定交换机，并指定路由键，生产者，发送消息到交换机，并同时给出了路由键，交换机根据给过来的路由键，将消息，放到相应得到队列中去。

                             

代码演示如下：

公共工程common下，创建RabbitmqConfigRouting配置类，初始化创建交换机，队列，队列绑定交换机并指定路由键，代码如下：注意交换机类型为，DirectExchange

@Component
public class RabbitmqConfigRouting {

    /**第一步，创建交换机
     * 交换机配置
     * ExchangeBuilder提供了fanout、direct、topic、header交换机类型的配置
     */
    @Bean("routingExchange")
    public DirectExchange creatRoutingExchange() {
        //durable(true)持久化，消息队列重启后交换机仍然存在
        //注意在这里指定的交换机类型，是fanout
        return new DirectExchange("routingExchange");
    }
    /**第二步，创建队列
     * 指定队列名称，bean名称
     */

    //声明队列
    @Bean("queueAA")  //队列名称
    public Queue QUEUE_AA() {
        Queue queue = new Queue("queueAA");
        return queue;
    }

    //声明队列
    @Bean("queueBB")  //队列名称
    public Queue QUEUE_BB() {
        Queue queue = new Queue("queueBB");
        return queue;
    }

    /**
     * 第三步，队列绑定交换机，并指定绑定规则，即说明绑定的路由规则
     * 传入参数，交换机和队列
     */
    @Bean
    public Binding BINDING_QUEUE_AA(@Qualifier("queueAA") Queue queue,
                                            @Qualifier("routingExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("AA");
    }

    @Bean
    public Binding BINDING_QUEUE_BB(@Qualifier("queueBB") Queue queue,
                                            @Qualifier("routingExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("BB");
    }

}

启动项目，打开管理页面，发现，已经创建了交换机并绑定了对应的队列如下图，对比上述代码。交换机名称，队列名称，路由键。

                                                            

生产者代码:

在producer工程的测试类中，继续创建发送消息的方法，如下，指定路由键，

代码如下：

   @Test
    public void sendAA() {
        String context = "hi AA, this is  msg to AA queue ";
        //注意这里是3个参数，第1个交换机名称，第2个路由键，第3个为消息内容。
        this.rabbitTemplate.convertAndSend("routingExchange","AA", context);
        System.out.println("Sender : " + context);
    }
    @Test
    public void sendBB() {
        String context = "hi BB, this is  msg to BB queue ";
        //注意这里是3个参数，第1个交换机名称，第2个路由键，第3个为消息内容。
        this.rabbitTemplate.convertAndSend("routingExchange","BB", context);
        System.out.println("Sender : " + context);
    }

 

消费者代码：

在consumer工程下，创建类ReceiveHandlerRouting，用于监听这个2个队列，

@Component
public class ReceiveHandlerRouting {

    @RabbitListener(queues = "queueAA")//监听队列AA
    public void receive_queueAA( String message){
        System.out.println("Receiver A "+message);
    }
    @RabbitListener(queues = "queueBB") //监听队列BB
    public void receive_queueBB( String message){
        System.out.println("Receiver B "+message);
    }
}

分别测试，向AA队列，BB队列发送消息，测试成功。

 

第四种方式  Topics

            Topics 话题模式或者主题模式，这种模式下，交换机的类型为topic,队列绑定交换机的时候，不再是一个确定的路由键，而是带通配符的路由模式，生产者在发送消息时，会指定一个具体的路由键，交换机拿到这个路由键后，去匹配跟它绑定队列的路由模式，如果，匹配上这个路由键，就会把这个消息投递到这队列中，主要匹配上就会投递，所有，一条消息，可以投递到多个队列中去，只要这些队列满足匹配规则。

                

 

代码演示如下：

公共配置类，在common工程下，创建初始化配置类，RabbitmqConfigTopics，指定交换机类型，创建队列，队列绑定交换机并指定路由模式。代码入下：

@Component
public class RabbitmqConfigTopics {
    /**第一步，创建交换机
     * 交换机配置
     * ExchangeBuilder提供了fanout、direct、topic、header交换机类型的配置
     */
    @Bean("topicsExchange")
    public TopicExchange createTopExchange() {
        //durable(true)持久化，消息队列重启后交换机仍然存在
        //注意在这里指定的交换机类型，是topic
        return new TopicExchange("topicsExchange");
    }
    /**第二步，创建队列
     * 指定队列名称，bean名称
     */
    @Bean("topicA")
    public Queue QueueA() {
        return new Queue("topicA");
    }

    @Bean("topicB")
    public Queue QueueB() {
        return new Queue("topicB");
    }
    /**
     * 第三步，队列绑定交换机，并指定绑定规则，
     * 绑定规则为指定路由模式，不是一个固定的路由键
     * 传入参数，交换机和队列
     */
    @Bean
    public Binding BINDING_QUEUE_Topic_A(@Qualifier("topicA") Queue queue,
                                            @Qualifier("topicsExchange") TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("topic.#.A.*");
    }
    @Bean
    public Binding BINDING_QUEUE_Topic_B(@Qualifier("topicB") Queue queue,
                                              @Qualifier("topicsExchange") TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("topic.*.B.#");
    }
}

启动项目，打开管理页面，观察创建好的交换机，队列，及路由模式

                                                        

生产者代码：

在producer工程下的测试类中创建测试方法，注意模式的匹配。

在发消息是，指定具体的路由键，交换机拿到路由键去匹配路由模式，匹配成功，就进行投递消息到队列

 //*表示一个词.
    //  #表示零个或多个词.
    @Test
    public void sendTopicA() {
        String context = "hi TopicA, 这个消息只能由A队列接受 ";
        //注意这里是3个参数，第1个交换机名称，第2个路由键，第3个为消息内容 topicA的路由模式，topic.#.A.*
        this.rabbitTemplate.convertAndSend("topicsExchange","topic.A.info", context);
        System.out.println("Sender : " + context);
    }
    @Test
    public void sendTopicB() {
        String context = "hi TopicB, 这个消息只能由B队列接受";
        //注意这里是3个参数，第1个交换机名称，第2个路由键，第3个为消息内容。topicB的路由模式，topic.*.B.#
        this.rabbitTemplate.convertAndSend("topicsExchange","topic.info.B", context);
        System.out.println("Sender : " + context);
    }
    @Test
    public void sendTopicC() {
        String context = "hi TopicA and TopicB , 这个消息可以由A队列，B队列接受";
        //注意这里是3个参数，第1个交换机名称，第2个路由键，第3个为消息内容。
        this.rabbitTemplate.convertAndSend("topicsExchange","topic.A.B", context);
        System.out.println("Sender : " + context);
    }

 

消费者代码：

在consumer工程下创建监听类ReceiveHandlerTopics，获取队列消息，

@Component
public class ReceiveHandlerTopics {
    @RabbitListener(queues = "topicA")//监听队列topicA
    public void receive_queueAA( String message){
        System.out.println("Receiver: topicA ,我获取到消息："+message);
    }
    @RabbitListener(queues = "topicB") //监听队列topicB
    public void receive_queueBB( String message){
        System.out.println("Receiver: topicB,我获取到消息："+message);
    }
}

分别发送消息，测试成功。

 

 

芮呆萌061511332
关注
专栏目录
rabbitmq | rabbitTemplate的convertAndSend部分源码解析
weixin_43268715的博客
12-01 2556
在RabbitMQ中，事务是一种确保消息发送的可靠性的机制。Spring AMQP提供了对RabbitMQ事务的抽象，而作为Spring AMQP的核心组件，提供了许多简化消息发送的方法。在这篇博客中，我们将深入探讨RabbitMQ事务机制的源码实现，以及Spring封装的的使用。
工作中常用的RabbitMQ实践
m0_55627541的博客
12-07 1430
Topic类型:(当生产者往该交换机发送消息时，他并不像direct指定固定的routingkey，可以进行模糊匹配，当该routingkey为空时，他会匹配routingkey为空的队列)direct类型:(当生产者往该交换机发送消息时，他必须指定固定的routingkey，当routingkey值为空，他也会匹配routingkey为空的队列)fanout类型:(当生产者往该交换机发送消息时，他所绑定的队列都会收到消息，routingkey即使写了也会忽略，一般为空字符串)因此会打印出下面这条记录。
RabbitMQ笔记
普通还不自信的程序员
09-14 1279
文章目录一、引言二、RabbitMQ介绍三、RabbitMQ安装四、RabbitMQ架构【`重点`】4.1 官方的简单架构图4.2 RabbitMQ的完整架构图4.3 查看图形化界面并创建一个Virtual Host五、RabbitMQ的使用【`重点`】5.1 RabbitMQ的通讯方式5.2 Java连接RabbitMQ5.2.1 创建maven项目5.2.2 导入依赖5.2.3 创建工具类连接RabbitMQ5.3 Hello-World5.4 Work5.5 Publish/Subscribe5.6
RabbitMQ发送方确认机制
菜鸟逆袭之路
05-25 2029
RabbitMQ发送方确认机制
RabbitMQ使用
最新发布
qq_53573029的博客
03-01 1094
时效性较强，可以立即得到结果异步通信的优点：耦合度低吞吐量提示故障隔离流量削峰异步通讯的缺点：依赖于Broker的可靠性，安全性，吞吐能力架构复杂了，业务没有明显的流程线，不好追踪管理MQ（MessageQueue），中文解释是消息队列，字面来看就是存放消息的队列，也就是时间驱动架构中的Broker。安装RabbitMQ，参考课前资料-d \输入端口，输入密码，进入RabbitMQRabbitMQ中的几个概念：channel：操作MQ的工具exchange：路由消息到队列中。
rabbitmq学习笔记和软件和插件
05-05
**RabbitMQ学习笔记与软件插件详解** RabbitMQ是一种广泛应用的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议，提供可靠的消息传递服务。在分布式系统中，RabbitMQ扮演着数据交换中心的角色，...
rabbitMQ学习笔记
11-06
rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ...
RabbitMQ学习笔记
06-22
**RabbitMQ学习笔记** RabbitMQ是一款广泛应用的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议，能够实现在分布式系统中可靠的消息传递。RabbitMQ的核心功能是作为一个消息代理，允许应用程序...
rabbitMQ 学习笔记
12-27
**正文** ...通过以上的学习，你应该对RabbitMQ有了基本的理解，并掌握了在Java中使用RabbitMQ的基本方法。然而，实际应用中，还需要根据具体业务场景灵活运用和调整策略，以充分发挥RabbitMQ的优势。
RabbitMq学习笔记
01-15
RabbitMq是实现AMQP（高级消息队列协议）的消息中间件的一种，与Springboot整合后使用方便简单，功能强大。本文还列举了Springboot整合RabbitMq使用和原版对比、及一些坑，简单易懂。
RabbitMQ高级特性
qq_40432598的博客
03-11 639
RabbitMQ高级特性
《Spring Boot 实战派》--12.集成RabbitMQ,实现系统间的 数据交换
tumu6889的博客
05-28 3272
第12章集成RabbitMQ,实现系统间的数据交换 RabbitMQ是近年来使用非常广泛的消息中间件。 本章首先介绍它的原理、概念、6种工作模式、常用的注解； 然后用实例讲解在Spring Boot 中如何使用AmqpTemplate接口实现消息的发送和监听。 12.1认识RabbitMQ 12.1.1介绍RabbitMQ RabbitMQ 是开源的高级消息队列协议(Advanced Message Queueing Protocol, AMQP) 的实现，用Erlang语言编写，...
RabbitMQ消息持久化总结
weixiaohuai的博客
07-06 8935
一、简介 在RabbitMQ中，如果遇到RabbitMQ服务停止或者挂掉，那么我们的消息将会出现丢失的情况，为了在RabbitMQ服务重启的情况下，不丢失消息，我们可以将Exchange（交换机）、Queue（队列）与Message（消息）都设置为可持久化的（durable）。这样的话，能够保证绝大部分的消息不会被丢失，但是还有有一些小概率会发生消息丢失的情况。下面通过一个简单的示例总结在Rab...
RabbitMQ - Spring boot 整合
热门推荐
wanght笔记
03-12 2万+
文章目录新建项目pom.xmlapplication.yml主程序简单模式创建主类生产者消费者测试类工作模式主类生产者生产者消费者ack模式设置 ack 模式手动执行确认操作抓取数量 新建项目 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4...
RabbitMQ-SpringBoot-direct模式
qq_42438218的博客
11-05 513
图解目标：1. 生产者发送消息到RabbitMQ2. 消费者从RabbitMQ获取消息3. 消息过期时间TTL4. 死信队列5. 消息确认机制代码结构。
RocketMq灰皮书(三)------MQ使用
剑小纯的夜话白鹭
02-18 2609
RocketMq灰皮书(三)------MQ使用 在使用MQ之前,我们回顾一下前两篇博文的内容. 我们大致了解了RocketMQ的四个概念,分别是:Producer,Consumer,Message和Broker 我们在本地的Windows10系统上,部署了RocketMQ和其后台系统 在本篇博文中,我们会使用使用SpringBoot构建两个微服务,一个作为生产者,一个作为消费者,通过RocketMQ传递消息,了解在Java中使用RocketMQ的方法. 一. SpringBoot整合RocketMQ
消息机制-rabbitmq
明耀的博客
04-29 162
pom.xml <!-- rabbitmq--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId&gt...
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4694
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
springboot整合rabbitMq，java核心技术卷目录
m0_64867839的博客
12-17 1191
public static final String TEST_QUEUE_TO_TOPIC2 = “topic.message2”; /** 交换机（topic） */ public static final String TOPIC_EXCHANGE = “topic_exchange”; /** 路由key（topic） */ public static final String TOPIC_EXCHANGE_ROUTING_KEY = “topic.#”; } 一、普通消息： 1.创建普通队
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值