RabbitMQ详解（四）：SpringBoot整合MQ

最新推荐文章于 2024-05-28 22:59:18 发布
最新推荐文章于 2024-05-28 22:59:18 发布
阅读量1.7k 收藏 2
点赞数 2
分类专栏： 中间件 文章标签： java-rabbitmq rabbitmq spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45181611/article/details/130606944
版权

SpringBoot整合MQ

需要创建两个springboot项目，一个springboot_rabbitmq_producer生产者，一个springboot_rabbitmq_consumer消费者

fanout模式（配置文件方式）

定义生产者

  • 创建生产者工程 springboot_rabbitmq_producer

    在这里插入图片描述

  • pom.xml文件中添加依赖

    <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>

  • application.yml文件配置

    # 服务端口
server:
  port: 8080
# 配置rabbitmq服务
spring:
  rabbitmq:
    username: admin
    password: admin
    virtual-host: /
    host: 请填写自己的IP地址
    port: 5672

  • 生产者代码

    package com.cn.service;

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

@Service
public class OrderService {

    @Autowired	
    /**
     * RabbitTemplate
     * 提供了编辑消息、发送消息、发送消息前的监听、发送消息后的监听等消息制造和消息监听功能，
     * 可以让我们像操作原生 RabbitMQ API 那样在 Spring 中通过 RabbitTemplate 来操作消息并发送和监听消息
     */
    private RabbitTemplate rabbitTemplate;

      public void createOrderFanout(String userId, String productId, int num){
        //此处模拟生成订单编号
        String orderId = UUID.randomUUID().toString();
        //定义交换机名称
        String exchangeName  = "fanout-order-exchange";
        //fanout模式不需要routeKey
        String routeKey  = "";
        rabbitTemplate.convertAndSend(exchangeName, routeKey, orderId);
    }
}

  • 绑定关系,基于配置文件的形式

    package com.cn.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;

@Configuration
public class FanoutRabbitmqConfig {

    //1.声明交换机
    @Bean
    public FanoutExchange fanoutExchange(){
     return new FanoutExchange("fanout-order-exchange", true, false);
    }

    //2.声明队列
    @Bean
    public Queue fanoutEmailQueue(){
        return new Queue("email.fanout.queue", true);
    }

    @Bean
    public Queue fanoutSmsQueue(){
        return new Queue("sms.fanout.queue", true);
    }

    @Bean
    public Queue fanoutWeixinQueue(){
        return new Queue("weixin.fanout.queue", true);
    }

    //3.交换机和队列进行绑定
    @Bean
    public Binding fanoutEmailBinding(){
        return BindingBuilder.bind(fanoutEmailQueue()).to(fanoutExchange());
    }

    @Bean
    public Binding fanoutSmsBinding(){
        return BindingBuilder.bind(fanoutSmsQueue()).to(fanoutExchange());
    }

    @Bean
    public Binding fanoutWeixinBinding(){
        return BindingBuilder.bind(fanoutWeixinQueue()).to(fanoutExchange());
    }
}

  • 测试代码

    package com.cn;

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

@SpringBootTest
class SpringbootRabbitmqFanoutProducerApplicationTests {

    @Autowired
    private OrderService orderService;

    @Test
    void testOrderFanout() {
        orderService.createOrderFanout("1","1",111);
    }
}

  • 启动测试，查看图形化管理界面，可以看到交换机和队列都已创建好并且各投递了一条消息

在这里插入图片描述

在这里插入图片描述

定义消费者

  • 创建消费者工程 springboot_rabbitmq_consumer

    在这里插入图片描述

  • pom.xml文件中添加依赖

    <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>

  • application.yml文件配置

    # 服务端口
server:
  port: 8081
# 配置rabbitmq服务
spring:
  rabbitmq:
    username: admin
    password: admin
    virtual-host: /
    host: 请填写自己的IP地址
    port: 5672

  • 消费者-邮件服务

    package com.cn.service.fanout;

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

@Service
/**
 * @RabbitListener
 * 队列已经存在时，直接指定名称即可
 */
@RabbitListener(queues = "email.fanout.queue")
public class EmailConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("email.fanout.queue => 接收到了订单信息:" + message);
    }
}

  • 消费者-短信服务

    package com.cn.service.fanout;

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

@Service
/**
 * @RabbitListener
 * 队列已经存在时，直接指定名称即可
 */
@RabbitListener(queues = "sms.fanout.queue")
public class SmsConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("sms.fanout.queue => 接收到了订单信息:" + message);
    }
}

  • 消费者-微信服务

    package com.cn.service.fanout;

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

@Service
/**
 * @RabbitListener
 * 队列已经存在时，直接指定名称即可
 */
@RabbitListener(queues = "weixin.fanout.queue")
public class WeixinConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("weixin.fanout.queue => 接收到了订单信息:" + message);
    }
}

  • 启动消费者，查看日志打印

    在这里插入图片描述

direct模式（配置文件方式）

定义生产者

  • 在上个案例OrderService中修改

     public void createOrderDirect(String useerId, String productId, int num){
      	//此处模拟生成订单编号
        String orderId = UUID.randomUUID().toString();
        //定义交换机名称
        String exchangeName  = "direct-order-exchange";;
        //direct模式需要routeKey
        String routeKey  = "email";
        rabbitTemplate.convertAndSend(exchangeName, routeKey, orderId);
    }

  • 绑定关系

    package com.cn.config;

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

@Configuration
public class DirectRabbitmqConfig {

    //1.声明交换机
    @Bean
    public DirectExchange directExchange(){
     return new DirectExchange("direct-order-exchange", true, false);
    }

    //2.声明队列
    @Bean
    public Queue directEmailQueue(){
        return new Queue("email.direct.queue", true);
    }

    @Bean
    public Queue directSmsQueue(){
        return new Queue("sms.direct.queue", true);
    }

    @Bean
    public Queue directWeixinQueue(){
        return new Queue("weixin.direct.queue", true);
    }

    //3.交换机和队列进行绑定
    @Bean
    public Binding directEmailBinding(){
        return BindingBuilder.bind(directEmailQueue()).to(directExchange()).with("email");
    }

    @Bean
    public Binding directSmsBinding(){
        return BindingBuilder.bind(directSmsQueue()).to(directExchange()).with("sms");
    }

    @Bean
    public Binding directWeixinBinding(){
        return BindingBuilder.bind(directWeixinQueue()).to(directExchange()).with("weixin");
    }
}

  • 测试 代码

       @Test
    void testOrderDirect() {
        orderService.createOrderDirect("1","1",222);
    }

  • 启动测试，查看图形化管理界面，可以看到交换机和队列都已创建好并且只有email.direct.queue投递了一条消息

    在这里插入图片描述

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kL0fBpb2-1683753215224)(RabbitMQ.assets/image-20230511045758321.png)]

定义消费者

  • 同理对上个案例中的代码进行修改

  • 消费者-邮件服务

    package com.cn.service.direct;

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

@Service
@RabbitListener(queues = "email.direct.queue")
public class DirectEmailConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("email.direct.queue => 接收到了订单信息:" + message);
    }
}

  • 消费者-短信服务

    package com.cn.service.direct;

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

@Service
@RabbitListener(queues = "sms.direct.queue")
public class DirectSmsConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("sms.direct.queue => 接收到了订单信息:" + message);
    }
}

  • 消费者-微信服务

    package com.cn.service.direct;

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

@Service
@RabbitListener(queues = "weixin.direct.queue")
public class DirectWeixinConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("weixin.direct.queue => 接收到了订单信息:" + message);
    }
}

  • 启动消费者，查看日志打印

    在这里插入图片描述

topic模式(注解方式)

定义生产者

  • 在上个案例中修改

      public void createOrderTopic(String useerId, String productId, int num){
        String orderId = UUID.randomUUID().toString();
        String exchangeName  = "topic-order-exchange";
        String routeKey  = "com.email.xxx";
        rabbitTemplate.convertAndSend(exchangeName, routeKey, orderId);
    }

  • 此处不进行绑定操作，后面在消费者中使用注解形式去修改

  • 测试代码

    	@Test
    void testOrderTopic() {
        orderService.createOrderTopic("1","1",14);
    }

  • 启动测试，查看图形化管理界面，可以看到交换机和队列都已创建好并且只有email.direct.queue和sms.direct.queue各投递了一条消息

    在这里插入图片描述

    在这里插入图片描述

定义消费者

  • 同理对上个案例中的代码进行修改

  • 消费者-邮件服务

    package com.cn.service.topic;

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

@Service
@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 TopicEmailConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("email.topic.queue => 接收到了订单信息:" + message);
    }
}

  • 消费者-短信服务

    package com.cn.service.topic;

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

@Service
@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.topic.queue => 接收到了订单信息:" + message);
    }

}

  • 消费者-微信服务

    package com.cn.service.topic;

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

@Service
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "weixin.topic.queue", durable = "true", autoDelete = "false"),
        exchange = @Exchange(value = "topic-order-exchange", type = ExchangeTypes.TOPIC),
        key = "*.weixin.#"
))
public class TopicWeixinConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("weixin.topic.queue => 接收到了订单信息:" + message);
    }
}

  • 启动消费者，查看日志打印

    在这里插入图片描述

桔子Coding
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
05-27
在这个项目"springboot-rabbitMQ-websocket"中，我们将探讨如何将这三个技术整合起来，实现高效的数据发布和实时接收。 首先，Spring Boot整合RabbitMQ主要涉及以下几个步骤： 1. **添加依赖**：在项目中，我们...
SpringBoot 整合 MQ
qq_33753147的博客
10-29 3784
SpringBoot 整合 MQ
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4549
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
SpringBoot整合RabbitMQ的快速使用教程
最新发布
weixin_50348837的博客
05-28 1220
在分布式系统中，消息队列是一种重要的通信方式，它能够有效地将消息从一个应用程序传递到另一个应用程序。RabbitMQ是一款流行的开源消息队列系统，简单易用且功能强大。本文将介绍如何使用SpringBoot快速整合RabbitMQ，实现消息的发送和接收。。Fanout交换机会将接收到的所有消息广播到它知道的所有队列中。这种类型的交换机不考虑路由键，只是简单地将消息复制到所有绑定的队列中。适用于不需要选择性地发送消息给特定队列的情况，例如，广播系统通知或有多个服务需要消费同一份数据的场景。
springboot整合MQ
weixin_45865428的博客
03-01 3649
1、导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> <version>2.1.4.RELEASE</version> </dependency> 2、修改配置文件 spring.rabbitmq.host=.
利用springboot整合mq
qq_55983332的博客
03-10 180
springboot整合mq
Springboot项目整合Rabbitmq详细教程
洛阳泰山的博客
10-13 2632
首先在springboot的pom文件里引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 然后application.yml： ps：里面的虚拟host配置项不是必须的，我自己在rabbitmq服务上创建了自己的虚拟host
springboot-rabbitmq-learning:springboot-rabbitmq整合
05-02
1 与springboot框架结合 2 提供send接口 3 提供consume接口 (1) 处理成功，从队列中删除消息 (2) 处理失败(网络问题，程序问题，服务挂了)，将消息重新放回队列 4 保证消息的事务性处理 5 使用线程来消费通道中的...
springBoot-rabbitmq-study:springBoot RabbitMq继承，发送消息确认、持久化、消费消息确认
05-16
springBoot-rabbitmq-study 20171120 更新 1 改进一些细节：遍历map时基于entry，增加一定的效率 20170510 更新 1 增加线程池consumer优雅退出机制Runtime.getRuntime().addShutdownHook 2 修改部分log输出方式，将...
rabbitmq:SpringBoot整合RabbitMQ
05-17
SpringBoot整合消息队列RabbitMQ 简介 消息对列一般分JMS和AMQP两种 JMS是基于java API，对平台的支持力度较差 AMQP是一种跨平台、跨语言的网络线级协议 RabbitMQ为本工程的消息队列练习方式
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
Springboot 整合RabbitMq
GSON的博客
08-21 4463
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
Springboot整合RabbitMQ消息中间件
雾林小妖的博客
11-04 581
Springboot整合RabbitMQ消息中间件，并创建交换器和队列。
SpringBoot整合实现RabbitMQ
weixin_39956506的博客
01-30 4619
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。创建2个springboot项目，一个 mq-rabbitmq-producer（生产者），一个mq-rabbitmq-consumer（消费者）。rabbitmq配置类：配置Exchange、Queue、以及绑定交换机。rabbitmq配置类：配置Exchange、Queue、以及绑定交换机。
Springboot 整合 RocketMQ
原名：@程序员大禹
06-25 1605
pull方式里，取消息的过程需要用户自己写，首先通过打算消费的Topic拿到MessageQueue的集合，遍历MessageQueue集合，然后针对每个MessageQueue批量取消息，一次取完后，记录该队列下一次要取的开始offset，直到取完了，再换另一个MessageQueue。缺点：消费者从server端拉消息，主动权在消费端，可控性好，但是时间间隔不好设置，间隔太短，则空请求会多，浪费资源，间隔太长，则消息不能及时处理。推荐使用PushConsumer，直接上代码！
Springboot快速整合MQ
bjjx123456的博客
02-02 980
异步调用简单说就是将一件事拆为两部分，把应该立马做完的【基础部分】先做完，然后剩下的事情【bonus】留到后台慢慢完成。 举个例子，我们赶ddl的时候，先把必须完成的基础部分先做完提交，然后如果想要继续优化项目在在后面慢慢优化。
Springboot整合RabbitMQ详解
m0_54853503的博客
07-28 1969
队列，交换机和绑定统称为AMQP实体（AMQPentities）这是RabbitMQ的一种保护机制。防止当消息激增的时候，海量的消息进入consumer而引发consumer宕机。该值定义通道上允许的未确认消息的最大数量，这是为了防止Unacked消息缓冲区存在过多的Unacked消息。一旦数量达到配置的数量，RabbitMQ将停止在通道上传递更多消息。RabbitMQ支持为队列设置优先级，从而达到优先级高的队列中消息被优先消费。惰性队列支持更多的消息存储。消息回退会增加生产者的复杂性；...
【SpringBoot高级篇】SpringBoot集成RocketMQ消息队列
热门推荐
输入技术、输出想法
01-18 1万+
RocketMQ是阿里巴巴2016年MQ中间件，使用Java语言开发，在阿里内部，RocketMQ承接了例如“双11”等高并发场景的消息流转，能够处理万亿级别的消息。
CentOS7环境下RabbitMQ服务器搭建与SpringBoot整合教程
"本文档详细介绍了如何在CentOS7环境下搭建RabbitMQ服务器，并整合Java客户端与SpringBoot应用，提供了一个生产者-消费者代码实例。" 在本文档中，我们首先探讨了RabbitMQ服务器的安装和配置步骤，这对于任何希望在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值