RabbitMQ：第三章：Springboot集成RabbitMQ（直连模式，工作队列模式，发布订阅模式，路由模式，通配符模式）

最新推荐文章于 2024-07-08 09:23:09 发布
最新推荐文章于 2024-07-08 09:23:09 发布
阅读量901 收藏 19
点赞数 23
分类专栏： 程序员 文章标签： java-rabbitmq rabbitmq spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dgayuiafahf/article/details/138424143
版权

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！

<maven.compiler.target>1.7</maven.compiler.target>

org.springframework.boot

spring-boot-starter

org.springframework.boot

spring-boot-starter-test

test

org.springframework.boot

spring-boot-starter-amqp

org.springframework.boot

spring-boot-starter-web

junit

junit

4.11

test

springboot_rabbitmq

maven-clean-plugin

3.1.0

maven-resources-plugin

3.0.2

maven-compiler-plugin

3.8.0

maven-surefire-plugin

2.22.1

maven-war-plugin

3.2.2

maven-install-plugin

2.5.2

maven-deploy-plugin

2.8.2

2.application.properties配置

server.port=8080

#spring.rabbitmq.host=localhost

spring.rabbitmq.port=5672

spring.rabbitmq.username=guest

spring.rabbitmq.password=guest

spring.rabbitmq.addresses=110.42.239.246

spring.rabbitmq.virtual-host=springboot

#spring.rabbitmq.addresses=110.42.239.246:5672,110.42.239.247:5672,110.42.239.248:5672

说明：这里免费提供rabbitmq连接方式给大家使用学习

3.config配置

HelloWorldConfig

package com.sky.springbootrabbitmqmodule.config;

import org.springframework.amqp.core.Queue;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

/**

  • HelloWorld rabbitmq课上讲解的第一个工作模式

  • 直连模式只需要声明队列，所有消息都通过队列转发。

  • 无需设置交换机

*/

@Configuration

public class HelloWorldConfig {

@Bean

public Queue setQueue() {

return new Queue(“helloWorldqueue”);

}

}

FanoutConfig

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

/**

  • Fanout模式需要声明exchange，并绑定queue，由exchange负责转发到queue上。

  • 广播模式 交换机类型设置为：fanout

*/

@Configuration

public class FanoutConfig {

//声明队列

@Bean

public Queue fanoutQ1() {

return new Queue(“fanout.q1”);

}

@Bean

public Queue fanoutQ2() {

return new Queue(“fanout.q2”);

}

//声明exchange

@Bean

public FanoutExchange setFanoutExchange() {

return new FanoutExchange(“fanoutExchange”);

}

//声明Binding,exchange与queue的绑定关系

@Bean

public Binding bindQ1() {

return BindingBuilder.bind(fanoutQ1()).to(setFanoutExchange());

}

@Bean

public Binding bindQ2() {

return BindingBuilder.bind(fanoutQ2()).to(setFanoutExchange());

}

}

WorkConfig

package com.sky.springbootrabbitmqmodule.config;

import org.springframework.amqp.core.Queue;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

@Configuration

public class WorkConfig {

//声明队列

@Bean

public Queue workQ1() {

return new Queue(“work_sb_mq_q”);

}

}

DirectConfig

package com.sky.springbootrabbitmqmodule.config;

import org.springframework.amqp.core.*;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

/*

路由模式|Routing模式 交换机类型：direct

*/

@Configuration

public class DirectConfig {

//声明队列

@Bean

public Queue directQ1() {

return new Queue(“direct_sb_mq_q1”);

}

@Bean

public Queue directQ2() {

return new Queue(“direct_sb_mq_q2”);

}

//声明exchange

@Bean

public DirectExchange setDirectExchange() {

return new DirectExchange(“directExchange”);

}

//声明binding，需要声明一个routingKey

@Bean

public Binding bindDirectBind1() {

return BindingBuilder.bind(directQ1()).to(setDirectExchange()).with(“directBind.one”);

}

@Bean

public Binding bindDirectBind2() {

return BindingBuilder.bind(directQ2()).to(setDirectExchange()).with(“directBind.two”);

}

}

TopicConfig

package com.sky.springbootrabbitmqmodule.config;

import org.springframework.amqp.core.Binding;

import org.springframework.amqp.core.BindingBuilder;

import org.springframework.amqp.core.Queue;

import org.springframework.amqp.core.TopicExchange;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

/*

Topics模式 交换机类型 topic

  • */

@Configuration

public class TopicConfig {

//声明队列

@Bean

public Queue topicQ1() {

return new Queue(“topic_sb_mq_q1”);

}

@Bean

public Queue topicQ2() {

return new Queue(“topic_sb_mq_q2”);

}

//声明exchange

@Bean

public TopicExchange setTopicExchange() {

return new TopicExchange(“topicExchange”);

}

//声明binding，需要声明一个roytingKey

@Bean

public Binding bindTopicHebei1() {

return BindingBuilder.bind(topicQ1()).to(setTopicExchange()).with(“directBind.*”);

}

@Bean

public Binding bindTopicHebei2() {

return BindingBuilder.bind(topicQ2()).to(setTopicExchange()).with(“#.two”);

}

}

4.消费端component

package com.sky.springbootrabbitmqmodule.component;

import org.springframework.amqp.rabbit.annotation.RabbitListener;

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;

import org.springframework.amqp.rabbit.connection.ConnectionFactory;

import org.springframework.context.annotation.Bean;

import org.springframework.stereotype.Component;

@Component

public class ConcumerReceiver {

//直连模式的多个消费者，会分到其中一个消费者进行消费。类似task模式

//通过注入RabbitContainerFactory对象，来设置一些属性，相当于task里的channel.basicQos

@RabbitListener(queues=“helloWorldqueue”)

public void helloWorldReceive(String message) {

System.out.println("helloWorld模式 received message : " +message);

}

//工作队列模式

@RabbitListener(queues=“work_sb_mq_q”)

public void wordQueueReceiveq1(String message) {

System.out.println("工作队列模式1 received message : " +message);

}

@RabbitListener(queues=“work_sb_mq_q”)

public void wordQueueReceiveq2(String message) {

System.out.println("工作队列模式2 received message : " +message);

}

//pub/sub模式进行消息监听

@RabbitListener(queues=“fanout.q1”)

public void fanoutReceiveq1(String message) {

System.out.println("发布订阅模式1received message : " +message);

}

@RabbitListener(queues=“fanout.q2”)

public void fanoutReceiveq2(String message) {

System.out.println("发布订阅模式2 received message : " +message);

}

//Routing路由模式

@RabbitListener(queues=“direct_sb_mq_q1”)

public void routingReceiveq1(String message) {

System.out.println("Routing路由模式routingReceiveqOne received message : " +message);

}

@RabbitListener(queues=“direct_sb_mq_q2”)

public void routingReceiveq2(String message) {

System.out.println("Routing路由模式routingReceiveqTwo received message : " +message);

}

//topic 模式

//注意这个模式会有优先匹配原则。例如发送routingKey=hunan.IT,那匹配到hunan.(hunan.IT,hunan.eco),之后就不会再去匹配.ITd

@RabbitListener(queues=“topic_sb_mq_q1”)

public void topicReceiveq1(String message) {

System.out.println("Topic模式 topic_sb_mq_q1 received message : " +message);

}

@RabbitListener(queues=“topic_sb_mq_q2”)

public void topicReceiveq2(String message) {

System.out.println("Topic模式 topic_sb_mq_q2 received message : " +message);

}

}

5.生产者controller

package com.sky.springbootrabbitmqmodule.controller;

import org.springframework.amqp.AmqpException;

import org.springframework.amqp.core.Message;

import org.springframework.amqp.core.MessageProperties;

import org.springframework.amqp.rabbit.core.RabbitTemplate;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RestController;

import java.io.UnsupportedEncodingException;

@RestController

public class ProducerController {

@Autowired

private RabbitTemplate rabbitTemplate;

//helloWorld 直连模式

@GetMapping(value=“/helloWorldSend”)

public Object helloWorldSend(String message) throws AmqpException, UnsupportedEncodingException {

//设置部分请求参数

MessageProperties messageProperties = new MessageProperties();

messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);

//发消息

rabbitTemplate.send(“helloWorldqueue”,new Message(message.getBytes(“UTF-8”),messageProperties));

return "message sended : "+message;

}

//工作队列模式

@GetMapping(value=“/workqueueSend”)

public Object workqueueSend(String message) throws AmqpException, UnsupportedEncodingException {

MessageProperties messageProperties = new MessageProperties();

messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);

//制造多个消息进行发送操作

for (int i = 0; i <10 ; i++) {

rabbitTemplate.send(“work_sb_mq_q”, new Message(message.getBytes(“UTF-8”),messageProperties));

}

return "message sended : "+message;

}

// pub/sub 发布订阅模式 交换机类型 fanout

@GetMapping(value=“/fanoutSend”)

public Object fanoutSend(String message) throws AmqpException, UnsupportedEncodingException {

MessageProperties messageProperties = new MessageProperties();

messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);

//fanout模式只往exchange里发送消息。分发到exchange下的所有queue

rabbitTemplate.send(“fanoutExchange”, “”, new Message(message.getBytes(“UTF-8”),messageProperties));

return "message sended : "+message;

}

//routing路由工作模式 交换机类型 direct

@GetMapping(value=“/directSend”)

public Object routingSend(String routingKey,String message) throws AmqpException, UnsupportedEncodingException {

if(null == routingKey) {

routingKey=“directBind.one”;

}

MessageProperties messageProperties = new MessageProperties();

messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);

//fanout模式只往exchange里发送消息。分发到exchange下的所有queue

rabbitTemplate.send(“directExchange”, routingKey, new Message(message.getBytes(“UTF-8”),messageProperties));

return “message sended : routingKey >”+routingKey+";message > "+message;

}

//topic 工作模式 交换机类型 topic

@GetMapping(value=“/topicSend”)

public Object topicSend(String routingKey,String message) throws AmqpException, UnsupportedEncodingException {

if(null == routingKey) {

routingKey=“directBind.one”;

}

MessageProperties messageProperties = new MessageProperties();

messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);

//fanout模式只往exchange里发送消息。分发到exchange下的所有queue

rabbitTemplate.send(“topicExchange”, routingKey, new Message(message.getBytes(“UTF-8”),messageProperties));

return “message sended : routingKey >”+routingKey+";message > "+message;

}

}

读者福利

秋招我借这份PDF的复习思路，收获美团，小米，京东等Java岗offer

更多笔记分享

秋招我借这份PDF的复习思路，收获美团，小米，京东等Java岗offer

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！
}

//topic 工作模式 交换机类型 topic

@GetMapping(value=“/topicSend”)

public Object topicSend(String routingKey,String message) throws AmqpException, UnsupportedEncodingException {

if(null == routingKey) {

routingKey=“directBind.one”;

}

MessageProperties messageProperties = new MessageProperties();

messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);

//fanout模式只往exchange里发送消息。分发到exchange下的所有queue

rabbitTemplate.send(“topicExchange”, routingKey, new Message(message.getBytes(“UTF-8”),messageProperties));

return “message sended : routingKey >”+routingKey+";message > "+message;

}

}

读者福利

[外链图片转存中…(img-lZBkNpyq-1714740146831)]

更多笔记分享

[外链图片转存中…(img-JBTTtX9v-1714740146832)]

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！

白茶一清欢
关注
  • 23
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
SpringBoot中使用RabbitMQ消息队列——路由、通配符、订阅模式
陪你听风的博客
03-06 9920
RabbitMQ简介 RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。 支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等...
springboot2.1.4集成rabbitmq，三种模式：fanout direct topic的实现
05-16
3. **Topic模式**：Topic模式允许使用通配符进行路由，如`*.log`或`audit.#`。这种模式在需要根据消息类型进行路由时非常有用。创建Topic交换机并发送消息： ```java @Bean public TopicExchange topicExchange() {...
RabbitMQ：第三章：Springboot集成RabbitMQ（直连模式，工作队列模式，发布订阅模式，路由模式
2401_85617548的博客
06-28 926
机会是留给有准备的人，大家在求职之前应该要明确自己的态度，熟悉求职流程，做好充分的准备，把一些可预见的事情做好。对于应届毕业生来说，校招更适合你们，因为绝大部分都不会有工作经验，企业也不会有工作经验的需求。同时，你也不需要伪造高大上的实战经验，以此让自己的简历能够脱颖而出，反倒会让面试官有所怀疑。你在大学时期应该明确自己的发展方向，如果你在大一就确定你以后想成为Java工程师，那就不要花太多的时间去学习其他的技术语言，高数之类的，不如好好想着如何夯实Java基础。请转发本文支持一下。
RabbitMQ消息队列(四)：SpringBoot整合之发布订阅模式
fatestranger的博客
08-11 903
P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给 X（交换机）C：消费者，消息的接受者，会一直等待消息到来。Queue：消息队列，接收消息、缓存消息。Exchange：交换机，图中的 X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于 Exchange 的类型。.........
RabbitMQ03_Springboot整合RabbitMQ实现发布与订阅模式、路由模式、通配符模式
所得皆惊喜
12-14 1690
Springboot整合RabbitMQ实现发布与订阅模式、路由模式、通配符模式
RabbitMQ消息队列(六)：SpringBoot整合之通配符模式
fatestranger的博客
08-11 436
简单模式 HelloWorld 一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）；工作队列模式 Work Queue 一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）；发布订阅模式 Publish/subscribe 需要设置类型为 fanout 的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列；......
RabbitMQ——六种工作模式、SpringBoot整合RabbitMQ
Guizy
01-23 1434
目录 一、RabbitMQ入门程序 二、Work queues 工作模式 三、Publish / Subscribe 发布/订阅模式 四、Routing 路由模式 五、Topics 六、Header 七、RPC 八、Spring Data Elasticsearch 一、RabbitMQ入门程序 <dependencies> <dependency> <groupId>org.springframework.boot</grou
SpringBoot整合RabbitMQ:Topics(通配符模式)
weixin_65518722的博客
11-07 220
打开业务类RabbitMQService，在该类中使用@RabbitListener注解及其相关属性定制Topics通配符模式的消息组件，并模拟编写消息消费者接收的方法。System.out.println("接收到短信订阅需求处理消息： "+message);// 通配符模式消息接收、进行短信业务订阅处理。// 通配符模式消息接收、进行邮件业务订阅处理。// 同时发送邮件和短信的用户消息。// 只发送邮件订阅用户消息。// 只发送短信订阅用户消息。
图文并茂的RabbitMQ工作模式
王华春_Jason
09-15 767
一、简单模式 1、简单模式 一对一模式，一个生产者、一个消费者，生产者发送消息，消费者消费消息。 生产者：也就是要发送消息的程序 消费者：消息的接收者，会一直等待消息到来 消息队列：类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息 2、实例代码： //生产者 public class Producer { public static void main(String[] args) throws IOException, TimeoutException
SpringBoot(40) RabbitMQ 7种工作模式
郑清
08-10 801
RabbitMQ 工作模式 1. 简单模式 2. 工作队列模式 3. 发布订阅模式 4. 路由模式 5. 通配符模式 6. RPC模式
rabbitmq延时队列和四种交换机模式下队列的简单实现
08-06
3. **Topic交换机**：比Direct更灵活，允许使用通配符进行路由。路由键可以包含单词（以`.`分隔），消息会根据匹配程度路由到队列。例如，“weather.us.west”和“weather.eu.east”。 4. **Headers交换机**：不...
SpringBoot与RabbitMQ整合和对五种队列模式的实现源码
06-21
在本文中，我们将深入探讨如何将SpringBoot框架与RabbitMQ消息队列服务进行整合，以及如何实现五种常见的队列模式。RabbitMQ作为一款强大的开源消息中间件，广泛应用于分布式系统中，用于解耦应用程序，提高系统的可...
基于RabbitMQ几种Exchange 模式详解
08-28
基于RabbitMQ几种Exchange模式详解 本文将详细介绍RabbitMQ中四种Exchange模式：fanout、direct、topic、header。在实际应用中，header模式使用较少，本文将对前三种模式进行比较。 一、Fanout Exchange Fanout ...
RabbitMQ 最常用的三大模式实例解析
08-25
RabbitMQ 三大模式实例解析详解 RabbitMQ 是一个基于 AMQP 协议的开源消息队列系统，它提供了多种模式来实现消息的发送和接收。今天，我们将详细介绍 RabbitMQ 中的三大模式实例解析：Direct 模式、Fanout 模式和 ...
SpringBoot日常：封装rabbitmq starter组件
最新发布
qq_32590535的博客
07-08 669
本章内容主要介绍编写一个rabbitmq starter，能够通过配置文件进行配置交换机、队列以及绑定关系等等。项目引用该组件后能够自动初始化交换机和队列，并进行简单通信。 如若有其他需求，可自行扩展，例如消息消费的确认等
Java版Flink使用指南——将消息写入到RabbitMQ的队列中
方亮的专栏
07-08 276
在一文中，我们介绍了如何使用Java在Flink中读取RabbitMQ中的数据，并将其写入日志中。本文将通过代码产生一些数据，然后将它们写入到另外一个RabbitMQ队列中。
【RabbitMQ问题踩坑】RabbitMQ设置手动ack后，消息队列有多条消息，只能消费一条，就不继续消费了，这是为什么 ？
qq_39666711的博客
07-01 1254
此时如果队列中有3条消息的话，也就是ready中存在3条消息，unacked中存在一条，也就是total为4条，那及时其他的消息我修改代码，重新项目了，把注释的手动ack给放开了，那MQ中的情况也不会变，因为如果在代码中设置了消费者需要需要手动ack的话，如果一但存在了未ack的消息【unacked】的消息，那ready中都不会被消费。现象：我发送5条消息到MQ队列中，同时，我在yml中设置的是需要在代码中手动确认，但是我把代码中的手动ack给关闭了，会出现什么情况？
RabbitMQ快速入门 - 图像化界面的简单操作
LYJbao的博客
07-06 672
publisher：消息发送者consumer：消息的消费者queue：队列、存储消息exchange：交换机，负责路由消息virtual-host：虚拟主机，起到数据隔离的作用结合图来理解：消息发送者不是直接把消息塞到队列中，而是先把消息发到交换机，由交换机把消息路由到队列中；由上图可以发现交换机可以只路由给一个队列，也可以路由给所有队列；消费者监听队列，就可以拿到消息了~RabbitMQ的服务端（消息代理）就包括了交换机和队列两部分 ~
rabbitmq 通配符工作模式
09-02
RabbitMQ的通配符工作模式是指使用Topic Exchange来实现路由选择的一种模式。在这种模式下，队列可以绑定到一个模式上，使用符号"#"匹配一个或多个词，而符号"*"匹配不多不少一个词。例如，"audit.#"能够匹配到...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值