【RabbitMQ】SpringBoot整合RabbitMQ

于 2024-08-16 15:15:00 发布
阅读量212 收藏 4
点赞数 3
分类专栏： RabbitMQ 文章标签： rabbitmq spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/p_fly/article/details/141228980
版权

对于RabbitMQ的开发,Spring方法提供了更为方便的操作.

Spring官网介绍: Spring AMQP

RabbitMQ官网介绍: RabbitMQ tutorial - "Hello World!" | RabbitMQ

引入依赖

为了方便测试也引入SpringWeb依赖.

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
  </dependencies>

添加配置

#配置RabbitMQ的基本信息
spring:
  rabbitmq:
    host:  # IP地址
    port: 5672 #端口号 默认5672
    username:  #用户名
    password:  #密码
    virtual-host: #虚拟主机
    # 以上写法也可以整合成下面这种写法
    # addresses: amqp://用户名:密码@IP地址:端口号/虚拟主机

工作模式代码

相关常量

public class Constants {
    //工作队列模式
    public static final String WORK_QUEUE = "work.queue";
}

相关配置

import com.example.rabbitmqspringboot.constant.Constants;
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 RabbitMQConfig {
    // 工作队列模式
    // 工作队列交给Spring管理
    @Bean("workQueue")
    public Queue workQueue(){
        return QueueBuilder.durable(Constants.WORK_QUEUE).build();
    }
}

生产者

import com.example.rabbitmqspringboot.constant.Constants;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RequestMapping("/producer")
@RestController
public class ProducerController {
    // 引入RabbitTemplate 这是Spring Boot提供的RabbitMQ客户端相关操作
    @Autowired
    private RabbitTemplate rabbitTemplate;

    // 工作模式的生产者代码
    @RequestMapping("/work")
    public String work(){
        for (int i = 0; i < 10; i++) {
            //使用内置交换机, RoutingKey 和队列名称一致
            rabbitTemplate.convertAndSend("", Constants.WORK_QUEUE, "hello spring amqp: work..."+i);
        }

        return "发送成功";
    }
}

消费者

import com.example.rabbitmqspringboot.constant.Constants;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class WorkListener {

    /**
     * RabbitListener是 Spring 框架中用于监听 RabbitMQ 队列的注解。
     * 通过使用这个注解，可以定义一个方法，以便从 RabbitMQ 队列中接收消息。
     * 该注解支持多种参数类型，这些参数类型代表了从 RabbitMQ 接收到的消息和相关信息。
     *
     * 以下是一些常用的参数类型：
     * String：返回消息的内容。
     * Message (org.springframework.amqp.core.Message)：Spring AMQP 的 Message 类，返回原始的消息体以及消息的属性，如消息 ID、内容、队列信息等。
     * Channel (com.rabbitmq.client.Channel)：RabbitMQ 的通道对象，可以用于进行更高级的操作，如手动确认消息。
     */

    // 监听队列
    // 通常来说@RabbitListener注解是放到类上的，表示这个类作为一个消费者
    // 这里为了方便，将监听队列放到方法上，表示这个方法是一个消费者。所以这里有两个消费者
    @RabbitListener(queues = Constants.WORK_QUEUE)
    public void queueListener1(Message message, Channel channel){
        System.out.println("listener 1 ["+Constants.WORK_QUEUE+"] 接收到消息:" +message + ",channel:"+channel);
    }

    @RabbitListener(queues = Constants.WORK_QUEUE)
    public void queueListener2(String message){
        System.out.println("listener 2 ["+Constants.WORK_QUEUE+"] 接收到消息:" +message);
    }
}

结果

其他工作模式整合

以下代码整合发布/订阅模式, 路由模式和通配符模式

相关常量

public class Constants {
    //工作队列模式
    public static final String WORK_QUEUE = "work.queue";

    //发布订阅模式
    public static final String FANOUT_QUEUE1 = "fanout.queue1";
    public static final String FANOUT_QUEUE2 = "fanout.queue2";
    public static final String FANOUT_EXCHANGE = "fanout.exchange";

    //路由模式
    public static final String DIRECT_QUEUE1 = "direct.queue1";
    public static final String DIRECT_QUEUE2 = "direct.queue2";
    public static final String DIRECT_EXCHANGE = "direct.exchange";

    //通配符模式
    public static final String TOPIC_QUEUE1 = "topic.queue1";
    public static final String TOPIC_QUEUE2 = "topic.queue2";
    public static final String TOPIC_EXCHANGE = "topic.exchange";
}

相关配置

import com.example.rabbitmqspringboot.constant.Constants;
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 RabbitMQConfig {
    // 工作队列模式
    // 工作队列交给Spring管理
    @Bean("workQueue")
    public Queue workQueue(){
        return QueueBuilder.durable(Constants.WORK_QUEUE).build();
    }

    // 发布订阅模式
    // 创建队列 创建交换机 绑定队列和交换机
    @Bean("fanoutQueue1")
    public Queue fanoutQueue1(){
        return QueueBuilder.durable(Constants.FANOUT_QUEUE1).build();
    }

    @Bean("fanoutQueue2")
    public Queue fanoutQueue2(){
        return QueueBuilder.durable(Constants.FANOUT_QUEUE2).build();
    }
    @Bean("fanoutExchange")
    public FanoutExchange fanoutExchange(){
        return ExchangeBuilder.fanoutExchange(Constants.FANOUT_EXCHANGE).durable(true).build();
    }
    @Bean("fanoutQueueBinding1")
    public Binding fanoutQueueBinding1(@Qualifier("fanoutExchange") FanoutExchange fanoutExchange, @Qualifier("fanoutQueue1") Queue queue){
        return BindingBuilder.bind(queue).to(fanoutExchange);
    }
    @Bean("fanoutQueueBinding2")
    public Binding fanoutQueueBinding2(@Qualifier("fanoutExchange") FanoutExchange fanoutExchange, @Qualifier("fanoutQueue2") Queue queue){
        return BindingBuilder.bind(queue).to(fanoutExchange);
    }

    //路由模式
    // 队列1 和 交换机 绑定，路由键为orange
    // 队列2 和 交换机 绑定，路由键为black
    // 队列2 和 交换机 绑定，路由键为orange
    @Bean("directQueue1")
    public Queue directQueue1(){
        return QueueBuilder.durable(Constants.DIRECT_QUEUE1).build();
    }
    @Bean("directQueue2")
    public Queue directQueue2(){
        return QueueBuilder.durable(Constants.DIRECT_QUEUE2).build();
    }
    @Bean("directExchange")
    public DirectExchange directExchange(){
        return ExchangeBuilder.directExchange(Constants.DIRECT_EXCHANGE).durable(true).build();
    }
    @Bean("directQueueBinding1")
    public Binding directQueueBinding1(@Qualifier("directExchange") DirectExchange directExchange, @Qualifier("directQueue1") Queue queue){
        return BindingBuilder.bind(queue).to(directExchange).with("orange");
    }

    @Bean("directQueueBinding2")
    public Binding directQueueBinding2(@Qualifier("directExchange") DirectExchange directExchange, @Qualifier("directQueue2") Queue queue){
        return BindingBuilder.bind(queue).to(directExchange).with("black");
    }
    @Bean("directQueueBinding3")
    public Binding directQueueBinding3(@Qualifier("directExchange") DirectExchange directExchange, @Qualifier("directQueue2") Queue queue){
        return BindingBuilder.bind(queue).to(directExchange).with("orange");
    }

    //通配符模式
    // 队列1 和 交换机 绑定，路由键为 *.orange.*
    // 队列2 和 交换机 绑定，路由键为 *.*.rabbit
    // 队列2 和 交换机 绑定，路由键为 lazy.#
    @Bean("topicQueue1")
    public Queue topicQueue1(){
        return QueueBuilder.durable(Constants.TOPIC_QUEUE1).build();
    }
    @Bean("topicQueue2")
    public Queue topicQueue2(){
        return QueueBuilder.durable(Constants.TOPIC_QUEUE2).build();
    }
    @Bean("topicExchange")
    public TopicExchange topicExchange(){
        return ExchangeBuilder.topicExchange(Constants.TOPIC_EXCHANGE).durable(true).build();
    }

    @Bean("topicQueueBinding1")
    public Binding topicQueueBinding1(@Qualifier("topicExchange") TopicExchange topicExchange, @Qualifier("topicQueue1") Queue queue){
        return BindingBuilder.bind(queue).to(topicExchange).with("*.orange.*");
    }
    @Bean("topicQueueBinding2")
    public Binding topicQueueBinding2(@Qualifier("topicExchange") TopicExchange topicExchange, @Qualifier("topicQueue2") Queue queue){
        return BindingBuilder.bind(queue).to(topicExchange).with("*.*.rabbit");
    }
    @Bean("topicQueueBinding3")
    public Binding topicQueueBinding3(@Qualifier("topicExchange") TopicExchange topicExchange, @Qualifier("topicQueue2") Queue queue){
        return BindingBuilder.bind(queue).to(topicExchange).with("lazy.#");
    }
}

生产者

import com.example.rabbitmqspringboot.constant.Constants;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RequestMapping("/producer")
@RestController
public class ProducerController {
    // 引入RabbitTemplate 这是Spring Boot提供的RabbitMQ客户端相关操作
    @Autowired
    private RabbitTemplate rabbitTemplate;

    // 工作模式的生产者代码
    @RequestMapping("/work")
    public String work(){
        for (int i = 0; i < 10; i++) {
            //使用内置交换机, RoutingKey 和队列名称一致
            rabbitTemplate.convertAndSend("", Constants.WORK_QUEUE, "hello spring amqp: work..."+i);
        }
        return "发送成功";
    }

    @RequestMapping("/fanout")
    public String fanout(){
        rabbitTemplate.convertAndSend(Constants.FANOUT_EXCHANGE,"", "hello spring amqp:fanout...");
        return "发送成功";
    }

    // 路由键是 orange black
    @RequestMapping("/direct/{routingKey}")
    public String direct(@PathVariable("routingKey") String routingKey){
        rabbitTemplate.convertAndSend(Constants.DIRECT_EXCHANGE, routingKey, "hello spring amqp:direct, my routing key is "+routingKey);
        return "发送成功";
    }

    // 路由键 *.orange.*   *.*.rabbit   lazy.#
    @RequestMapping("/topic/{routingKey}")
    public String topic(@PathVariable("routingKey") String routingKey){
        rabbitTemplate.convertAndSend(Constants.TOPIC_EXCHANGE, routingKey, "hello spring amqp:topic, my routing key is "+routingKey);
        return "发送成功";
    }
}

消费者

订阅发布模式

import com.example.rabbitmqspringboot.constant.Constants;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class FanoutListener {

    @RabbitListener(queues = Constants.FANOUT_QUEUE1)
    public void queueListener1(String message){
        System.out.println("队列["+Constants.FANOUT_QUEUE1+"] 接收到消息:" +message);
    }

    @RabbitListener(queues = Constants.FANOUT_QUEUE2)
    public void queueListener2(String message){
        System.out.println("队列["+Constants.FANOUT_QUEUE2+"] 接收到消息:" +message);
    }
}

 

路由模式

import com.example.rabbitmqspringboot.constant.Constants;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class DirectListener {

    @RabbitListener(queues = Constants.DIRECT_QUEUE1)
    public void queueListener1(String message){
        System.out.println("队列["+Constants.DIRECT_QUEUE1+"] 接收到消息:" +message);
    }

    @RabbitListener(queues = Constants.DIRECT_QUEUE2)
    public void queueListener2(String message){
        System.out.println("队列["+Constants.DIRECT_QUEUE2+"] 接收到消息:" +message);
    }
}

 

通配符模式

import com.example.rabbitmqspringboot.constant.Constants;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class TopicListener {

    @RabbitListener(queues = Constants.TOPIC_QUEUE1)
    public void queueListener1(String message){
        System.out.println("队列["+Constants.TOPIC_QUEUE1+"] 接收到消息:" +message);
    }

    @RabbitListener(queues = Constants.TOPIC_QUEUE2)
    public void queueListener2(String message){
        System.out.println("队列["+Constants.TOPIC_QUEUE2+"] 接收到消息:" +message);
    }
}

p_fly
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot 整合RabbitMq ，用心看完这一篇就够了
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
RabbitMQ与SpringBoot整合详解
vanGogh的博客
11-17 6364
一、前言   本文章总体简介，会采用Docker下载安装RabbitMQ，详细介绍RabbitMQ优缺点及其相关技术知识点，SpringBoot作为整合学习的基础架构。看完本片文章，你会了解消息队列RabbitMQ，你会使用消息队列RabbitMQ。 二、消息队列   当第一次出现在我脑中这个词语时，我会问自己什么时消息队列？我做的项目为什么没有消息队列？我做的项目可以用消息队列么？如果可以用消息队列这要怎么使用消息队列？消息队列能解决项目什么问题？等等问题会出现在我的脑海…，然而我将会在面文章中对自己慢慢
SpringBoot整合RabbitMQ
jyx_boy的博客
04-07 349
中配置RabbitMQ服务器的连接参数。把String换成对象。
Springboot整合RabbitMQ
weixin_49076273的博客
06-02 1万+
一、Springboot整合RabbitMQ的代码实现 1.引入Springboot整合RabbitMQ的依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> &l
SpringBoot整合RabbitMQ实现消息延迟队列(含源码)
热门推荐
Venus's Blog
07-04 9万+
*** 商户订单号/*** 支付宝订单号//为true,则交换机处理消息到路由失败，则会返回给生产者 配置文件指定，则这里不需指定 rabbitTemplate . setMandatory(true);//开启强制消息投递（mandatory为设置为true），但消息未被路由至任何一个queue，则回退一条消息 rabbitTemplate . setReturnsCallback(returned -> {});
【RabbitMQ】之 RabbitMQ 与 SpringBoot 整合
王廷云的博客
04-07 2146
一、SpringBoot 整合 RabbitMQ 1）、引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2）、添加配置 # 配置 RabbitMQ 服务器 IP 和端口 spring.rabbitmq.host=19
SpringBoot 整合 RabbitMQ
方圆师兄
05-09 863
RabbitMQ官网 这里我是直接使用docker发布的rabbitmq 拉取 rabbitmq镜像 docker pull rabbitmq:management 运行rabbitmq的容器 docker run -itd --name rabbbitmq -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin -p 15672:15672 -p 5672:5672 rabbitmq:management 我们暴露了两个端口 ，15
springboot 整合 rabbitmq
fjaljda的博客
11-10 920
springboot 整合 rabbitmq
[RabbitMQ]整合SpringBoot
m0_51955470的博客
03-15 3075
整合SpringBoot 创建项目 引入依赖 <dependencies> <!--RabbitMQ 依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> <dependency> &lt
SpringBoot如何整合RabbitMQ
ShuSheng007的程序人生
07-23 1万+
好久没有写博客了，终日忙于生计，真是人过30不如狗啊，但写点什么好呢？想想当年自己入门时候那痛苦的经历，还是写点优质实用的入门文章吧，既满足了自己好为人师的本性，也能给后辈提供一些帮助。今天咱们就来聊聊springboot整合rabbitmq的那些事吧。SpringBoot的风头之盛不多说了，我是在2016年首次接触springboot的，当时自己要写个APP，后台采用了springboot。当时还真是个新鲜事物，没想到以后几年的发展犹如黄河泛滥，一发不可收拾…rabbitmq官网https。...
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
docker安装rabbitmq并整合springboot
11-24
"Docker 安装 RabbitMQ 并整合 Spring Boot" RabbitMQ 是一个基于 AMQP 协议的消息队列系统，广泛应用于企业级应用程序中。通过 Docker 安装 RabbitMQ，可以实现轻松快速的部署和管理。本文将指导您如何使用 Docker...
springboot整合rabbitmq转发mqtt
09-30
本篇文章将详细介绍如何在Spring Boot项目中整合RabbitMQ以实现MQTT消息的转发。 首先，我们需要在Spring Boot项目中引入RabbitMQ的相关依赖。在`pom.xml`文件中添加以下Maven依赖： ```xml <groupId>org.spring...
死信队列.
weixin_52449894的博客
08-12 302
死信”是指在RabbitMQ中那些因为某些原因无法被正常处理的消息。
MQ的介绍
qq_53098873的博客
08-12 790
MQ全称Message Queue(消息队列)，是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信，主要功能业务解耦。
SpringBoot中整合RabbitMQ（测试+部署上线 最完整）
qq_73440769的博客
08-12 1279
包括RabbitMQ在虚拟机本地测试和部署上线通过微信小程序测试，包括Java代码使用示例，也有部署RabbitMQ中的一些困难和解决办法，和最后的解决，配置部署代码一条龙。
仿RabbitMq实现简易消息队列正式篇(路由匹配篇)
最新发布
m0_62812354的博客
08-15 217
TOC。
rabbitmq springboot配置
09-22
根据提供的引用内容，配置RabbitMQ与Spring Boot的步骤如下： 1. 首先，引入springboot整合amqp的依赖，即在pom.xml文件中添加以下依赖： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 2. 然后，在application.yml配置文件中进行RabbitMQ的相关配置，包括端口、主机、用户名、密码等信息。 3. 创建一个自定义的RabbitMQ配置类（例如RabbitConfig.java），用于配置和初始化RabbitMQ的队列和交换机。 4. 使用@RabbitListener注解标记消费者类或方法，监听指定的队列，实现消息的接收和处理。 5. 在消费者端，可以根据需要进行队列和交换机的创建和绑定操作，以确保消费者能够正常接收消息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值