Spring Boot 注解方式 实现RabbitMQ

最新推荐文章于 2024-04-18 01:02:38 发布
最新推荐文章于 2024-04-18 01:02:38 发布
阅读量4.6k 收藏 18
点赞数 3
分类专栏： SpringBoot 文章标签： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq331709114/article/details/88319598
版权
1.简介

MQ为message queue消息队列，是程序与程序之间的通讯方法；
RabbitMQ是由erlang（面向并发的编程语言）语言进行开发，遵循的是AMQP（Advanced Message Queue ）协议，支持市面上所有的主流的操作系统且支持多种语言开发

2.基础概念
  1. Producer(生产者)：生产者用于发布消息。
  2. Consumer(消费者)：用于从队列中获取消息,消费者只需关注队列即可，不需要关注交换机和路由键。
  3. Queue(队列):用于存储消息,特性是先进先出,生产者生产的消息会发送到交换机中，交换机将消息存储到某个或某些队列中,最终被消费者消费。
  4. Exchange(交换机)：生产者会将消息发送到交换机，然后交换机通过路由策略(规则)将消息路由到匹配的队列中去。 Exchange不存储消息，Exchange 常用的三种类型Fanout、Direct、Topic ，每种类型对应不同的路由规则。
  5. Routing Key(路由键)：用于定义路由规则，当路由键和队列绑定的路由键匹配时，消息就会发送到该队列。
  6. Binding(绑定)：以路由键为规则将Exchange与Queue关联起来(Exchange—>Routing Key—>Queue)
3.五种类型
  1. 简答模式

在这里插入图片描述
使用默认的交换机，生产者直接把消息发送到Queue中，消费者从Queue中获取消息。

  1. work模式

在这里插入图片描述
使用默认的交换机，多个消费者同时绑定一个队列，队列中的消息会被平摊给多个消费者，默认使用公平分发策略，效率高的就会一直空闲，效率低的一直忙，可以设置每次消费的数量使效率高的多消费

  1. 广播模式（Fanout）
    在这里插入图片描述
    生产者把数据根据交换机的名称推送到对应的交换机上，再把消息发送给与其绑定的所有队列中，消费者在从对应的队列中消费数据。（不管路由键，只需要绑定到交换机上）

  2. 路由模式（Direct）
    在这里插入图片描述
    生产者先把消息发送到交换机，交换机会根据路由规则（binding key与routing key完全匹配）发送到对应的队列中去，消费者再去消费对应的消息（需要路由键完全匹配）

  3. 通配符模式（Topic）

在这里插入图片描述
与路由模式相同，只是在路由规则上进行了扩展，routing key跟binding key都是用 “.” 进行分割，分隔开的每一段字符串是一个单词。
例： aaaaa.ndsds.dsad
binding key中有两种特殊字符 “*”跟 ”#”，*用于匹配一个单词，#可以匹配多个或零个单词（路由键模糊匹配）

4.代码演示
  1. 添加对应POM文件
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
  1. .在properties中加入对应的配置
spring.rabbitmq.host=
spring.rabbitmq.port=
spring.rabbitmq.username=
spring.rabbitmq.password=
spring.rabbitmq.virtual-host=
#每次从队列中取一个,轮询分发，默认是公平分发
spring.rabbitmq.listener.simple.prefetch=1
#失败后重试
spring.rabbitmq.listener.simple.default-requeue-rejected=true

简单模式生产者

 @RestController
@Slf4j
@RequestMapping("SimpleSender")
public class SimpleSender {

    @Autowired
    private AmqpTemplate amqpTemplate;

    @GetMapping("simple")
    public void simpleSend(String content){
        log.info("简单队列发送消息：{}",content);
        this.amqpTemplate.convertAndSend("simple",content);

    }

}

简单模式消费者

@Component
@Slf4j
public class SimpleReceiver {

    
    //监听simple队列，如果没有此队列先进性创建 简单队列消费者 返回值必须void
    @RabbitListener(queuesToDeclare =@Queue("simple") )
    @RabbitHandler
    public void SimpleReceiver(String conten){
        log.info("开始消费简单队列消息:{}",conten);
    }

}

work模式生产者

@RestController
@Slf4j
@RequestMapping("WorkSender")
public class WorkSender {

    @Autowired
    private AmqpTemplate amqpTemplate;

    @GetMapping("workSender")
    public void workSender(String content){
        log.info("work模式发送消息：{}",content);
       this.amqpTemplate.convertAndSend("work",content);
    }
}

work模式消费者

@Slf4j
@Component
//放在类上，监听到消息后会交给@RabbitHandler的方法进行处理，如果有多个方法,会根据参数类型进行选择
//@RabbitListener(queuesToDeclare = @Queue("work") )
public class WorkReceiver {

    @RabbitListener(queuesToDeclare = @Queue("work"))
    @RabbitHandler
    public void workReceiver1(String content) throws InterruptedException {
        log.info("work模式开始消费1：{}",content);
        Thread.sleep(1000);

    }

    @RabbitListener(queuesToDeclare = @Queue("work") )
    @RabbitHandler
    public void workReceiver2(String content, Channel channel) throws IOException, InterruptedException {
        log.info("work模式开始消费2：{}",content);
        Thread.sleep(2000);

    }
}

广播模式生产者

@RestController
@Slf4j
@RequestMapping("FanoutSender")
public class FanoutSender {
    @Autowired
    private AmqpTemplate amqpTemplate;

    @GetMapping("fanoutSender")
    public  void  fanout(String content){
        log.info("fanout开始广播数据：{}",content);
        this.amqpTemplate.convertAndSend("fanout.test","",content);
    }
}

广播模式消费者

@Slf4j
@Component
public class FanoutReceiver {

    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("fanout1"),
            exchange = @Exchange("fanout.test")
    ))
    public void fanoutReceiver2(String content){
        log.info("广播模式1开始消费：{}",content);
    }

    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("fanout2"),
            exchange = @Exchange("fanout.test")
    ))
    public void fanoutReceiver1(String content){
        log.info("广播模式2开始消费：{}",content);
    }

路由模式生产者

@Slf4j
@RestController
@RequestMapping("DirectSender")
public class DirectSender {

    @Autowired
    private AmqpTemplate amqpTemplate;

    @GetMapping("directSender")
    public void directSender(String content,String key){
        log.info("路由模式开始生产消息：{},key:{}",content,key);
        this.amqpTemplate.convertAndSend("direct.test",key,content);
    }
}

路由模式消费者

@Slf4j
@Component
public class DirectReceiver {

    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("direct1"),
            exchange = @Exchange("direct.test"),
            key = "a"
    ))
    public  void directReceiver1(String content){
        log.info("路由模式1开始消费，{}",content);
    }

    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("direct2"),
            exchange = @Exchange("direct.test"),
            key = "b"
    ))
    public  void directReceiver2(String content){
        log.info("路由模式2开始消费，{}",content);
    }

    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("direct3"),
            exchange = @Exchange("direct.test"),
            key = "b"
    ))
    public  void directReceiver3(String content){
        log.info("路由模式3开始消费，{}",content);
    }
}

通配符模模式配置类

@Configuration
public class TopicConfig {


    @Bean
    public Queue topic1() {
        return QueueBuilder.durable("topic1").build();
    }

    @Bean
    public Queue topic2() {
        return new Queue("topic2");
    }

    @Bean
    public Queue topic3() {
        return new Queue("topic3");
    }

    @Bean
    public Queue topic4() {
        return new Queue("topic4");
    }

    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange("topic.test");
    }

    @Bean
    public Binding binding1(@Qualifier("topic1") Queue queue,
                            @Qualifier("topicExchange") TopicExchange topicExchange) {
        return BindingBuilder.bind(queue).to(topicExchange).with("a.#");
    }

    @Bean
    public Binding binding2(@Qualifier("topic2") Queue queue,
                            @Qualifier("topicExchange") TopicExchange topicExchange) {
        return BindingBuilder.bind(queue).to(topicExchange).with("a.*");
    }

    @Bean
    public Binding binding3(@Qualifier("topic3") Queue queue,
                            @Qualifier("topicExchange") TopicExchange topicExchange) {
        return BindingBuilder.bind(queue).to(topicExchange).with("*.a");
    }

    @Bean
    public Binding binding4(@Qualifier("topic4") Queue queue,
                            @Qualifier("topicExchange") TopicExchange topicExchange) {
        return BindingBuilder.bind(queue).to(topicExchange).with("#.a");

    }
}

通配符模式生产者

@Slf4j
@RestController
@RequestMapping("TopicSender")
public class TopicSender {
    @Autowired
    private AmqpTemplate amqpTemplate;

    @GetMapping("topicSender")
    public  void toipc(String content,String key){
        log.info("通配符模式开始发布消息:{},key:{}",content,key);
        this.amqpTemplate.convertAndSend("topic.test",key,content);
    }

}

通配符模式消费者

@Slf4j
@Component
@Configuration
public class TopicReceiver {

    @RabbitHandler
    @RabbitListener(queues = "topic1")
    public void topicReceiver1(String content){
        log.info("通配符模式1开始订阅：{}",content);
    }


    @RabbitHandler
    @RabbitListener(queues = "topic2")
    public void topicReceiver2(String content){
        log.info("通配符模式2开始订阅：{}",content);
    }



    @RabbitHandler
    @RabbitListener(queues = "topic3")
    public void topicReceiver3(String content){
        log.info("通配符模式3开始订阅：{}",content);
    }

    @RabbitHandler
    @RabbitListener(queues = "topic4")
    public void topicReceiver4(String content){
        log.info("通配符模式4开始订阅：{}",content);
    }
}
大海没有水
关注
专栏目录
Springboot注解方式整合RabbitMQ
ApolloNing的博客
12-08 584
第1步：引入POM依赖 核心POM <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 全部pom.xml内容 <?xml version="1.0" encoding="UTF-8"?> <project
玩转 Spring Boot 集成篇（RabbitMQ）
一猿小讲
02-01 4714
MQ 经常被应用于流量削峰、异步消息、应用解耦，常见的 MQ 开源组件有 RabbitMQ、Kafka、ActiveMQ、RocketMQ 等。1.RabbitMQRabbitMQ 最初...
springboot整合rabbitmq合集(xml方式和注解方式)
12-20
首先介绍一下rabbitmq三种模式 Direct–路由模式 任何发送到Direct Exchange的消息都会被转发到RouteKey指定的Queue。 这种模式下不需要将Exchange进行任何绑定(binding)操作。 消息传递时需要一个“RouteKey”，可以简单的理解为要发送到的队列名字。 如果vhost中不存在RouteKey中指定的队列名，则该消息会被抛弃。 Fanout–发布/订阅模式 任何发送到Fanout Exchange的消息都会被转发到与该Exchange绑定(Binding)的所有Queue上。 这种模式不需要RouteKey。 这种模式需要提前将Exchange
Spring boot使用Rabbitmq注解
大秦铁骑
04-04 9239
三个注解：@EnableRabbit @RabbitListener @RabbitHandler @EnableRabbit@EnableRabbit和@Configuration一起使用，可以加在类或者方法上，这个注解开启了容器对注册的bean的@RabbitListener检查。@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNT...
SpringBoot整合RabbitMQ系列--注解的使用
IT利刃出鞘的博客
05-29 3225
本文用实例介绍SpringBoot中RabbitMQ相关的注解。
rabbitmq实战指南mobi，Spring Boot 常用注解
最新发布
2301_79835671的博客
04-18 709
学习技术一定要制定一个明确的学习路线，这样才能高效的学习，不必要做无效功，既浪费时间又得不到什么效率，大家不妨按照我这份路线来学习。大家不妨直接在牛客和力扣上多刷题，同时，我也拿了一些面试题跟大家分享，也是从一些大佬那里获得的，大家不妨多刷刷题，为金九银十冲一波！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！3347446)]
spring-boot-mq-rabbitmq 一套打通rabbitmq 打开可用 有注释
04-08
《Spring Boot整合RabbitMQ：实现消息队列与分布式通信》 在当今的微服务架构中，消息队列（Message Queue，MQ）扮演着至关重要的角色，它能够有效地解决系统间的异步通信、解耦以及扩展性问题。RabbitMQ作为一款...
spring boot使用RabbitMQ实现topic 主题
08-27
Spring Boot 使用 RabbitMQ 实现 Topic 主题 Topic 主题是一种高级的消息 routing 机制，它允许消息的消费者根据路由键（Routing Key）来订阅消息。在 Spring Boot 中，我们可以使用 RabbitMQ 来实现 Topic 主题。...
spring boot中使用RabbitMQ routing路由详解
08-27
这种实现方式可以实现基于颜色类型的过滤器，例如，将只有 orange 颜色的消息路由到队列 Q1 中，将只有 black 和 green 颜色的消息路由到队列 Q2 中。 使用 Spring Boot 框架和 RabbitMQ，可以轻松地实现基于 ...
Spring Boot中使用RabbitMQ的示例代码
08-27
在 Spring Boot 中使用 RabbitMQ 需要添加相关依赖项，然后配置 RabbitMQ 的连接信息，最后使用 @RabbitListener 注解来监听消息队列。在业务逻辑中，可以使用 RabbitTemplate 来发送和接收消息。 知识点五：...
springboot+rabbitmq 集成
12-23
主要是springboot+rabbitmq集成的demo，里面是基于java注解实现消息发送和消息监听
SpringBoot RabbitMQ 注解版 基本概念与基本案例
ch98000的博客
08-24 376
注意事项:在YAML中开启的配置acknowledge-mode为auto也是默认的所以消息不需要手动确认默认没有异常则消费成功，如果需要定制ACK方式可以将acknowledge-mode修改为MANUAL则要在消费完成后自行ACK或NACK否则将导致消息重复消费。秒杀和抢购等场景经常使用 MQ 进行流量削峰。使用MQ就不会造成上述的问题，因为我们在用户注册完成后想消息模块对应的邮件发送业务队列去发送消息即可，队列会监督消息模块完成，如果完不成队列会一直监督，直到完成为止。
Springboot 集成 RabbitMq(注解版)
一尘在心的博客
06-22 1140
1：pom中引入相关的依赖 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-stream-binder-rabbit</artifactId> </dependency> 2：配置文件中加入对应的配置 # mq配置 #添加类型 spring.cloud.stream.bi
注解形式实现SpringBoot结合RabbitMq
weixin_38399962的博客
09-26 1692
导入相关依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-amqp&lt;/artifactId&gt; &lt;/dependency&gt; 在配置文件中配置rabbitMq的相关配置:(下图...
spring boot 整合 RabbitMq （注解）
weixin_30827565的博客
12-20 81
1、增加rabbitmq的依赖包 <!-- ampq 依赖包 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </d...
多个springboot整合使用rabbitmq(使用注解的方式)
qq_36138652的博客
08-18 987
先参考。
Spring整合RabbitMQ-注解方式
bug_null的博客
09-12 761
maven导入</</</</提示：ConnectionFactory有三个实现CachingConnectionFactory 基于channel的缓存模式 最常用是这个。LocalizedQueueConnectionFactory 直接连接某个节点的方式。如果是集群，此种不太适合。SimpleRoutingConnectionFactory 在当前的连接工厂中按查找的KEY获取连接工厂。运行消息的生产者，查看消息发送信息通过检查发现，消息已经成功的发送到了队列运行主程序,检查控制台的输出。
SpringBoot整合RabbitMQ 5种模式的注解绑定
小爽帅到拖网速的博客
05-03 3968
1、导入依赖 <!--AMQP依赖，包含RabbitMQ--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> <!--对象转换--> <dependency> <group
Spring Boot与RabbitMQ延迟消息实现详解
"这篇教程详细介绍了如何在Spring Boot项目中使用RabbitMQ的延迟消息功能，特别是通过rabbitmq_delayed_message_exchange插件实现这一功能。文章背景是面试中关于订单未支付自动取消的问题，强调了延迟消息相对于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值