SpringBoot使用RabbitMQ

最新推荐文章于 2024-05-20 18:48:59 发布
置顶 最新推荐文章于 2024-05-20 18:48:59 发布
阅读量252 收藏 2
点赞数 1
分类专栏： JAVA RabbitMQ 文章标签： springboot rabbitmq java 消息对应
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43835717/article/details/91902876
版权

消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构使用较多的消息队列有ActiveMQ，RabbitMQ，Kafka，RocketMQ等，这里主要讲解RabbitMQ的简单使用

一、 创建SpringBoot项目，并引入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

二、 Queue方式

1、 定义配置类

/**
 * @author Gjing
 **/
@Configuration
public class RabbitMqConfiguration {

    /**
     * 声明一个名为simple的队列
     */
    @Bean
    public Queue testQueue() {
        return new Queue("simple");
    }
}

2、声明一个生产者

/**
 * @author Gjing
 **/
@Component
public class Producer {

    @Resource
    private AmqpTemplate rabbitTemplate;

    public void send() {
        String message = "hello";
        this.rabbitTemplate.convertAndSend("simple", message);
    }
}

3、声明消费者

/**
 * @author Gjing
 **/
@Slf4j
@Component
public class Consumer {

    @RabbitListener(queues = "simple")
    public void receive(String message) {
        log.info("消费者1收到消息：{}", message);
    }
}

4、创建Controller进行调用

/**
 * @author Gjing
 **/
@RestController
public class DemoController {

    @Resource
    private Producer producer;

    @PostMapping("/message")
    public void send() {
        for (int i = 0; i < 10; i++) {
            this.producer.send();
        }
    }
}

三、 topic exchange方式

1、定义配置类

/**
 * @author Gjing
 **/
@Configuration
public class RabbitMqConfiguration {

    /**
     * 声明一个名为topic.message1的队列
     */
    @Bean
    public Queue topicQueue() {
        return new Queue("topic.message1");
    }

    /**
     * 声明一个名为topic.message2的队列
     */
    @Bean
    public Queue topicQueue2() {
        return new Queue("topic.message2");
    }

    /**
     * 声明一个名为exchange的交换机
     */
    @Bean
    public TopicExchange exchange() {
        return new TopicExchange("exchange");
    }

    /**
     * 将topic.message1的队列绑定到exchange交换机
     */
    @Bean
    public Binding bindMessage1() {
        return BindingBuilder.bind(topicQueue()).to(exchange()).with("topic.message1");
    }

    /**
     * 将topic.message2的队列绑定到exchange交换机
     */
    @Bean
    public Binding bindMessage2() {
        return BindingBuilder.bind(topicQueue2()).to(exchange()).with("topic.message2");
    }
}

2、定义生产者

/**
 * @author Gjing
 **/
@Component
public class TopicProducer {

    @Resource
    private AmqpTemplate rabbitTemplate;

    public void send() {
        String message1 = "I am topic.message1";
        String message2 = "I am topic.message2";
        this.rabbitTemplate.convertAndSend("exchange", "topic.message1", message1);
        this.rabbitTemplate.convertAndSend("exchange", "topic.message2", message2);
    }
}

3、定义消费者1

/**
 * @author Gjing
 **/
@Component
@Slf4j
public class TopicConsumer1 {

    @RabbitListener(queues = "topic.message1")
    public void receive(String message) {
        log.info("消费者1收到消息：{}", message);
    }
}

4、定义消费者2

/**
 * @author Gjing
 **/
@Component
@Slf4j
public class TopicConusmer2 {
    @RabbitListener(queues = "topic.message2")
    public void receive(String message) {
        log.info("消费者2收到消息：{}", message);
    }
}

5、创建controller进行调用

/**
 * @author Gjing
 **/
@RestController
public class TopicController {
    @Resource
    private TopicProducer topicProducer;

    @PostMapping("/message-topic")
    public void sendMessageTopic() {
        for (int i = 0; i < 10; i++) {
            this.topicProducer.send();
        }
    }
}

四、fanout方式

1、定义配置类

/**
 * @author Gjing
 **/
@Configuration
public class RabbitMqConfiguration {
    
    /**
     * 声明一个名为fanout.1的队列
     */
    @Bean
    public Queue fanoutQueue1() {
        return new Queue("fanout.1");
    }
    /**
     * 声明一个名为fanout.2的队列
     */
    @Bean
    public Queue fanoutQueue2() {
        return new Queue("fanout.2");
    }
    /**
     * 声明一个名为fanout.3的队列
     */
    @Bean
    public Queue fanoutQueue3() {
        return new Queue("fanout.3");
    }

    /**
     * 声明一个名为fanoutExchange的转发器
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    /**
     * 将队列fanoutQueue1绑定到fanout转发器
     */
    @Bean
    public Binding bindFanout1() {
        return BindingBuilder.bind(fanoutQueue1()).to(fanoutExchange());
    }

    /**
     * 将队列fanoutQueue1绑定到fanout转发器
     */
    @Bean
    public Binding bindFanout2() {
        return BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange());
    }

    /**
     * 将队列fanoutQueue1绑定到fanout转发器
     */
    @Bean
    public Binding bindFanout3() {
        return BindingBuilder.bind(fanoutQueue3()).to(fanoutExchange());
    }
}

2、定义生产者

/**
 * @author Gjing
 **/
@Component
public class FanoutProducer {
    @Resource
    private AmqpTemplate amqpTemplate;

    public void send() {
        String message = "hello, I am speaker";
        //这里的routingKey会被rabbitMQ忽略，如果不设置这个参数会导致发送消息失败,
        //所以这里随便写（我给他空字符串），rabbitMQ会默认发给所有绑定的
        this.amqpTemplate.convertAndSend("fanoutExchange","", message);
    }
}

3、定义消费者1

/**
 * @author Gjing
 **/
@Component
@Slf4j
public class FanoutConsumer1 {

    @RabbitListener(queues = "fanout.1")
    public void receive(String message) {
        log.info("消费者1收到消息：{}", message);
    }
}

4、定义消费者2

/**
 * @author Gjing
 **/
@Component
@Slf4j
public class FanoutConsumer2 {
    @RabbitListener(queues = "fanout.2")
    public void receive(String message) {
        log.info("消费者2收到消息：{}", message);
    }
}

5、定义消费者3

/**
 * @author Gjing
 **/
@Component
@Slf4j
public class FanoutConsumer3 {
    @RabbitListener(queues = "fanout.3")
    public void receive(String message) {
        log.info("消费者3收到消息：{}", message);
    }
}

6、创建controller调用

/**
 * @author Gjing
 **/
@RestController
public class FanoutController {
    @Resource
    private FanoutProducer fanoutProducer;

    @PostMapping("/message-fanout")
    public void sendFanout() {
        this.fanoutProducer.send();
    }
}

五、RabbitMQ核心概念

server：又称Broker，接受客户端的连接实现AMQP实体服务；connection：与broker的连接；channel：网络通道，几乎所有的操作都是在channel中进行；message：服务器和应用程序之间传送的数据，由properties和body组成，properties可以对消息进行修饰，比如消息的优先级和高级特性， body为消息的内容；exchange：交换机，接收消息，根据路邮件转发消息到绑定的队列；binding：exchange和queue之间的虚拟连接，可以包含routing key；Routing key：一个路由规则，虚拟机用他确定如何路由一个特定信息；Queue：也称为message Queue，消息队列，保存信息并将它们转发给消费者。

Exchange类型：

  • Fanout：路由规则是把所有发送到该Exchange的消息路由到所有与她绑定的Queue中
    在这里插入图片描述
    备注: 生产者P生产消息1推送到Exchange，由于Exchange Type=fanout这时候会遵循fanout的规则将消息推送到所有与他绑定的Queue。
  • direct：把消息路由到那些binding key与routing key完全匹配的Queue中。
    在这里插入图片描述
    备注：生产者P发送消息时Routing key = bloking时，这时候将消息传送到Exchange，Exchange获取到生产者发送过来的消息后，会根据自身的规则进行与匹配响应的Queue，这时候发现Queue1和Queue2都符合，就会将消息传送给这两个队列，如果我们以Routing key = create和routing key = confirm发送消息时，这时候消息只会被推送到Queue2队列中，其他的Routing key 的消息会被丢弃。
  • topic：模糊匹配，通过通配符满足一部分规则就可以传送，其中注意的是有两个字符 ’ * ’和 ‘ # ’，其中 ‘ * ’用于匹配一个单词，’ # ’用于匹配多个单词（可以是0个）
    在这里插入图片描述
    备注：当生产者发送消息Routing Key=F.C.E的时候，这时候只满足Queue1，所以会被路由到Queue中，如果Routing Key=A.C.E这时候会被同是路由到Queue1和Queue2中，如果Routing Key=A.F.B时，这里只会发送一条消息到Queue2中。

常见面试题

  • 什么是元数据？元数据分为哪些类型？包括哪些内容？与cluster相关的元数据有哪些？元数据是如何保存的？元数据在cluster中是如何分布的？

在非cluster模式中，元数据主要分为Queue元数据（Queue名字和属性等）、Exchange元数据（Exchange名字、类型、属性等）、binding元数据（存放路由关系的查找表）、vhost元数据（vhost范围内针对前三者的名字空间约束和安全属性设置）。在cluster模式下，包括cluster中node位置信息和node关系信息。元数据按照erlang node的类型确定是仅保存于RAM中，还是同时保存在RAM或者Disk上，元数据在cluster中是全node分布的

  • rabbitmq的一个Queue中存放的message是否有数量限制？

可以认为无限制，限制取决于机器的内存，但是消息过多会导致处理效率的下降。

  • rabbitmq如何实现延迟队列？

没有直接支持延迟队列功能，但是可以通过两个特性来实现延迟队列，①TTL：通过队列属性设置，队列中的所有消息都有相同的过期时间、对消息进行单独设置，每条消息TTL可以不同。如果同时使用，则消息的过期时间以两者之间TTL较小的那个数值为准，消息在队列的生存时间一旦超过设置的TTL值，就称为dead letter。②DLX：Queue可以配置X-dead-letter-exchange和x-dead-letter-routing-key(可选)两个参数，如果队列内出现了dead letter，则按照这两个参数重新路由转发到指定的队列。

  • X-dead-letter-exchange：出现dead letter之后将dead letter重新发送到指定exchange
  • 出现dead letter之后将dead letter重新按照指定的routing-key发送
    • 出现dead letter的情况有：
      1. 消息或者队列的TTL过期; 2. 队列达到最大长度; 3. 消息被消费者拒绝

以上为个人见解，如有误欢迎各位指正

阿靖哦
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在SpringBoot中使用RabbitMQ
好记性不如烂笔头
07-28 512
开始之前 RabbitMQ涉及的重要的概念 Channel 信道。消息的读写操作在信道中进行，客户端可以建立多个信道，每个信道代表一个会话。 Message 消息。应用程序和MQ服务之间传送的数据，消息可以非常简单，也可以很复杂。有Properties和body组成。Properties为外包装，可以对消息进行修饰，比如消息的优先级、延迟等高级特性；body就是消息体内容。 Exchange 交换器,一个MQ服务器可以有一个或多个交换器。应用程序通过交换器，按照一定路由规则将消
SpringBoot整合RabbitMQ
听雪楼
12-31 1235
Producer配置 publisher-confirms, 实现一个监听器用于监听Broker端给我们返回的确认请求 : RabbitTemplate.ConfirmCallback publisher-returns, 保证消息对Broker端是可达的, 如果出现路由键不可达的情况, 则使用监听器对不可达的消息进行后续的处理, 保证消息的路由成功 : RabbitTemplate.Retur...
Spring Boot 实现 RabbitMQ 监听消息的几种方式
最新发布
ttyy1112的专栏
05-20 1305
通过在方法上标记注解来监听指定的队列，当消息到达时，被注解的方法将被调用。：实现 Spring AMQP 提供的接口，编写自定义的消息监听器，然后使用设置消息监听器。：通过类，可以将普通的 Java 方法转换为消息监听器，从而简化消息处理逻辑。：结合和注解，可以实现多个不同类型消息的处理方法，根据消息内容的不同调用对应的处理方法。这些方式都可以在 Spring Boot 项目中方便地实现 RabbitMQ 的消息监听功能。
RabbitMQ 浅析
Darklovy
06-05 555
转载自：https://www.cnblogs.com/ityouknow/p/6120544.html RabbitMQ 是一个由 Erlang 语言开发的 AMQP（高级消息队列协议） 的开源实现。它主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲、消息分发的作用。 AMQP AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是...
Spring Boot中使用RabbitMQ
JavaAlliance
07-08 4393
Message Broker与AMQP简介 Message Broker是一种消息验证、传输、路由的架构模式，其设计目标主要应用于下面这些场景： 消息路由到一个或多个目的地 消息转化为其他的表现方式 执行消息的聚集、消息的分解，并将结果发送到他们的目的地，然后重新组合成相应的结果返回给消息用户 调用Web服务来检索数据 响应事件或错误 使用发布-订阅模式来提供内容或基于主题的消息路由 AMQP...
在SpringBoot中对RabbitMQ三种使用方式
有趣的灵魂万里挑一,好看的皮囊你又没有
07-08 4745
在SpringBoot三种创建RabbitMQ的队列和消息的方式
springboot使用rabbitmq工具类
03-29
springboot使用rabbitmq工具类,里面包含比较原生的方法,还有一套是我结合springboot框架写的一套方法,里面有两个方法,看情况使用,一般使用框架的方法比较好,因为框架方法时前辈们封装好经过检验的没有问题的方法,...
SpringBoot之RabbitMQ的使用方法
08-26
SpringBoot之RabbitMQ的使用方法 RabbitMQ是消息中间件的一种，消息中间件即分布式系统中完成消息的发送和接收的基础软件，消息中间件的工作过程可以用生产者消费者模型来表示。即，生产者不断的向消息队列发送信息...
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
05-27
在这个项目"springboot-rabbitMQ-websocket"中，我们将探讨如何将这三个技术整合起来，实现高效的数据发布和实时接收。 首先，Spring Boot整合RabbitMQ主要涉及以下几个步骤： 1. **添加依赖**：在项目中，我们...
springboot+rabbitmq
03-21
在本项目中，`springboot-rabbitmq`目录下包含了实现三种不同模式的代码： 1. 队列模式（Queue Mode）：在RabbitMQ中，队列是消息的接收者。生产者将消息发送到队列，而消费者从队列中接收和处理消息。队列模式是最...
Spring Boot 中使用 RabbitMQ
good7ob的博客
07-31 1666
通过本文的介绍，你已经学习了如何在 Spring Boot 中使用 RabbitMQ 实现异步消息的发送和接收。你了解了如何配置 RabbitMQ 连接信息，并使用 Spring Boot 提供的和注解进行消息的发送和接收。通过实际的案例，我们展示了如何使用 RabbitMQ 实现任务队列，以邮件发送服务为例。你学习了如何创建消息发送者和消息接收者，并使用队列来实现任务的异步处理。使用 RabbitMQ 可以帮助我们实现解耦和异步处理，提高系统的可靠性和性能。
Springboot初步使用RabbitMQ
热门推荐
Ron_的博客
01-29 1万+
RabbitMQ消息队列 1.2.消息队列（MQ） 1.2.1.什么是消息队列 解耦、削峰填谷、异步 消息队列，即MQ，Message Queue。 消息队列是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。 结合前面所说的问题： 商品服务对商品增删改以后，无需去操作索引库或静态页面，只是发送一条消息，也不关心消息被谁接收。 搜索服务服务接收消息，去处
springboot rabbitmq 的使用
bings_l的博客
08-16 998
目录 1、rabbitMQ 2、rabbitMQ的下载和安装 3、使用场景 3.1 异步处理 3.2 应用解耦 3.3 流量削峰 3.4 定时任务 4、rabbitmq管理界面 5、六种队列 5.1 简单队列(hello world) 5.2 工作队列(work queue) 5.3 发布/订阅队列(publish/subscribe) 5.4 路由队列(routing) 5.5 通配符队列(Topics) 5.6 远程通信队列（rpc） 1、rabbitMQ rabbit
rabbitMQ学习笔记(八)——应用场景
sam的博客
05-11 416
MQ的应用场景 1 异步处理 场景说明：用户注册后，需要发注册邮件和注册短信,传统的做法有两种 1.串行的方式 2.并行的方式 串行方式: 将注册信息写入数据库后,发送注册邮件,再发送注册短信,以上三个任务全部完成后才返回给客户端。 这有一个问题是,邮件,短信并不是必须的,它只是一个通知,而这种做法让客户端等待没有必要等待的东西. 并行方式:将注册信息写入数据库后,发送邮件的同时,发送短信,以上三个任务完成后,返回给客户端,并行的方式能提高处理的时间。 消息队列:假设三个业务节点分别使用50
Spring Boot项目使用RabbitMQ队列
play_big_knife的博客
12-20 3288
Spring Boot项目中使用Rabbitmq做为消息队列。消费队列可以实现生产者和消费者之间的和谐通信。
springboot 使用rabbitmq
08-26
要在Spring Boot中使用RabbitMQ，首先需要添加相应的依赖。在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 接下来，你需要在application.properties（或application.yml）文件中配置RabbitMQ连接信息，例如： ```properties spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest ``` 然后，你可以创建一个生产者和一个消费者来发送和接收消息。 对于生产者，你可以使用RabbitTemplate类发送消息。例如，创建一个名为`MessageProducer`的类，并注入`RabbitTemplate`： ```java import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class MessageProducer { private final RabbitTemplate rabbitTemplate; @Autowired public MessageProducer(RabbitTemplate rabbitTemplate) { this.rabbitTemplate = rabbitTemplate; } public void sendMessage(String message) { rabbitTemplate.convertAndSend("myExchange", "myRoutingKey", message); } } ``` 对于消费者，你可以创建一个消息处理器来处理接收到的消息。例如，创建一个名为`MessageConsumer`的类，并使用`@RabbitListener`注解指定监听的队列： ```java import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component public class MessageConsumer { @RabbitListener(queues = "myQueue") public void handleMessage(String message) { System.out.println("Received message: " + message); // 处理消息 } } ``` 需要注意的是，你还需要在启动类上添加`@EnableRabbit`注解来启用RabbitMQ相关功能。 这是一个简单的使用RabbitMQ的Spring Boot示例。根据你的需求，你可以进一步配置交换机和队列等属性，以及处理更复杂的消息场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值