RabbitMQ基础（2）——发布订阅 fanout模式 &amp； topic模式 &amp； rabbitmq回调确认 &amp； 延迟队列（死信

最新推荐文章于 2024-07-07 18:42:45 发布
最新推荐文章于 2024-07-07 18:42:45 发布
阅读量624 收藏 17
点赞数 29
分类专栏： 程序员 文章标签： 单元测试 功能测试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84790808/article/details/138641028
版权

img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化的资料的朋友，可以戳这里获取

@Bean
public Binding mailBinding(){
    return BindingBuilder.bind(mailQueue())
            .to(fanoutExchange());
}

@Bean
public Binding phoneBinding(){
    return BindingBuilder.bind(phoneQueue())
            .to(fanoutExchange());
}

}


### 生产者生成验证码，发送给交换机



> 
> 接口
> 
> 
>

package com.tianju.auth.service;

public interface IUserService {

/\*\*

* 生产者生成信息发送给交换机
* @param msg 信息，这里是验证码
*/
void sendCode(String msg);
}



> 
> 实现
> 
> 
>

package com.tianju.auth.service.impl;

import com.tianju.auth.service.IUserService;
import com.tianju.auth.util.RabbitMqConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
@Slf4j
public class UserServiceImpl implements IUserService {

@Autowired
private RabbitTemplate rabbitTemplate;

@Override
public void sendCode(String msg) {
    rabbitTemplate.convertAndSend(
            RabbitMqConstants.MQ\_FANOUT\_EXCHANGE,
            "routingkey.fanout",
            msg);
    log.debug("[生产者向交换机：] 发送一条信息：{}",msg);
}

}



> 
> 测试类生成验证码，发给交换机
> 
> 
> 


![在这里插入图片描述](https://img-blog.csdnimg.cn/60bd08eab3a54dc083f1462219e4ccd7.png)

package com.tianju.auth.service.impl;

import cn.hutool.core.lang.Snowflake;
import com.tianju.auth.service.IUserService;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)

public class UserServiceImplTest {

@Autowired
private IUserService userService;

@Test
public void sendCode() {
    String code = new Snowflake().nextIdStr().substring(0, 6);
    System.out.println(code);
    userService.sendCode(code);
}

}


### 消费者消费验证码

package com.tianju.auth.consumer;

import com.tianju.auth.service.IEmailService;
import com.tianju.auth.util.RabbitMqConstants;
import com.tianju.auth.util.SMSUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class UserConsumer {
@Autowired
private IEmailService emailService;

@RabbitListener(queues = RabbitMqConstants.MQ\_MAIL\_QUEUE)
public void emailConsumer(String msg){
    log.debug("[email消费者：]消费{}",msg);
    emailService.sendEmail("xxxx@qq.com", "登陆验证码", msg);
}

@RabbitListener(queues = RabbitMqConstants.MQ\_PHONE\_QUEUE)
public void phoneConsumer(String msg){
    log.debug("[phone消费者：]消费{}",msg);
    SMSUtil.send("xxxx", msg);
}

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/ded10b5c9ff7438ba9e9b840ef547fcd.png)


## topic模式


![在这里插入图片描述](https://img-blog.csdnimg.cn/2585b426376e4860be43576eada8088a.png)



> 
> 例如： routingkey: my.orange.rabbit —-> Q1,Q2
> 
> 
> 


![在这里插入图片描述](https://img-blog.csdnimg.cn/5bbb30c09947481a95cb66771c21ccd1.png)


### 配置类增加配置

package com.tianju.auth.util;

/**
* rabbitmq的常量
*/
public interface RabbitMqConstants {
String MQ_MAIL_QUEUE=“mq_email_queue”;
String MQ_PHONE_QUEUE=“mq_phone_queue”;
String MQ_FANOUT_EXCHANGE=“mq_fanout_exchange”;

String MQ\_TOPIC\_EXCHANGE="mq\_topic\_exchange";

String MQ\_TOPIC\_QUEUE\_A = "mq\_topic\_queue\_a";
String MQ\_TOPIC\_QUEUE\_B = "mq\_topic\_queue\_b";

// 参数 String name, boolean durable, boolean exclusive, boolean autoDelete
boolean durable = true;
boolean exclusive = false;
boolean autoDelete = false;

}

package com.tianju.auth.config;

import com.tianju.auth.util.RabbitMqConstants;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMqConfig {

@Bean // 邮箱的队列
public Queue mailQueue(){
    return new Queue(RabbitMqConstants.MQ\_MAIL\_QUEUE,
            RabbitMqConstants.durable,
            RabbitMqConstants.exclusive,
            RabbitMqConstants.autoDelete);
}

@Bean // 电话的队列
public Queue phoneQueue(){
    return new Queue(RabbitMqConstants.MQ\_PHONE\_QUEUE,
            RabbitMqConstants.durable,
            RabbitMqConstants.exclusive,
            RabbitMqConstants.autoDelete);
}
@Bean // 交换机
public FanoutExchange fanoutExchange(){
    return new FanoutExchange(RabbitMqConstants.MQ\_FANOUT\_EXCHANGE,
            RabbitMqConstants.durable,
            RabbitMqConstants.autoDelete);
}

@Bean
public Binding mailBinding(){
    return BindingBuilder.bind(mailQueue())
            .to(fanoutExchange());
}

@Bean
public Binding phoneBinding(){
    return BindingBuilder.bind(phoneQueue())
            .to(fanoutExchange());
}



@Bean // A队列
public Queue topicAQueue(){
    return new Queue(RabbitMqConstants.MQ\_TOPIC\_QUEUE\_A,
            RabbitMqConstants.durable,
            RabbitMqConstants.exclusive,
            RabbitMqConstants.autoDelete);
}

/\*\*

* topic模式相关配置
*/

@Bean // B队列
public Queue topicBQueue(){
    return new Queue(RabbitMqConstants.MQ\_TOPIC\_QUEUE\_B,
            RabbitMqConstants.durable,
            RabbitMqConstants.exclusive,
            RabbitMqConstants.autoDelete);
}

@Bean // topic的交换机
public TopicExchange topicMyExchange(){
    return new TopicExchange(RabbitMqConstants.MQ\_TOPIC\_EXCHANGE,
            RabbitMqConstants.durable,
            RabbitMqConstants.autoDelete);
}


@Bean
public Binding topicAQueueBinding(){
    return BindingBuilder
            .bind(topicAQueue())
            .to(topicMyExchange())
            .with("topic.xxx"); // 规则 topic.xxx
}

@Bean
public Binding topicBQueueBinding(){
    return BindingBuilder
            .bind(topicBQueue())
            .to(topicMyExchange())
            .with("topic.\*"); // 规则 topic.xxx
}

}


### 生产者发送信息


![在这里插入图片描述](https://img-blog.csdnimg.cn/1481ecc9efaf41c091714b82c1bc347c.png)




/\*\*

* topic模式下，生产者发送信息给交换机，可以决定给哪个队列发信息
* @param msg 发送的信息
* @param routingKey 类似正则表达式，决定给谁发
* .with(“topic.xxx”); // 规则 topic.xxx ---- A队列
* .with(“topic.*”); // 规则 topic.xxx ---- B队列
* 在配置类中，如上所述配置，则如果输入的routingKey为 topic.xxx则给A和B发；
* 如果输入的routingKey为 topic.yyy 则 只给B队列发；
*/
void sendMsg(String msg,String routingKey);



> 
> 实现
> 
> 
>

package com.tianju.auth.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.tianju.auth.entity.UserPrivs;
import com.tianju.auth.mapper.UserMapper;
import com.tianju.auth.service.IUserService;
import com.tianju.auth.util.RabbitMqConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
@Slf4j
public class UserServiceImpl implements IUserService {

@Autowired
private RabbitTemplate rabbitTemplate;

@Override
public void sendCode(String msg) {
    rabbitTemplate.convertAndSend(
            RabbitMqConstants.MQ\_FANOUT\_EXCHANGE,
            "routingkey.fanout",
            msg);
    log.debug("[生产者向交换机：] 发送一条信息：{}",msg);
}

@Override
public void sendMsg(String msg,String routingKey) {
    rabbitTemplate.convertAndSend(
            RabbitMqConstants.MQ\_TOPIC\_EXCHANGE,
            routingKey, // "topic.yyy",此时只有B队列有信息
            msg);
    log.debug("[生产者向交换机：] 发送一条信息：{}",msg);
}

}


### 进行发送

package com.tianju.auth.service.impl;

import cn.hutool.core.lang.Snowflake;
import com.tianju.auth.service.IUserService;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)

public class UserServiceImplTest {

@Autowired
private IUserService userService;

@Test
public void sendCode() {
    String code = new Snowflake().nextIdStr().substring(0, 6);
    System.out.println(code);
    userService.sendCode(code);
}

@Test
public void sendTopic() {
    String code = new Snowflake().nextIdStr().substring(0, 6);
    System.out.println(code);
    userService.sendMsg(code,"topic.yyy");
}

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/dc40f7009a5e4067b60957ebebb4483b.png)


### 控制台查看


![在这里插入图片描述](https://img-blog.csdnimg.cn/214dd8bb1a8549ec9dd99fe23bb9586c.png)


## rabbitmq回调确认


### 配置类

spring:

rabbitmq的配置

rabbitmq:
host: 192.168.111.130
port: 5672
username: admin
password: 123
# 确认收到
publisher-confirm-type: correlated
publisher-returns: true


### 验证生产者发送是否成功



> 
> 使用RabbitTemplate的回调方法。
> 
> 
> 先设置
> 
> 
> * setConfirmCallback
> * setReturnsCallback
> 
> 
> 


![在这里插入图片描述](https://img-blog.csdnimg.cn/29c69a9533834a688520fa380ca3d84d.png)




@Autowired
private RabbitTemplate rabbitTemplate;

@Override
public void sendCode(String msg) {
    rabbitTemplate.convertAndSend(
            RabbitMqConstants.MQ\_FANOUT\_EXCHANGE,
            "routingkey.fanout",
            msg);
    log.debug("[生产者向交换机：] 发送一条信息：{}",msg);
}

@Override
public void sendMsg(String msg,String routingKey) {

    // 如果发到交换机，看一下有没有反馈
    rabbitTemplate.setConfirmCallback((c,ack,message)->{
        log.debug("\*\*\*\*\* setConfirmCallback：ack--{}", ack); // 是否发送到交换机
        log.debug("\*\*\*\*\* setConfirmCallback：c-->{}",c);
        // channel error; protocol method: #method<channel.close>(reply-code=404,
        // reply-text=NOT\_FOUND - no exchange 'aaaa' in vhost '/', class-id=60, method-id=40)
        log.debug("\*\*\*\*\* setConfirmCallback：m-->{}",message);
        if (ack){
            log.debug("[生产者：] 发送信息到交换机{}","RabbitMqConstants.MQ\_TOPIC\_EXCHANGE");
        }else {
            log.debug(message);
        }
    });

    rabbitTemplate.setReturnsCallback(r->{
        log.debug("返回文字{}", r.getReplyText());
        log.debug("返回code{}", r.getReplyCode());
        log.debug("返回Exchange{}", r.getExchange());
        log.debug("返回RoutingKey{}", r.getRoutingKey());
    });


    rabbitTemplate.convertAndSend(
            RabbitMqConstants.MQ\_TOPIC\_EXCHANGE,

// “aaaa”,// 失败的情况
routingKey, // “topic.yyy”,此时只有B队列有信息
msg);

    log.debug("[生产者向交换机：] 发送一条信息：{}",msg);
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/add6f272ff754d5aa96bc788bc0f9b18.png)

rabbitTemplate.setConfirmCallback((c,ack,message)->{
log.debug(“******* setConfirmCallback:ack->{}”,ack);
log.debug(“******* setConfirmCallback:c->{}”,c);
log.debug(“******* setConfirmCallback:chanel->{}”,message);
if(ack){
log.debug(“[生产者]发送信息到达交换机{}”,“RabbitMqConstants.MQ_TOPIC_EXCHANGE”);
}else {
log.debug(message);
}
});
rabbitTemplate.setReturnsCallback(r->{
log.debug(“返回文字:{}”,r.getReplyText());
log.debug(“返回code:{}”,r.getReplyCode());
log.debug(“返回Exchange:{}”,r.getExchange());
log.debug(“返回RoutingKey:{}”,r.getRoutingKey());
});
rabbitTemplate.convertAndSend(
RabbitMqConstants.MQ_TOPIC_EXCHANGE,
“abc.xxx”,
msg
);




@Test
public void sendTopic() {
    String code = new Snowflake().nextIdStr().substring(0, 6);
    System.out.println(code);
    userService.sendMsg(code,"topic.rrr");
}


## 延迟队列（死信）设计


[Documentation: Table of Contents — RabbitMQ]( )


![在这里插入图片描述](https://img-blog.csdnimg.cn/8d012596a93d45acaf606bcef7dde082.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/15d187f391624fa6aa3905df97230d56.png)


### java代码步骤


#### 创建正常+死信队列

package com.tianju.mq.config;

import com.tianju.mq.constants.RabbitMqConstants;
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;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class RabbitMqConfig {

@Bean
public DirectExchange normalExchange(){
    return new DirectExchange(RabbitMqConstants.MQ\_NORMAL\_EXCHANGE,
            RabbitMqConstants.durable,
            RabbitMqConstants.autoDelete);
}
@Bean
public Queue normalQueue(){
    Map<String, Object> map = new HashMap<>(2);
    map.put("x-dead-letter-exchange",RabbitMqConstants.MQ\_DELAY\_EXCHANGE);
    map.put("x-dead-letter-routing-key",RabbitMqConstants.MQ\_DELAY\_ROUTING\_KEY);
    return new Queue(
            RabbitMqConstants.MQ\_NORMAL\_QUEUE,
            RabbitMqConstants.durable,
            RabbitMqConstants.exclusive,
            RabbitMqConstants.autoDelete,
            map);
}
@Bean
public Binding normalBinding(){
    return BindingBuilder.bind(normalQueue())
            .to(normalExchange())
            .with(RabbitMqConstants.MQ\_NORMAL\_ROUTING\_KEY);
}


//------------------死信队列设计--------------------------
/\*\*

* 死信(延迟)队列
* @return
*/
@Bean
public Queue delayQueue(){
return new Queue(RabbitMqConstants.MQ_DELAY_QUEUE,
RabbitMqConstants.durable,
RabbitMqConstants.exclusive,
RabbitMqConstants.autoDelete);
}
/**
* 死信交换机
* @return
*/
@Bean
public DirectExchange delayExchange(){
return new DirectExchange(RabbitMqConstants.MQ_DELAY_EXCHANGE,
RabbitMqConstants.durable,
RabbitMqConstants.autoDelete);
}
/**
* 死信交换机队列绑定
* @return
*/
@Bean
public Binding delayBinding(){
return BindingBuilder.bind(delayQueue())
.to(delayExchange())
.with(RabbitMqConstants.MQ_DELAY_ROUTING_KEY);
}
}


#### 配置类+常量

package com.tianju.mq.constants;

public interface RabbitMqConstants {
String MQ_DELAY_QUEUE = “mq_delay_queue”; // 延迟队列，死信队列
String MQ_DELAY_EXCHANGE = “mq_delay_exchange”; // 死信交换机
String MQ_DELAY_ROUTING_KEY = “mq_delay_routing_key”; // 死信路由

// 正常的队列，交换机，路由
String MQ\_NORMAL\_QUEUE = "mq\_normal\_queue";
String MQ\_NORMAL\_EXCHANGE = "mq\_normal\_exchange";
String MQ\_NORMAL\_ROUTING\_KEY = "mq\_normal\_routing\_key";

// 参数
boolean durable = true;
boolean exclusive = false;
boolean autoDelete = false;

}

server:
port: 9099

spring:

邮箱的配置

mail:
host: smtp.qq.com
port: 587
username: xxxxx.com
password: xxxxx

rabbitmq的配置

rabbitmq:
host: 192.168.111.130
port: 5672
username: admin
password: 123
# 确认收到
publisher-confirm-type: correlated
publisher-returns: true

logging:
level:
com.tianju.mq: debug


### 生产者到正常队列

package com.tianju.mq.service;

public interface IUserService {
/**
* 延迟队列的生产者
* @param msg 发送的信息
* @param delayTime 延迟的时间，毫秒
*/
void sendDelay(String msg,int delayTime);
}

package com.tianju.mq.service.impl;

import com.tianju.mq.constants.RabbitMqConstants;
import com.tianju.mq.service.IUserService;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

`
package com.tianju.mq.service.impl;

import com.tianju.mq.constants.RabbitMqConstants;
import com.tianju.mq.service.IUserService;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service

[外链图片转存中…(img-u2B9pptr-1715282502426)]
[外链图片转存中…(img-LnKlcIoB-1715282502427)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84790808
关注
专栏目录
【架构】关于RabbitMQ
l192168134的博客
04-21 5120
1      什么是RabbitMQ？ RabbitMQ是实现AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然：   单向解耦   双向解耦（如：RPC）     例如一个日志系统，很容易使用RabbitM
SpringBoot+RabbitMq实现生产者与消费者的多种情景
qq_35414397的博客
09-27 1万+
一、新建maven工程：springboot-rabbitmq 二、引入springboot和rabbitmq的依赖  &amp;lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://...
spring集成rabbitMq(基于direct、topic和fanout模式)
11-15
spring集成rabbitMq(基于direct、topic和fanout模式)，包括main方法，5种情景，一天总结运行
rabbitmq交换机之fanout丶direct丶Topic（三）
旅人的博客
08-31 474
文章目录ExchangesExchanges 的类型绑定fanout模式代码演示direct模式代码演示Topic模式 Exchanges RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。生产者只能将消息发送到交换机(exchange)，交换机工作的就是接收来自生产者的消息，另一方面将它们推入队列。因此交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把消息推到许多队列中还是说应该丢弃它们，这就的由交换机的类型来决定。 Exchanges 的类型 总
RabbitMQ中常用的三种交换机【Fanout、Direct、Topic】
最新发布
LYJbao的博客
07-07 1613
此时支付服务会把支付结果发送到交换机中，而短信服务就会去监听这个交换机，但是交换机不会把所有的消息都路由给短信服务，而只把支付成功的消息路由给这个短信服务。这种情况下，就需要使用到这个Direct交换机，短信服务下的队列和这个交换机设置一个key（例如：success），支付服务发消息时，支付成功RoutingKey设为success，失败为fail，交换机就会只把key为success的消息路由给短信服务了~上图中，就是，key为blue，消费者1去消费；一个只能接到新闻，一个只能接到和中国相关的消息~
RabbitMQ 主题（Topic）
weixin_34319817的博客
11-13 56
　　我们进步改良了我们的日志系统。我们使用direct类型转发器，使得接收者有能力进行选择性的接收日志,，而非fanout那样，只能够无脑的转发。 　　虽然使用direct类型改良了我们的系统，但是仍然存在一些局限性：它不能够基于多重条件进行路由选择。　　在我们的日志系统中，我们有可能希望不仅根据日志的级别而且想根据日志的来源进行订阅。这个概念类似unix工具：syslog，它转发日志基于严重性（...
RabbitMQ fanout
笑一个吧
01-13 456
fanout 广播 发布订阅 生产者 package fanout; import com.jia.RabbitMQMain; import com.jia.utils.RabbitMQUtils; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import org.junit.Test; import java.io.IOException; /** * @program: RabbitMQL
Spring整合RabbitMQ（二）之注解实现
Liam1994的博客
06-15 4100
1、增加rabbitmq的依赖包&amp;lt;!-- ampq 依赖包 --&amp;gt; &amp;lt;dependency&amp;gt;             &amp;lt;groupId&amp;gt;com.rabbitmq&amp;lt;/groupId&amp;gt;             &amp;lt;artifactId&amp;gt;amqp-client&amp;lt;/artifactId&amp;gt;             &amp;lt;version&amp;
rabbitmq简介，安装，api操作
huoyunp的博客
01-11 552
rabbitmq介绍 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。 RabbitMQ是一个开源的AMQP实现，服务器端用Erl
springboot集成rabbitmq（一）
Tracyclock的博客
02-08 523
1.pom文件&amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.springframework.boot&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;spring-boot-starter-amqp&amp;lt;/artifactId&amp;gt; &amp;lt;/dependency&amp;gt;2.application.ym文件mq.rabbit.h...
rabbitmq-fanout（广播模式）
热门推荐
fakerswe的博客
08-06 5万+
RabbitMQ—fanout（广播模式） RabbitMQ—fanout（广播模式） 一、什么是fanout(广播模式) 二、代码域 1. 生产者【FanoutBoss】 2. 消费者【FanoutWorker】 三、广播模式效果 1. 先运行三个消费者，即【FanoutWorker】 控制台效果图如下，三个消费者等待接收消息 RabbitMQ网页控制台如下，可看到三个消费者队列 ...
RabbitMQ详解（三）：消息模式（fanout、direct、topic、work）
weixin_45181611的博客
05-10 3504
消息模式详解
rabbitmq fanout
qq_33002953的博客
05-13 109
import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; public class Producer4FanoutExchange { public static void main(String...
RabbitMQ Fanout
Leon_Jinhai_Sun的博客
10-12 132
Fanout这种类型非常简单。正如从名称中猜到的那样，它是将接收到的所有消息广播到它知道的所有队列中。系统中默认有些exchange类型
RabbitMQ入门（六）RabbitMQ交换器之fanout
jwang的博客
10-12 574
前言 本章讲解RabbitMQ常用交换器的最后一个类型——fanout 方法 1.概念 fanout（广播），顾名思义，其可以不依赖路由键，向所有绑定了的队列发送消息。 广播的含义就是将消息发送给所有订阅该频道的听众。 需求：我们的用户下订单之后，我们会做如下的两步操作：发短信、推送订单，在以前的模式上，我们下订单的业务逻辑和发短信，推送订单的逻辑是强耦合的，当我们使用Ra...
RabbitMQ基础（2）——发布订阅/fanout模式 & topic模式 & rabbitmq回调确认 & 延迟队列（死信）设计
Arya的博客，专注后端领域
08-10 1942
1.rabbitmq队列方式的梳理，点对点，一对多； 2.发布订阅模式，交换机到消费者，以邮箱和手机验证码为例； 3.topic模式，根据规则决定发送给哪个队列； 4.rabbitmq回调确认，setConfirmCallback和setReturnsCallback； 5.死信队列，延迟队列，创建方法，正常---死信，设置延迟时间；
Rabbitmq fanout与topic区别
fwk19840301的博客
06-20 1万+
RabbitMQ服务器会根据路由键将消息从交换器路由到队列中，如何处理投递到多个队列的情况？这里不同类型的交换器起到了重要的作用。 最常用的交换机有三种：direct、topic、fanout。我分别叫他们：“直接连接交换机”，“主题路由匹配交换机”，“无路由交换机” fanout fanout类型的Exchange路由规则非常简单，它会把所有发送到该Exchange的消息路由到所有与它绑定...
Rabbitmq运用之fanout模式
yu240956419的博客
05-11 5727
Rabbitmq之fanout模式，属于多播模式，里面消费写了两种写法，方法和时间，注释内容详细
RabbitMQ Exchange深度解析：fanout、direct与topic模式
"这篇文章主要介绍了RabbitMQ的Exchange模式，包括Fanout、Direct和Topic三种模式，以及如何在代码中实现生产者和消费者的示例。" 在AMQP（Advanced Message Queuing Protocol）协议中，RabbitMQ作为消息队列服务器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值