RabbitMQ3/7--springboot集成RabbitMQ

最新推荐文章于 2023-02-01 18:23:02 发布
最新推荐文章于 2023-02-01 18:23:02 发布
阅读量478 收藏
点赞数
分类专栏： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42758288/article/details/119078705
版权

交换机与队列进行绑定的方式

1.配置类config(消费者端和生产者端)推荐
2.注解（在消费者端使用@RabbitListener(bindings = @QueueBinding（）进行绑定）
3.页面绑定（不推荐）

springboot整合RabbitMQ

业务场景，模拟用户下单，交换机进行消息分发

在这里插入图片描述
生产者和消费者分属不同的模块

工程架构

在这里插入图片描述

Fanout 模式(交换机与队列绑定在生产者端)

引入依赖项

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

配置文件application.yml

# 服务端口
server:
  port: 8080
# 配置rabbitmq服务
spring:
  rabbitmq:
    username: ems
    password: ems
    virtual-host: /ems
    host: 39.105.×××  //阿里云服务器地址，先开端口号
    port: 5672

生产者

service发送消息
package com.yhd.rabbitmq.service;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.UUID;

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 20:53
 */
@Service
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void makeOrder(String userid,String productid,int num){
        //1.根据商品id查询库存是否足够
        //2.保存订单
        String orderId = UUID.randomUUID().toString();
        System.out.println("订单生产成功："+orderId);
        //3.通过MQ来完成消息的分发
        //参数1：交换机 参数2：路由key/queue队列名称 参数3：消息内容
        String exchangeName = "fanout_order_exchange";
        String routingKey = "";
        rabbitTemplate.convertAndSend(exchangeName,routingKey,orderId);
    }
}
使用配置类完成交换机和队列的绑定关系
package com.yhd.rabbitmq.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 20:56
 */
@Configuration
public class RabbitMqConfiguration {
    //1.声明注册fanout模式的交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        //参数1，交换机名字 参数2，交换机是否持久化 参数3，是否自动删除
        return new FanoutExchange("fanout_order_exchange",true,false);
    }
    //2.声明3个队列
    @Bean
    public Queue smsQueue(){
        //参数1，队列名称 参数2，是否持久化
        return new Queue("sms.fanout.queue",true);
    }
    @Bean
    public Queue duanxinQueue(){
        return new Queue("duanxin.fanout.queue",true);
    }
    @Bean
    public Queue emailQueue(){
        return new Queue("email.fanout.queue",true);
    }
    //3.完成队列和交换机的绑定关系
    @Bean
    public Binding smsBingding(){
        return BindingBuilder.bind(smsQueue()).to(fanoutExchange());
    }
    @Bean
    public Binding duanxinBingding(){
        return BindingBuilder.bind(duanxinQueue()).to(fanoutExchange());
    }
    @Bean
    public Binding emailBingding(){
        return BindingBuilder.bind(emailQueue()).to(fanoutExchange());
    }
}
测试类注入并调用
package com.yhd.rabbitmq;

import com.yhd.rabbitmq.service.OrderService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class RabbitmqApplicationTests {
    @Autowired
    private OrderService orderService;
    @Test
    void contextLoads() {
        orderService.makeOrder("1","1",12);
    }
}
运行结果
  • 队列
  • 在这里插入图片描述
交换机

在这里插入图片描述

队列中的绑定交换机的信息

在这里插入图片描述

消费者

依赖项
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
配置文件application.yml
# 服务端口
server:
  port: 8081  //避免端口号冲突
# 配置rabbitmq服务
spring:
  rabbitmq:
    username: ems
    password: ems
    virtual-host: /ems
    host: 39.105.××××
    port: 5672
消息监听并进行消费（短信，Email，SMS三个消费者）
短信
package com.yhd.rabbitmq.service.fanout;

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

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 22:15
 */
//spring 容器托管`在这里插入代码片`
@Component
//声明消费者，并绑定队列
@RabbitListener(queues = "duanxin.fanout.queue")
public class FanoutDuanxinConsumer {
    @RabbitHandler  //回调，message就是消息内容
    public void reviceMessage(String message){
        System.out.println("duanxin接收到了的订单信息是："+message);
    }
}
Email
package com.yhd.rabbitmq.service.fanout;

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

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 22:17
 */
@Component
@RabbitListener(queues = "email.fanout.queue")
public class FanoutEmailConsumer {
    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("email接收到了的订单信息是："+message);
    }
}
SMS
package com.yhd.rabbitmq.service.fanout;

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

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 22:17
 */
@Component
@RabbitListener(queues = "sms.fanout.queue")
public class FanoutSMSConsumer {
    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("sms接收到了的订单信息是："+message);
    }
}
运行结果

在这里插入图片描述
消息队列中的消息已经被消费掉了
在这里插入图片描述

总结

生产者：使用service完成消息发送，使用config配置类完成队列和交换机的绑定，使用测试类进行测试
消费者：声明为消费者，进行队列绑定，消息回调
在这里插入图片描述
步骤：
1.生产者声明交换机
2.生产者声明队列
3.生产者完成交换机与队列的绑定
4.消费者通过队列与生产者建立联系

Direct 模式（交换机与队列的绑定在消费者端）

Direct模式与Finout模式类似，仅多了一个路由key的绑定。故直接上代码

生产者

service

//模拟用户下单
public void makeOrderDirect(String userid,String productid,int num){
    //1.根据商品id查询库存是否足够
    //2.保存订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单生产成功："+orderId);
    //3.通过MQ来完成消息的分发
    //参数1：交换机 参数2：路由key/queue队列名称 参数3：消息内容
    String exchangeName = "direct_order_exchange";
    String routingKey = "";
    rabbitTemplate.convertAndSend(exchangeName,"email",orderId);
    rabbitTemplate.convertAndSend(exchangeName,"duanxin",orderId);
}

测试类

@Test
void testorderDerect() {
    orderService.makeOrderDirect("1","1",12);
}

消费者

交换机与队列的绑定(配置类)

package com.yhd.rabbitmq.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 22:53
 */
@Configuration
public class RabbitMqConfiguration {
    //1.声明注册direct模式的交换机
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("direct_order_exchange",true,false);
    }
    //2.声明队列
    @Bean
    public Queue directSmsQueue(){
        return new Queue("sms.direct.queue",true);
    }
    @Bean
    public Queue driectDuanxinQueue(){
        return new Queue("duanxin.direct.queue",true);
    }
    @Bean
    public Queue driectEmailQueue(){
        return new Queue("email.direct.queue",true);
    }
    //3.完成绑定关系
    @Bean
    public Binding smsBingding(){
        return BindingBuilder.bind(directSmsQueue()).to(directExchange()).with("sms");
    }
    @Bean
    public Binding duanxinBingding(){
        return BindingBuilder.bind(driectDuanxinQueue()).to(directExchange()).with("duanxin");
    }
    @Bean
    public Binding emailBingding(){
        return BindingBuilder.bind(driectEmailQueue()).to(directExchange()).with("email");
    }
}

消息监听与消费（短信，Email，SMS）

短信
package com.yhd.rabbitmq.service.driect;

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

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 22:15
 */
//spring 容器托管
@Component
//声明消费者，并绑定队列
@RabbitListener(queues = "duanxin.direct.queue")
public class DriectDuanxinConsumer {
    @RabbitHandler  //回调，message就是消息内容
    public void reviceMessage(String message){
        System.out.println("duanxin接收到了的订单信息是："+message);
    }
}
Email
package com.yhd.rabbitmq.service.driect;

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

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 22:17
 */
@Component
@RabbitListener(queues = "email.direct.queue")
public class DriectEmailConsumer {
    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("email接收到了的订单信息是："+message);
    }
}
SMS
package com.yhd.rabbitmq.service.driect;

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

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 22:17
 */
@Component
@RabbitListener(queues = "sms.direct.queue")
public class DriectSMSConsumer {
    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("sms接收到了的订单信息是："+message);
    }
}

运行结果

在这里插入图片描述

总结

在进行交换机与队列绑定的时候要进行路由key的设置
在这里插入图片描述

Topic 模式（注解绑定）

Topic模式与Direct模式类似，都需要绑定路由key从而完成消息的匹配与转发，不同之处在于，Topic模式使用通配符模式，更灵活。

生产者

service

//--------------------------topic--------------------------------
//模拟用户下单
public void makeOrderTopic(String userid,String productid,int num){
    //1.根据商品id查询库存是否足够
    //2.保存订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单生产成功："+orderId);
    //3.通过MQ来完成消息的分发
    //参数1：交换机 参数2：路由key/queue队列名称 参数3：消息内容
    String exchangeName = "topic_order_exchange";
    String routingKey = "com.duanxin";
    rabbitTemplate.convertAndSend(exchangeName,routingKey,orderId);
}

测试类

@Test
void testorderTopic() {
    orderService.makeOrderTopic("1","1",12);
}

消费者（短信，Email，SMS三个消费者）

短信

package com.yhd.rabbitmq.service.topic;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 22:15
 */
//spring 容器托管
@Component
//声明消费者，并绑定队列
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "duanxin.topic.queue",durable = "true",autoDelete  = "false"),
        exchange = @Exchange(value = "topic_order_exchange",type = ExchangeTypes.TOPIC),
        key = "#.duanxin.#"
) )
public class TopicDuanxinConsumer {
    @RabbitHandler  //回调，message就是消息内容
    public void reviceMessage(String message){
        System.out.println("duanxin接收到了的订单信息是："+message);
    }
}

Email

package com.yhd.rabbitmq.service.topic;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 22:17
 */
@Component
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "email.topic.queue",durable = "true",autoDelete =  "false"),
        exchange = @Exchange(value = "topic_order_exchange",type = ExchangeTypes.TOPIC),
        key = "#.email.#"
))
public class TopciEmailConsumer {
    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("email接收到了的订单信息是："+message);
    }
}

SMS

package com.yhd.rabbitmq.service.topic;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/20 22:17
 */
@Component
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "sms.topic.queue",durable = "true",autoDelete =  "false"),
        exchange = @Exchange(value = "topic_order_exchange",type = ExchangeTypes.TOPIC),
        key = "com.#"
))
public class TopicSMSConsumer {
    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("sms接收到了的订单信息是："+message);
    }
}

运行结果

消费者启动后

在这里插入图片描述

生产者启动后

在这里插入图片描述

总结

使用注解进行交换机和队列的绑定
在这里插入图片描述

詹姆斯东
关注
专栏目录
Springboot 整合RabbitMq ，用心看完这一篇就够了
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
RabbitMq 虚拟主机 virtual-host ，Springboot 中使用 RabbitMq 虚拟主机 virtual-host
热门推荐
简简单单Onlinezuozuo
12-20 2万+
文章目录RabbitMq 虚拟主机 virtual-host ，Springboot 中使用 RabbitMq 虚拟主机 virtual-host1、在RabbitMQ 控制台中创建虚拟主机2、创建一个用户3、把用户分配给虚拟主机4、在Springboot 项目中指定连接时，连接到指定的虚拟主机5、虚拟主机在Springboot 中取值的源码 RabbitMq 虚拟主机 virtual-host ...
springboot整合rabbitMQ
m0_59054066的博客
09-19 124
1.创建一个springboot工程 2.导入rabbitMQ相关依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 3.yml配置文件配置mq五大参数即加上虚拟主机 spring: rabbitmq:
# SpringBoot 集成 RabbitMQ
不积跬步，无以至千里；不积小流，无以成江海
01-13 190
RabbitMQ是实现AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ主要是为了实现系统之间的双向解耦而实现的。当生产者大量产生数据时，消费者无法快速消费，那么需要一个中间层。保存这个数据。...
springboot 集成rabbitmq
qq_34135615的博客
02-01 942
springboot集成rabbitmq
springboot整合RabbitMQ
weixin_45671337的博客
07-19 840
介绍 MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。 MQ特点： MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取或者订阅队列
springboot-integrate-rabbitmq:springboot-集成-rabbitmq
03-16
在"springboot-integrate-rabbitmq-main"这个项目中，你可能会找到以下文件和目录结构： - `src/main/java`: 包含主要的Java源代码，如配置类、消息生产者和服务、消息消费者等。 - `src/main/resources`: 存放配置...
（二）RabbitMQ学习笔记 --- SpringBoot集成RabbitMQ
yaozw0112的博客
10-16 240
1、导入依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.3.4.RELEASE</version> </parent> <dependencies>
RabbitMQ实战-多线程-springboot-rabbit.zip
最新发布
11-07
通过这个项目，你将学习如何在Spring Boot中集成RabbitMQ，使用多线程来提高消息处理效率，并理解如何设计和实现一个健壮的、高并发的消息处理系统。同时，这也会帮助你掌握如何在分布式环境中解决异步通信和数据...
rabbitmq-practice整合springboot的一个小练习demo
07-10
本项目“rabbitmq-practice整合springboot的一个小练习demo”就是针对这种集成进行的一次实践，旨在帮助开发者理解和掌握如何在Spring Boot应用中使用RabbitMQ。 首先，我们需要了解RabbitMQ的基本概念。RabbitMQ是...
Spring boot整合RabbitMQ
一个还在上学的程序缘
11-30 737
目录： 一、RabbitMQ简介   RabbitMQ安装不必我多说，linux和windows环境下都可以安装，我是在windows环境下进行安装的，安装RabbitMQ之前需要先安装Erlang，因为Rabbit MQ 是建立在Erlang OTP平台上，而且安装Erlang 时要注意安装的RabbityMQ 所依赖的Erlang版本。   RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而且支持跨平台。
Springboot 整合RabbitMq
GSON的博客
08-21 4748
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
SpringBoot+RabbitMQ
一名系统架构师的征途
08-08 3684
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。消息中间件在互联网公司的使用中越来越多，刚才还看到新闻阿里将RocketMQ捐献给了apache，当然了今天的主角还是讲RabbitMQ。消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不用关心是谁来消费，消费者不用关心谁在生产...
SpringBoot--整合RabbitMQ
吴声子夜歌的博客
02-06 628
整合SpringBoot SpringBoot未AMQP提供了自动化配置依赖spring-boot-starter-amqp，因此首先创建项目，并添加依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>sp...
SpringBoot 整合RabbitMQ
m0_59276546的博客
07-21 92
SpringBoot 整合RabbitMQ
springboot整合rabbitmq
Listen·Rain的博客
06-26 414
交换机Fanout、Direct、Topic、Header模式测试 模式的详细介绍可以去查看rabbitmq官网：https://www.rabbitmq.com/tutorials/tutorial-three-java.html
RabbitMQ死信交换机实现定时任务：Springboot集成实例
在Spring Boot中集成RabbitMQ，开发者可以利用框架提供的API和配置来设置死信交换机和TTL。通过在生产者端设置消息的TTL，然后配置一个接收死信消息的队列，我们可以实现一个功能强大的延迟队列，用于处理那些需要在...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值