spring boot 整合rabbit MQ

11 篇文章 0 订阅
2 篇文章 0 订阅

spring boot 整合rabbit MQ

rabbit MQ

rabbit MQ 是实现了高级消息队列协议(AMQP)的开源消息代理软件(亦称面向消息的中间件)。RabbitMQ服务器是用[Erlang]语言编写的,而集群和故障转移是构建在[开放电信平台]框架上的。所有主要的编程语言均有与代理接口通讯的客户端[库] 来自百度百科 rabbit MQ

  • rabbit 和其他消息中间件不同的是,rabbit有一个exchange路由的概念
  • exchange 交换机,就相当于一个路由一样,把我们的消息分发到不通的queue ,rabbit支持三种exchange
    • direct 顾名思义,就是直连,相当于点对点的模式
    • topic 广播订阅模式,但是它可以根据我们的路由key的不通,转发到不通的人queue
    • fanout 广播订阅模式 ,这种模式下,路由key会失效,它会将消息发送到所有绑定的queue

与spring boot 的整合

直接参照spring.io的官方文档,讲的很清楚简单,贴一下链接

  • 引入相关依赖

     <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    
  • 启动类

    @SpringBootApplication
    public class SpringBootRabbitProduceApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(SpringBootRabbitProduceApplication.class, args);
        }
    
  • 配置服务器信息

    spring:
      rabbitmq:
        host: 127.0.0.1
        port: 5672
        username: guest
        password: guest
    
  • rabbit 配置类,这里具体解析下

    • Queue queue() 注册一个bean,类型是一个queue对象,

    • TopicExchange topicExchange() ,注册一个topic exchange

    • Binding bindingQueueA() 对queue和exchange进行绑定

      BindingBuilder.bind(queueA()).to(topicExchange()).with("topic.a")表示绑定queueA 这个队列到topicExchange 上,路由key是topic.a ,表示只有匹配topic.a的消息转发到 queueA这个队列上

      BindingBuilder.bind(queueB()).to(topicExchange()).with("topic.#") 表示绑定queueB到topicExchange 上,路由key是topic.#", .#表示topic开头的,无论后面是什么都会转发到绑定的queue上面

    • FanoutExchange 上面介绍过,绑定在FanoutExchange上面的,会忽略路由key,所有的详细都会发送到其绑定的所有queue上面

    @Configuration
    public class RabbitMQConfig {
    
        @Bean
        public Queue queue(){
            return new Queue("testQueue");
        }
    
        //------------------------测试topic-exchange-------------------------------------------------------------//
        @Bean
        public Queue queueA(){
            return new Queue("queueA");
        }
        @Bean
        public Queue queueB(){
            return new Queue("queueB");
        }
        @Bean
        public TopicExchange topicExchange(){
            return new TopicExchange("topic");
        }
        @Bean
        public Binding bindingQueueA(){
            //绑定 topic.a 才会路由到queueA
            return BindingBuilder.bind(queueA()).to(topicExchange()).with("topic.a");
        }
        @Bean
        public Binding bindingQueueB(){
            //绑定 topic.# 只要是topic.开头的都路由到queueB
            return BindingBuilder.bind(queueB()).to(topicExchange()).with("topic.#");
        }
    
    
        //------------------------测试 fanout exchange--------------------------------------------------------------//
    
        @Bean
        public Queue queueC(){
            return new Queue("queueC");
        }
        @Bean
        public Queue queueD(){
            return new Queue("queueD");
        }
    
        @Bean
        public FanoutExchange fanoutExchange(){
            return new FanoutExchange("fanout");
        }
    
        @Bean
        public Binding bindingQueueC(){
            return BindingBuilder.bind(queueC()).to(fanoutExchange());
        }
    
        @Bean
        public Binding bindingQueueD(){
            return BindingBuilder.bind(queueD()).to(fanoutExchange());
        }
    }
    
  • 消费

    直接在类或者方法上加上 @RabbitListener(queues = "queueName") 注解,queues表示要消费的队列

        /**
         * 消费 topic exchange queueA 消息
         * @param message
         */
       // @RabbitListener(queues = "queueA")
        public void consumerQueueA(Object message){
            try {
                log.info("----------------------------收到queueA消息:{}",message);
            }catch (Exception e){
                log.info("--",e);
            }
        }
        /**
         * 消费 topic exchange queueB 消息
         * @param message
         */
       // @RabbitListener(queues = "queueB")
        public void consumerQueueB(Object message){
            try {
                log.info("----------------------------收到queueB消息:{}",message);
            }catch (Exception e){
                log.info("--",e);
            }
        }
        /**
         * 消费 topic exchange queueB 消息
         * @param message
         */
        @RabbitListener(queues = "queueC")
        public void consumerQueueC(Object message){
            try {
                log.info("----------------------------queueC收到消息:{}",message);
            }catch (Exception e){
                log.info("--",e);
            }
        }
        /**
         * 消费 topic exchange queueB 消息
         * @param message
         */
        @RabbitListener(queues = "queueD")
        public void consumerQueueD(Object message){
            try {
                log.info("----------------------------queueD收到消息:{}",message);
            }catch (Exception e){
                log.info("--",e);
            }
        }
    
  • 发送消息

    • AmqpTemplate 直接注入AmqpTemplate 就可以发送消息,

    • amqpTemplate.convertAndSend(“topic”,“topic.a”,"–topic.a-- -----测试消息");

      第一个参数topic 表示要发送到那个exchange

      第二个参数"topic.a表示消息的路由key,

      第三个参数表示消息的内容,可以是String,也可以是object,注意需要实现序列化接口

    @Autowired
        private AmqpTemplate amqpTemplate;
        @Test
        public void testSendTopic(){
            //这里,第一条消息会发送到 queueA和queueB ,而下面两条只会发送到queueB
            amqpTemplate.convertAndSend("topic","topic.a","--topic.a--  -----测试消息");
            amqpTemplate.convertAndSend("topic","topic.b","--topic.b--  -----测试消息");
            amqpTemplate.convertAndSend("topic","topic.c","--topic.c--  -----测试消息");
        }
    @Test
        public void testSendFanout(){
            //这里,消息会发送到所有绑定的queue
            amqpTemplate.convertAndSend("fanout","fanout.a","--topic.a--  -----测试消息");
            amqpTemplate.convertAndSend("fanout","fanout.b","--topic.b--  -----测试消息");
            amqpTemplate.convertAndSend("fanout","fanout.c","--topic.c--  -----测试消息");
        }
    

消息消费的手动ack

ack就是消息消费完成之后,消费端给服务器一个回复,告诉服务器这条消息消费完成,服务器就会从对应的queue上面删除消费完成的消息,如果客户端没有完成ack,服务端会在这条消息加一个标示unackd,当unackd过多解释就行影响我们的消息的消费

消息的消费默认是客户端自动ack的,某些业务场景可能需要我们手动确认消息的消费,比如如果我们的消息消费失败之后,客户端发送一个nack给服务器,服务器就会吧这条消息重新回到ready状态,之后就可以重新去消费这条消息

配置消息手动ack

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    listener:
      simple:
        acknowledge-mode: manual

手动ack消息

  • channel.basicAck(tag,false) 手动的确认消息的消费成功,注意第二个个参数如果为true就会吧前面没有ack的消息一起ack了
  • channel.basicNack(tag,false,true)消息消费失败,手手动发送消息消费失败
    • 出现异常,或者消息消费失败 Nack 之后消息就会重新回到ready状态,可以重新进行消费
    • 第三个参数设为false,rabbit会在nack到达某个阈值时把这条消息放到死信队列中Dead Letter,
    • 死信队列也是一个队列,也可以通过客户端来消息,来对异常的消息做特殊处理
 /**
     * 消费 topic exchange queueB 消息
     *  channel client注册的通道
     *  tag amqp_deliveryTag 消息的tag
     * @param message
     */
    @RabbitListener(queues = "queueD")
    public void consumerQueueD(Object message, Channel channel,@Header(AmqpHeaders.DELIVERY_TAG) long tag){
        try {
            log.info("----------------------------queueD收到消息:{}",message);
            //手动确认消息的消费,注意第二个个参数如果为true就会吧前面没有ack的消息一起ack了
            channel.basicAck(tag,false);
        }catch (Exception e){
            log.info("--",e);
            //出现异常,或者消息消费失败 Nack 之后消息就会重新回到ready状态,可以重新进行消费
            //第三个参数设为false,rabbit会在nack到达某个阈值时把这条消息放到死信队列中Dead Letter,
            //死信队列也是一个队列,也可以通过客户端来消息
            try {
                channel.basicNack(tag,false,true);
            } catch (IOException e1) {
                log.info("--",e);
            }
        }
    }

未完待续…

  • 1
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot 中使用 RabbitMQRabbit Message Queue)可以方便地实现消息驱动的应用程序。RabbitMQ 是一个开源的消息代理(message broker),它实现了 AMQP(Advanced Message Queuing Protocol)协议,用于在分布式系统中传递和接收消息。 要在 Spring Boot 中使用 RabbitMQ,你需要进行以下步骤: 1. 添加 RabbitMQ 的依赖:在 `pom.xml` 文件中添加 RabbitMQ 的依赖项,例如: ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 2. 配置 RabbitMQ 连接信息:在 `application.properties` 或 `application.yml` 文件中配置 RabbitMQ 的连接信息,例如: ```yaml spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest ``` 3. 创建消息发送者和接收者:可以使用 Spring Boot 提供的 `RabbitTemplate` 类来发送和接收消息。你可以通过注入 `RabbitTemplate` 对象来使用它。 4. 定义消息队列和交换机:在发送和接收消息之前,需要定义消息队列和交换机。可以使用 `@RabbitListener` 注解来监听消息队列,并使用 `@RabbitHandler` 注解来处理接收到的消息。 5. 发送和接收消息:使用 `RabbitTemplate` 的方法来发送和接收消息。例如,使用 `convertAndSend()` 方法发送消息,使用 `@RabbitHandler` 注解的方法来处理接收到的消息。 通过以上步骤,你可以在 Spring Boot 中使用 RabbitMQ 来实现可靠的消息传递和处理,并构建消息驱动的应用程序。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值