RabbitMQ的常用交换机在springboot中的使用

已于 2022-09-29 13:56:37 修改
阅读量1.1k 收藏 4
点赞数 1
分类专栏： MQ 文章标签： java-rabbitmq rabbitmq java
于 2022-09-29 13:53:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w13966597931/article/details/127105242
版权

如果没有安装rabbitmq》》》》linux安装rabbitmq

一、导入依赖

<!--AMQP依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

二、编写配置

下面配置都是spring:下的

rabbitmq:
  host: 44.98.18
  username: guest
  password: guest
  # 虚拟主机
  virtual-host: /
  port: 5672
  listener:
    simple:
      # 消费者最小数量
      concurrency: 10
      # 消费者最大数量
      max-concurrency: 10
      # 限制消费者每次只能处理一条消息，处理完再继续处理下一条消息
      prefetch: 1
      # 启动时是否默认启动容器，默认true
      auto-startup: true
      # 拒绝策略：被拒绝时是否重新进入队列
      default-requeue-rejected: true
  template:
    retry:
      # 发布重试，默认false
      enabled: true
      # 重试时间默认1000ms
      initial-interval: 1000ms
      # 重试次数,默认3
      max-attempts: 3
      # 重试最大间隔时间，默认10000ms
      max-interval: 10000ms
      # 重试的间隔乘数，比如配置2.0，第一次等10s，第二次等20s，第三次等40秒
      multiplier: 1

一个简单队列

需要创建一个配置类，然后创建一个生产者，再创建一个消费者，之后在具体的业务中调用生产者就欧克了

创建一个队列 RabbitMQConfig.java

/**
 * <p>
 * RabbitMQ配置类
 * </p>
 *
 * @author wangmh
 * @since 2022/9/20 17:01
 */
@Configuration
public class RabbitMQConfig {

    @Bean
    public Queue queue(){
        // 名字，是否持久化
        return new Queue("queue",true);
    }

}

生产者：MQSender.java

@Service
@Slf4j
public class MQSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(Object msg){
        log.info("发送消息："+msg);
        rabbitTemplate.convertAndSend("queue",msg);
    }

}

消费者：MQReceiver.java

@Service
@Slf4jd
public class MQReceiver {

    // 监听这个队列
    @RabbitListener(queues = "queue")
    public void receive(Object msg){
        log.info("接收消息"+msg);
    }

}

输出结果

结果：
2022-09-20 19:43:49.720  INFO 11180 --- [nio-8080-exec-1] com.example.rabbitmq.MQSender            : 发送消息：hello
2022-09-20 19:43:49.853  INFO 11180 --- [ntContainer#0-9] com.example.rabbitmq.MQReceiver          : 接收消息(Body:'hello' MessageProperties [headers={}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=, receivedRoutingKey=queue, deliveryTag=1, consumerTag=amq.ctag-rr1oDI2wtJb1Np0jucHeGw, consumerQueue=queue])

交换机

一、fanout

广播模式，把队列和交换机进行绑定，转发消息是最快的，因为他不需要去处理路由键

发送到交换机的消息，会被转发到和这个交换机绑定的所有队列上（发布订阅模式

在配置文件中配置2个队列，1个交换机，把这个交换机和2个队列做绑定

@Configuration
public class RabbitMQConfig {

    private static final String QUEUE01 = "queue_fanout01";
    private static final String QUEUE02 = "queue_fanout02";
    private static final String EXCHANGE = "fanoutExchange";

    @Bean
    public Queue queue01(){
        return new Queue(QUEUE01);
    }

    @Bean
    public Queue queue02(){
        return new Queue(QUEUE02);
    }


    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange(EXCHANGE);
    }

    // 绑定交换机和队列
    @Bean
    public Binding binding01(){
        return BindingBuilder.bind(queue01()).to(fanoutExchange());
    }

    @Bean
    public Binding binding02(){
        return BindingBuilder.bind(queue02()).to(fanoutExchange());
    }

}

发送：

@Autowired
private RabbitTemplate rabbitTemplate;

public void send01(Object msg){
    log.info("发送消息："+msg);
    rabbitTemplate.convertAndSend("fanoutExchange","",msg);
}

接收 :

@RabbitListener(queues = "queue_fanout01")
public void receive01(Object msg){
    log.info("queue01："+msg);
}

@RabbitListener(queues = "queue_fanout02")
public void receive02(Object msg){
    log.info("queue02 :"+msg);
}

运行后就可以看到控制台的变化：

 

 结果：

二、direct

所有被发送到direct交换机上的消息，都会被转发到路由key中指定的一个queue

和fanout相比，就是多了一个key，匹配的时候根据key进行匹配

发送的时候要带有路由key,如果匹配不到默认上会丢失，但是我们在yaml中配置了，发送失败重新进入队列

但是：

当项目使用的时间越来越就，路由key就会越来越多，就会变得越来越难管

RabbitMQConfig.java

@Configuration
public class RabbitMQConfig {

    private static final String QUEUE01 = "queue_direct01";
    private static final String QUEUE02 = "queue_direct02";
    private static final String EXCHANGE = "directExchange";
    private static final String ROUTINGKEY01 = "queue.red";
    private static final String ROUTINGKEY02 = "queue.green";

    @Bean
    public Queue queue01(){
        return new Queue(QUEUE01);
    }

    @Bean
    public Queue queue02(){
        return new Queue(QUEUE02);
    }

    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange(EXCHANGE);
    }

    // 绑定队列和交换机，这种模式需要指定路由key
    @Bean
    public Binding binding01(){
        return BindingBuilder.bind(queue01()).to(directExchange()).with(ROUTINGKEY01);
    }

    @Bean
    public Binding binding02(){
        return BindingBuilder.bind(queue02()).to(directExchange()).with(ROUTINGKEY02);
    }

}

发送者：

@Service
@Slf4j
public class MQSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send02(Object msg){
        log.info("发送红色的消息：："+msg);
        rabbitTemplate.convertAndSend("directExchange","queue.red",msg);
    }

    public void send03(Object msg){
        log.info("发送绿色的消息：："+msg);
        rabbitTemplate.convertAndSend("directExchange","queue.green",msg);
    }

}

接收者：

@Service
@Slf4j
public class MQReceiver {

    // 监听这个队列
    @RabbitListener(queues = "queue_direct01")
    public void receive02(Object msg){
        log.info("queue_direct01："+msg);
    }

    @RabbitListener(queues = "queue_direct02")
    public void receive03(Object msg){
        log.info("queue_direct02 :"+msg);
    }

}

测试

@RequestMapping("/direct")
@ResponseBody
public void mq01(){
    mqSender.send02("hello+red");
    mqSender.send03("hello+green");
}

运行结果：

 看到管控台可以看到，对应的交换机，队列，和队列对应的key

三、topic

*只能替代1个词

#可以替代0个或多个词、

可以说是 direct模式的延申，方便我们管理路由key

所有发送到主机交换机的消息都会被转发到所有的路由ley中，所指定的topic的queue上去， 交换机会将路由key和topic模糊匹配，此时，队列需要绑定一个topic

RabbitMQConfig.java

@Configuration
public class RabbitMQConfig {

    private static final String QUEUE01 = "queue_topic01";
    private static final String QUEUE02 = "queue_topic02";
    private static final String EXCHANGE = "topicExchange";
    private static final String ROUTINGKEY01 = "#.queue.#";
    private static final String ROUTINGKEY02 = "*.queue.#";

    @Bean
    public Queue queue01(){
        return new Queue(QUEUE01);
    }

    @Bean
    public Queue queue02(){
        return new Queue(QUEUE02);
    }

    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(EXCHANGE);
    }

    // 绑定队列和交换机，这种模式需要指定路由key
    @Bean
    public Binding binding01(){
        return BindingBuilder.bind(queue01()).to(topicExchange()).with(ROUTINGKEY01);
    }

    @Bean
    public Binding binding02(){
        return BindingBuilder.bind(queue02()).to(topicExchange()).with(ROUTINGKEY02);
    }

}

发送消息：

@Service
@Slf4j
public class MQSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send01(Object msg){
        log.info("发送消息Queue1：："+msg);
        rabbitTemplate.convertAndSend("topicExchange","queue.red.message",msg);
    }

     public void send02(Object msg){
        log.info("发送消息，被queue1+queue2接收：："+msg);
        rabbitTemplate.convertAndSend("topicExchange","message.queue.green",msg);
    }

}

接收消息

@Service
@Slf4j
public class MQReceiver {

    // 监听这个队列
    @RabbitListener(queues = "queue_topic01")
    public void receive02(Object msg){
        log.info("queue_topic01："+msg);
    }

    @RabbitListener(queues = "queue_topic02")
    public void receive03(Object msg){
        log.info("queue_topic02 :"+msg);
    }

}

测试

@RequestMapping("/topic")
@ResponseBody
public void mq01(){
    mqSender.send02("hello+red");
    mqSender.send02("hello+green");
}

结果

 和刚刚一样，可以去管控太去查看响应的交换机和队列的信息

三、Headers模式

并不依赖于路由key

whereAll() 多个键值对都要满足

whereAny() 任意一个键值对满足即

RabbitMQConfig.java

@Configuration
public class RabbitMQConfig {

    private static final String QUEUE01 = "queue_headers01";
    private static final String QUEUE02 = "queue_headers02";
    private static final String EXCHANGE = "headerExchange";

    @Bean
    public Queue queue01(){
        return new Queue(QUEUE01);
    }

    @Bean
    public Queue queue02(){
        return new Queue(QUEUE02);
    }

    @Bean
    public HeadersExchange headersExchange(){
        return new HeadersExchange(EXCHANGE);
    }

    // 绑定队列和交换机，这种模式需要指定路由key
    @Bean
    public Binding binding01(){
        Map<String , Object> map = new HashMap<>();
        map.put("color","red");
        map.put("speed","low");
        // 两个只需要匹配一个
        return BindingBuilder.bind(queue01()).to(headersExchange()).whereAny(map).match();
    }

    @Bean
    public Binding binding02(){
        Map<String , Object> map = new HashMap<>();
        map.put("color","red");
        map.put("speed","fast");
        // 必须要两个同时匹配上才可以
        return BindingBuilder.bind(queue02()).to(headersExchange()).whereAll(map).match();
    }

}

发送消息：

public void send01(String msg){
    log.info("发送两个都能接收的：："+msg);
    MessageProperties properties = new MessageProperties();
    properties.setHeader("color","red");
    properties.setHeader("speed","fast");
    Message message = new Message(msg.getBytes(),properties);
    rabbitTemplate.convertAndSend("headerExchange","",message);
}

public void send02(String msg){
    log.info("发送消息，queue1接收：："+msg);
    MessageProperties properties = new MessageProperties();
    properties.setHeader("color","red");
    properties.setHeader("speed","normal");
    Message message = new Message(msg.getBytes(),properties);
    rabbitTemplate.convertAndSend("headerExchange","",message);
}

接收消息：

@RabbitListener(queues = "queue_headers01")
public void receive01(Message message){
    log.info("queue01接收Message对象："+message);
    log.info("queue01接收消息："+ new String(message.getBody()));
}

@RabbitListener(queues = "queue_headers02")
public void receive02(Message message){
    log.info("queue02接收Message对象："+message);
    log.info("queue02接收消息："+ new String(message.getBody()));
}

测试：

@RequestMapping("/direct")
@ResponseBody
public void mq01(){
    mqSender.send01("王萌虎");
    mqSender.send02("wangmenghu");
}

结果：

Wmenghu
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot RabbitMQ - 交换器
Happy Simon
01-18 151
今天跟大家分享下Spring Boot RabbitMQ - 交换器的知识。 1 fanout exchange 发送到该交换器的所有消息，会被路由到其绑定的所有队列。不处理路由键。你只需要简单的将队列绑定到交换机上。一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。Fanout交换机转发消息是最快的。 如图所示，所有发送到 f...
RabbitMQ连接池+SpringBoot实现
02-11
RabbitMQ连接池+SpringBoot实现。通过连接池实现将高效的管理RabbitMQ的Connection，并与springboot进行整合，实现消息发送，获取队列列表等功能。基于此可以进行更多功能的扩充。
SpringBoot整合RabbitMQ，三种交换机类型示例
最新发布
相关项目可以查看https://gitee.com/fan-pl或https://github.com/fpl1116
04-09 496
SpringBoot整合RabbitMQ，三种交换机类型示例
SpringBoot整合RabbitMQ——Direct交换机
SK_Jaco的博客
07-17 1086
文章目录SpringBoot整合RabbitMQ——Direct交换机简介依赖application.yml配置消息生产者（发送端）配置，端口9000消费者（接收端）配置，端口8088消息生产者（发送端）配置SendConfig.javaController层Service层消费者（接收端）验证 SpringBoot整合RabbitMQ——Direct交换机 简介 Direct Exchange是...
springboot整合rabbitmq-交换机模式
zwjzone的博客
05-06 1065
rabbitmq交换机模式direct和topic演示
SpringBoot 集成 RabbitMQ 常用交换机
Mrqiang9001
10-11 930
文章目录1 摘要2 常用交换机简介2.1 direct exchange2.2 Topic exchange2.3 Fanout exchange3 核心代码3.1 RabbitMQ 配置定义3.2 RabbitMQ 生产者3.3 RabbitMQ 消费者3.4 测试类(Controller)4 RabbitMQ 参数配置说明5 测试6 推荐参考资料7 本次提交记录 ​ ​ 1 摘要 RabbitMQ 消息队列四种交换机，分别是: 直连交换机(Direct exchange)、主题交换机(Topic exc
springboot+RabbitMq交换器Direct的demo
03-21
https://blog.csdn.net/qq_32786139/article/details/88709937 对应博客讲解 直接看博客也可以 为啥上传的时候 没有 设置积分这一项呢...
springboot使用rabbitmq工具类
03-29
springboot使用rabbitmq工具类,里面包含比较原生的方法,还有一套是我结合springboot框架写的一套方法,里面有两个方法,看情况使用,一般使用框架的方法比较好,因为框架方法时前辈们封装好经过检验的没有问题的方法,...
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
SpringBoot之RabbitMQ的使用方法
08-26
在SpringBoot中整合RabbitMQ非常简单，首先还是pom.xml引入依赖。然后在application.properties中配置RabbitMQ相关的信息，并首先启动了RabbitMQ实例，并创建两个queue。配置Queue（消息队列），由于采用的是Direct...
SpringBoot整合RabbitMQ——Fanout交换机
SK_Jaco的博客
07-17 2430
文章目录SpringBoot整合RabbitMQ——Fanout交换机简介依赖application.yml配置消息生产者（发送端）配置，端口9001消费者1（接收端）配置，端口8001消费者2（接收端）配置，端口8002消息生产者（发送端）SendConfig.java配置信息Controller层Service层消费者（接收端）消费者1消费者2验证 SpringBoot整合RabbitMQ——...
Spring Boot RabbitMQ 入门（三）之 Fanout交换器
自由
02-16 2783
0.回顾Spring Boot RabbitMQ 入门（二） 环境搭建 上篇文章我们学习了以下几点： * 1.如何创建交换器 * 2.如何创建对列 * 3.如何将队列绑定到交换器 * 4.如何创建消费者1.Exchange功能介绍交换器的作用：当你想将消息投递到对列的时候，你通过把消息交给交换器，通过交换器匹配一些规则，根据这些规则RabbitMQ知道将消息投递到哪个队列。这些规则就是路由
Springboot集成rabbitMQ之mandatory和备份交换机
sinat_34397278的博客
10-01 755
本文介绍了springboot集成rabbitmq以及mandatory和备份交换机，以及相关问题。
SpringBoot整合RabbitMQ——Topic 交换机
SK_Jaco的博客
07-17 1702
文章目录SpringBoot整合RabbitMQ——Topic交换机简介依赖application.yml配置消息生产者（发送端）SendConfig.java配置信息Controller层Service层消费者（接收端）测试 SpringBoot整合RabbitMQ——Topic交换机 简介 Topic交换机与Direct相似，通过与交换机绑定队列的路由键进行消息分发。不同的是Topic可以通过......
RabbitMQ篇六 springboot_rabbitMQ 提供者与消费者（扇型交换机）
bluewelkin的专栏
07-23 249
一、生产者端 /** * 创建三个队列 ：fanout.A fanout.B fanout.C * 将三个队列都绑定在交换机 fanoutExchange 上 * 因为是扇型交换机, 路由键无需配置,配置也不起作用 */ @Configuration public class FanoutRabbitConfig { /** * 创建三个队列 ：fanout.A fanout.B fanout.C * 将三个队列都绑定在交换机 fa
springboot与rabbitmq的整合【演示5种基本交换机】
学习笔记，相关教程 分享
07-15 3014
rabbitmq的5种交换机与springboot的案例。
rabbitMq与spring boot搭配实现监听
weixin_30340353的博客
08-23 358
　　在我前面有一篇博客说到了rabbitMq实现与zk类似的watch功能，但是那一篇博客没有代码实例，后面自己补了一个demo，便于理解。demo中主要利用spring boot的配置方式， 一、消费者（也就是watcher）配置 配置都采用spring的注解进行配置 1、创建连接 　　@Bean public ConnectionFactory createConnect...
rabbitmq使用topic类型交换机springboot
07-23
总结一下，通过配置文件和代码的方式，我们可以在Spring Boot中使用RabbitMQ的Topic类型交换机。只需要定义好RabbitMQ的连接信息和交换机的相关信息，然后调用RabbitTemplate对象的convertAndSend方法来发送消息即可...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值