SpringBoot集成RabbitMQ基本使用

于 2023-09-05 18:41:38 发布
阅读量100 收藏
点赞数 1
文章标签： java-rabbitmq spring boot rabbitmq
洛柒
本文链接：https://blog.csdn.net/qq_53972833/article/details/132698152
版权

文章目录

1. 简单模式-无交换机(一个生产者、一个队列、一个消费者）

  • 加入maven依赖

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

  • 在 application.yml 中配置rabbitmq的 连接信息

    spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest

  • 列配置，启动时创建队列

    @Configuration
public class RabbitMqConfig {
    @Bean
    public Queue createQueue(){
        return new Queue("hello-queue");
    }
}

  • 创建生产者（可以卸载接口里面）

    @Component
public class Sender {
 
    @Autowired
    private AmqpTemplate amqpTemplate;
 
    public void send(String msg){
        this.amqpTemplate.convertAndSend("hello-queue",msg);
    }
}

  • 创建消费者

    @Component
public class Receiver {
 
    @RabbitListener(queues = "hello-queue")
    public void process(String msg){
        System.out.println("receiver: "+msg);
    }
}

    结果：控制台打印出消费者的log日志：receiver: rabbit-mq-test

2.发布订阅模式

  • 消息发送方：

    @RestController
public class RabbitMqController {
    @Autowired
    private RabbitTemplate rabbit;
    @RequestMapping("/rabbitmq/sendPublisher")
    public String sendPublisher(){
        for(int i=0;i<20;i++){
            rabbit.convertSendAndReceive("exchange_fanout","","测试发布订阅模式:"+i);
        }
        return "发送成功....";
    }
}

  • 定义交换机

    @Bean
public FanoutExchange exchangeFanout(){
    return new FanoutExchange("exchange_fanout");
}

  • 定义两个消费者，每个消费者都需要绑定这个交换机，定义的两个消费者也需要定义成Bean。并且和exchange_fanout进行绑定

    @Bean
public Queue queueFanout1(){
    return new Queue("queue_fanout1");
}
@Bean
public Queue queueFanout2(){
    return new Queue("queue_fanout2");
}
@Bean
public Binding bindingExchange1(Queue queueFanout1,FanoutExchange exchangeFanout){
    return BindingBuilder.bind(queueFanout1).to(exchangeFanout);
}
@Bean
public Binding bindingExchange2(Queue queueFanout2,FanoutExchange exchangeFanout){
    return BindingBuilder.bind(queueFanout2).to(exchangeFanout);
}

  • 通过RabbitListener的Rabbitmq的监听器来获取消息。

    @RabbitListener(queues="queue_fanout1")
public void receiverMsg1(String msg){
    System.out.println("队列1接收到的信息:"+msg);
}
@RabbitListener(queues="queue_fanout2")
public void receiverMsg2(String msg){
    System.out.println("队列2接收到的信息:"+msg);
}

整体监听器的代码如下：

  • package com.example.demo.listener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.context.annotation.Bean;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.TopicExchange;
@Slf4j
@Component
public class RabbitMqConsumer {
    @Bean
    public Queue queueFanout1(){
        return new Queue("queue_fanout1");
    }
    @Bean
    public Queue queueFanout2(){
        return new Queue("queue_fanout2");
    }
    @Bean
    public FanoutExchange exchangeFanout(){
        return new FanoutExchange("exchange_fanout");
    }
    @Bean
    public Binding bindingExchange1(Queue queueFanout1,FanoutExchange exchangeFanout){
        return BindingBuilder.bind(queueFanout1).to(exchangeFanout);
    }
    @Bean
    public Binding bindingExchange2(Queue queueFanout2,FanoutExchange exchangeFanout){
        return BindingBuilder.bind(queueFanout2).to(exchangeFanout);
    }
    @RabbitListener(queues="queue_fanout1")
    public void receiverMsg1(String msg){
        System.out.println("队列1接收到的信息:"+msg);
    }
    @RabbitListener(queues="queue_fanout2")
    public void receiverMsg2(String msg){
        System.out.println("队列2接收到的信息:"+msg);
    }
}

    启动服务后，当浏览器访问“/rabbitmq/sendPublisher”后，在浏览器中显示文字“发送成功”，在控制台输出队列1和队列2的相关信息。浏览器显示如下图:

    image-20230817112836619

可在控制台看到结果。

3. routing(direct)模式

  • 首先是配置类，在配置类中我们需要声明交换机，队列和绑定关系。

  • @Configuration
public class DirectExchangeConfig {
 
    public static final String DIRECT_QUEUE = "directQueue";
    public static final String DIRECT_QUEUE2 = "directQueue2";
    public static final String DIRECT_EXCHANGE = "directExchange";
    public static final String DIRECT_ROUTING_KEY = "direct";
 
    @Bean
    public Queue directQueue() {
        return new Queue(DIRECT_QUEUE, true);
    }
 
    @Bean
    public Queue directQueue2() {
        return new Queue(DIRECT_QUEUE2, true);
    }
 
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(DIRECT_EXCHANGE, true, false);
    }
 
    @Bean
    public Binding bindingDirectExchange(Queue directQueue, DirectExchange directExchange) {
        return BindingBuilder.bind(directQueue).to(directExchange).with(DIRECT_ROUTING_KEY);
    }
 
    @Bean
    public Binding bindingDirectExchange2(Queue directQueue2, DirectExchange directExchange) {
        return BindingBuilder.bind(directQueue2).to(directExchange).with(DIRECT_ROUTING_KEY);
    }
 
}

  • 生产者

    @RestController
@Slf4j
@RequestMapping("/direct")
public class DirectController {
 
    private final RabbitTemplate rabbitTemplate;
 
    public DirectController(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }
 
    /**
     * direct交换机为直连模式交换机
     *      根据消息携带的路由键将消息投递给对应队列
     *
     *
     * @return
     */
    @GetMapping("send")
    public Object sendMsg() {
        rabbitTemplate.convertAndSend(DirectExchangeConfig.DIRECT_EXCHANGE, DirectExchangeConfig.DIRECT_ROUTING_KEY, "发送一条测试消息：direct");
        return "direct消息发送成功！！";
    }
}

  • 消费者

    package com.lsqingfeng.action.rabbitmq.direct;
 
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
 
/**
 * @className: DirectQueueListener
 * @description: 直连交换机的监听器
 * @author: sh.Liu
 * @date: 2021-08-23 16:03
 */
@Slf4j
@Component
public class DirectQueueListener {
 
    /**
     * 尽管设置了两个消费者，但是只有一个能够消费成功
     * 多次发送则轮训消费：
     * DirectReceiver消费者收到消息1  : 发送一条测试消息：direct
     * DirectReceiver消费者收到消息2  : 发送一条测试消息：direct
     * DirectReceiver消费者收到消息1  : 发送一条测试消息：direct
     * DirectReceiver消费者收到消息2  : 发送一条测试消息：direct
     *
     * 一个交换机可以绑定多个队列。如果通过路由key可以匹配到多个队列，消费的时候也只能有一个进行消费
     * @param testMessage
     */
    @RabbitHandler
    @RabbitListener(queues = DirectExchangeConfig.DIRECT_QUEUE)
    public void process(String testMessage) {
        System.out.println("DirectReceiver消费者收到消息1  : " + testMessage);
    }
 
    @RabbitHandler
    @RabbitListener(queues = DirectExchangeConfig.DIRECT_QUEUE)
    public void process2(String testMessage) {
        System.out.println("DirectReceiver消费者收到消息2  : " + testMessage);
    }
 
    @RabbitHandler
    @RabbitListener(queues = DirectExchangeConfig.DIRECT_QUEUE2)
    public void process3(String testMessage) {
        System.out.println("DirectReceiver消费者收到消息3  : " + testMessage);
    }
 
}
4. topic模式

如上图，主题模式不能具有任意的 routingKey，必须由一个英文句点“.”分隔的字符串（分割符）

其中***表示任意多个单词，#**表示一个单词

package com.rabbitmq.util;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class rabbitMqUtil {
    @Bean(name = "okong")
    public Queue queue() {
        //创建一个消息队列
        return new Queue("topic.okong");
    }
    @Bean(name = "qune")
    public Queue qune() {
        //创建一个消息队列
        return new Queue("topic.qune");
    }
    @Bean
    TopicExchange topicExchange() {
        return new TopicExchange("topic");//配置路由器为Topic模式
    }

    @Bean
    Binding bindingExchangeA(@Qualifier("okong") Queue queue, TopicExchange topicExchange) {
        // 配置该消息队列的  routingKey 
        //topic.* 匹配 第一个.后面的单词    代表      一个    单词
        //比如 topic.asd 会被该消息队列接受 topic.asd.dsf不会被该消息队列接受
        return BindingBuilder.bind(queue).to(topicExchange).with("topic.*");
    }

    @Bean
    Binding bindingExchangeB(@Qualifier("qune") Queue qune, TopicExchange topicExchange) {
        // 配置该消息队列的  routingKey 
        //topic.# 匹配 所有.后面的单词     代表     任意    个      单词
        //比如 topic.asd 会被该消息队列接受 topic.asd.dsf也会被该消息队列接受
          return BindingBuilder.bind(qune).to(topicExchange).with("topic.#");
    }
}

  • 监听类：

    package com.rabbitmq.util;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ListenterQune {
    @RabbitListener(queues = "topic.qune")
    @RabbitHandler
    public void process(String mess){
        System.out.println("我是topic.qune的消费者接收到的消息为 ："+mess);
    }
    @RabbitListener(queues = "topic.okong")
    @RabbitHandler
    public void okong(String mess){
        System.out.println("我是topic.okong的消费者接收到的消息为："+mess);
    }
}

  • 发送方：

    @RequestMapping("sendTwo")
public void sendTwo(String mes){
    amqpTemplate.convertAndSend("topic","topic.name",mes);
    amqpTemplate.convertAndSend("topic","topic.a",mes);   
}

这个样发送两个队列都可以收到:

在这里插入图片描述

洛柒。
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
SpringBoot集成RabbitMQ延时队列，自定义延时时间Demo
09-16
该示例通过 rabbitmq_delayed_message_exchange 插件实现自定义延时时间的延时队列。 示例是纯净的，只引入了需要的架包 启动示例时，请确保MQ已经安装了延时插件(附件里带有插件及安装说明)以及示例的MQ相关的配置是否和你的环境一致 启动成功后访问 ip:port/mq/push(参数 msg 消息；delayTime 延时毫秒时间) 测试，在后端控制台中查看效果
rabbitmq基础+springboot集成rabbitmq
10-14
RabbitMQ基础知识，工作队列、发布订阅、路由模式、通配符模式 都有详细的demo，Springboot整合了RabbitMQ，使用Junit测试，详细的文档说明都有。
SpringBoot集成RabbitMQ的方法(死信队列)
08-26
主要介绍了SpringBoot集成RabbitMQ的方法(死信队列)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
SpringBoot集成Rabbitmq简单案例
最新发布
03-15
SpringBoot集成Rabbitmq简单案例
Springboot整合RabbitMq，详细使用步骤
朱大虾
08-13 3657
消息队列（Message Queue）是一种应用间的通信方式。顾名思义，将消息放到队列中，排队发出。消息发布者只管把消息发布到MQ中而不用管谁来取，消息使用者只管从 MQ 中取消息而不管是谁发布的。这样发布者和使用者都不用知道对方的存在。 而且消息队列一般有完整的接收确认，发布消息回调等一系列机制，可以确保接收方一定能接受。用到的场景如：异步处理，应用解耦，流量削锋和消息通讯。可以直接在java代码中通过注入实体类的方式创建交换机及队列等设备。但此方式添加的’设备‘是懒加载的形式，只要当使用到识别到监听注解
Springboot项目整合Rabbitmq详细教程
洛阳泰山的博客
10-13 2405
首先在springboot的pom文件里引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 然后application.yml： ps：里面的虚拟host配置项不是必须的，我自己在rabbitmq服务上创建了自己的虚拟host
SpringBoot 集成 RabbitMQ（上）
sco5282的博客
09-26 1685
接下来使用 SpringBoot 来集成 RabbitMQ 1. 简单模式
SpringBoot使用RabbitMQ消息队列
热门推荐
lizc_lizc的博客
06-18 1万+
RabbitMQ简介RabbitMQ基本概念SpringBoot整合RabbitMQ在 pom.xml 中添加 spring-boot-starter-amqp的依赖        &lt;dependencies&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;a...
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4454
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
springboot整合rabbitMQ系列（五）topics模型，这个是既有路由键，也使用通配符
一天不写代码难受的博客
10-23 228
这个是第五个模式 发送者 @Test void testTopics() { //使用rabbitmq直接往队列里面放数据 // convertAndSend（）第一个参数 是 rabbitTemplate.convertAndSend("topics","user.save","基于这个user.save路由键的消息"); } 这个是发送给名字为topics的交换机，路由键是user.save ，发送的消息是 ： 基于这个user.sa.
springboot 使用注解的方式创建rabbitmq的交换机、路由key、以及监听队列的名称
知道的越多 不知道的就越多
09-28 2402
maven依赖： <!--rabbitmq--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> rabbitmq yml文件配置： #配置rabb
Springboot 整合RabbitMQ（四）：路由（Routing）
weixin_45821812的博客
03-06 1747
在本文中，我们将实现另一个功能 —— 只订阅一部分消息。例如，我们只需要把严重的错误日志信息写入日志文件（存储到磁盘），但同时仍然把所有的日志信息输出到控制台中 绑定（Binding） 在之前的例子中，我们已经创建了绑定。可以在我们的 Tut3Config 文件中回忆一下这样的代码： @Bean public Binding binding1(FanoutExchange fanout, Queu...
springboot中使用rabbitmq
weixin_42223524的博客
03-22 348
交换机的功能主要是接收消息并且转发到绑定的队列，交换机不存储消息，在启用 ack模式后，交换机找不到队列会返回错误。Fanout Exchange 消息广播的模式，不管路由键或者是路由模式，会把消息发给绑定给它的。定义一种路由模式，那么，通配符就要在这种路由模式和路由键之间匹配后交换机才能转发。的交换机模式，也是最简单的模式，根据 key 全文匹配去寻找队列。Fanout Exchange 广播者模式或者订阅者模式。在这种交换机下，队列和交换机的绑定会。消费者模式和简单模式一致。消费者和简单模式一致。
SpringBoot整合RabbitMQ（超详细）
海的那边，还是海吗
09-06 1958
创建交换机方法：ExchangeBuilder.交换机类型（交换机名字）.是否持久化，是否自动删除。BindingBuilder.bind(交换机名字).to(队列名字).with(路由K)消息的整个过程：消息先发送到交换机----交换机通过路口K发送到对应的队列里面去。发送消息方法:convertAndSend(交换机名字，路由K，消息内容)1、消息确认模式，消息发送到交换机时会返回回调函数（成功还是失败）2、退回模式，交换机发送给队列，只有失败时会触发。注入RabbitTemplate。
RabbitMQ与SpringBoot整合详解
vanGogh的博客
11-17 5925
一、前言   本文章总体简介，会采用Docker下载安装RabbitMQ，详细介绍RabbitMQ优缺点及其相关技术知识点，SpringBoot作为整合学习的基础架构。看完本片文章，你会了解消息队列RabbitMQ，你会使用消息队列RabbitMQ。 二、消息队列   当第一次出现在我脑中这个词语时，我会问自己什么时消息队列？我做的项目为什么没有消息队列？我做的项目可以用消息队列么？如果可以用消息队列这要怎么使用消息队列？消息队列能解决项目什么问题？等等问题会出现在我的脑海…，然而我将会在面文章中对自己慢慢
Springboot集成RocketMQ——简单使用
tang_seven的博客
08-25 2557
Springboot集成RocketMQ，进行简单使用
mq的面试题 20200908
yuzepeng11的博客
09-08 412
1、如何使用 ActiveMQ 解决分布式事务？ 在互联网应用中，基本都会有用户注册的功能。在注册的同时，我们会做出如下操作： 1. 收集用户录入信息，保存到数据库 2. 向用户的手机或邮箱发送验证码 等等… 如果是传统的集中式架构，实现这个功能非常简单：开启一个本地事务，往本地数据库中插入一条用户数据，发送 验证码，提交事物。 但是在分布式架构中，用户和发送验证码是两个独立的服务，它们都有各自的数据库，那么就不能通过本地事物 保证操作的原子性...
springboot rabbitmq使用 springboot rabbitmq使用 springboot集成rabbitmq一对多
07-09
Spring Boot集成RabbitMQ可以通过以下步骤完成： 1. 添加Maven依赖：在pom.xml文件中添加RabbitMQ的Spring Boot Starter依赖。 ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 2. 配置RabbitMQ连接信息：在application.properties（或application.yml）文件中配置RabbitMQ的连接信息。 ```properties spring.rabbitmq.host=your_rabbitmq_host spring.rabbitmq.port=your_rabbitmq_port spring.rabbitmq.username=your_rabbitmq_username spring.rabbitmq.password=your_rabbitmq_password ``` 3. 创建RabbitMQ发送者：创建一个发送消息的类，使用`RabbitTemplate`发送消息到指定的交换机和队列。 ```java import org.springframework.amqp.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class RabbitMQSender { @Autowired private RabbitTemplate rabbitTemplate; public void sendMessage(String exchange, String routingKey, Object message) { rabbitTemplate.convertAndSend(exchange, routingKey, message); } } ``` 4. 创建RabbitMQ接收者：创建一个接收消息的类，使用`@RabbitListener`注解监听指定的队列，处理接收到的消息。 ```java import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component public class RabbitMQReceiver { @RabbitListener(queues = "your_queue_name") public void receiveMessage(Object message) { // 处理接收到的消息 System.out.println("Received message: " + message.toString()); } } ``` 5. 发送和接收消息：在需要发送或接收消息的地方调用对应的方法。 ```java @Autowired private RabbitMQSender rabbitMQSender; public void sendMessage() { rabbitMQSender.sendMessage("your_exchange_name", "your_routing_key", "Hello, RabbitMQ!"); } ``` 以上是基本的使用方式，你可以根据实际需求进行扩展和配置。注意，你还需要安装并启动RabbitMQ服务。 希望对你有所帮助！如果有任何疑问，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值