【RabbitMQ、Spring Boot】Spring Boot整合RabbitMQ

最新推荐文章于 2022-08-03 18:25:33 发布
最新推荐文章于 2022-08-03 18:25:33 发布
阅读量1.6k 收藏 3
点赞数
分类专栏： RabbitMQ 文章标签： spring boot 分布式 微服务 rabbitmq spring cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apple_csdn/article/details/124212988
版权

一、环境准备

引入pom依赖

        <!--rabbitmq-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

设置application.yml配置文件

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 7006
    username: admin
    password: admin
    # 是否触发回调方法
    # NONE值是禁用发布确认模式，是默认值
    # CORRELATED值是发布消息成功到交换器后会触发回调方法，如1示例
    # SIMPLE值经测试有两种效果，其一效果和CORRELATED值一样会触发回调方法，其二在发布消息成功后使用rabbitTemplate调用waitForConfirms或waitForConfirmsOrDie方法等待broker节点返回发送结果，根据返回结果来判定下一步的逻辑，要注意的点是waitForConfirmsOrDie方法如果返回false则会关闭channel，则接下来无法发送消息到broker;
    publisher-confirm-type: correlated

二、简单模式：一个消费者消费一个队列中的信息

1、注册

package com.rabbmq.config;

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 简单模式
 *
 * @author He PanFu
 * @date 2021-09-16 12:33:25
 */
@Configuration
public class RabbitSimpleConfig {
    
    @Bean
    public Queue simpleQueueWx() {
        // 队列名称，是否持久化
        return new Queue("simple_queue", true);
    }
}

2、添加消息到队列中

	@Autowired
    RabbitTemplate rabbitTemplate;

	 @GetMapping("/simple")
    public String sendSimpleMessage() {
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend("simple_queue", getStringObjectMap());
        }
        return "ok";
    }
    
	private Map<String, Object> getStringObjectMap() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message, hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        return map;
    }

3、消费者消费消息

package com.rabbitmq.receiver;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;


/**
 * 简单模式：微信订阅
 *
 * @author He PanFu
 * @date 2021-09-16 12:47:32
 */
@Component
@RabbitListener(queues = "simple_queue")
public class RabbitSimpleWXListener {

    @RabbitHandler
    public void init(Map testMessage) {
        System.out.println("简单模式（微信）：" + testMessage);
    }
}

4、展示

在这里插入图片描述

备注：

  • @RabbitListener可以直接在方法上单独使用。
  • @RabbitListener 可以标注在类上面，需配合 @RabbitHandler 注解一起使用
  • @RabbitListener 标注在类上面表示当有收到消息的时候，就交给 @RabbitHandler 的方法处理，具体使用哪个方法处理，根据 MessageConverter 转换后的参数类型

三、工作模式(轮询分发)：多个消费者共同消费同一个队列中的信息

  • 介绍：启动多个消费者，当生产者将消息发送给队列时，一条信息只会被一个消费者接收，rabbit默认采用轮询的方式将消息平均发送给消费者，消费者在处理完某个信息后才会接收到下一条信息。
  • 轮询分发（Round-robin）：消息的分发是轮询的，即多个消费者依次从队列中获取消息并消费，每次获取一条，轮询分发不考虑消费者消费消息的速度。举个例子，队列中有100条消息，C1，C2两个消费者，无论它两的消费速度如何，最后的结果总是你一个我一个的每个人拿到25条消息。

1、注册

package com.cyun.demo.rabbitmq.provider;

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

/**
 * 工作模式
 *
 * @author He PanFu
 * @date 2021-09-16 12:33:25
 */
@Component
public class RabbitWorkManage {
    /**
     * 工作队列
     *
     * @return 队列
     */
    @Bean
    public Queue workQueue() {
        return new Queue("work_queue", true);
    }
}

2、添加消息到队列中

 	@GetMapping("/work")
    public String sendWorkMessage() {
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend("work_queue", getStringObjectMap());
        }
        return "ok";
    }

3、消费者消费消息

备注：正式环境是启动多台消费服务，我这里直接简单化模拟。

package com.cyun.demo.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.concurrent.TimeUnit;


/**
 * 工作模式：队列监听
 *
 * @author He PanFu
 * @date 2021-09-16 12:47:32
 */
@Slf4j
@Component
public class RabbitWorkListener {

    @RabbitListener(queues = "work_queue")
    public void messageListener1(Object msg, Channel channel, Message message) throws InterruptedException, IOException {
       TimeUnit.SECONDS.sleep(1);
        log.info("1消息处理完成，消息内容：{}", msg);
    }

    @RabbitListener(queues = "work_queue")
    public void messageListener2(Object msg, Channel channel, Message message) throws IOException, InterruptedException {
       TimeUnit.SECONDS.sleep(2);
        log.info("2消息处理完成，消息内容：{}", msg);
    }
}
4、展示

在这里插入图片描述

四、工作模式(公平分发)：多个消费者共同消费同一个队列中的信息

  • 公平分发（Fair dispatcher）：消息的分发是公平的，即按照消费者消费的能力来分配消息，能者多劳。举个例子，队列中有90条消息，C1,C2两个消费者，其中C1消费一条消息的速度是1s，C2消费一条消息的速度是2s,那么最后的结果是C1消费了60条消息，C2消费了30条消息。

1、修改application.yml文件

开启手动ack，并且每次只能读取1条消息

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 7006
    username: admin
    password: admin
    # 是否触发回调方法
    # NONE值是禁用发布确认模式，是默认值
    # CORRELATED值是发布消息成功到交换器后会触发回调方法，如1示例
    # SIMPLE值经测试有两种效果，其一效果和CORRELATED值一样会触发回调方法，其二在发布消息成功后使用rabbitTemplate调用waitForConfirms或waitForConfirmsOrDie方法等待broker节点返回发送结果，根据返回结果来判定下一步的逻辑，要注意的点是waitForConfirmsOrDie方法如果返回false则会关闭channel，则接下来无法发送消息到broker;
    publisher-confirm-type: correlated
    listener:
      simple:
        # 开启手动确定
        acknowledge-mode: manual
        # 预处理模式更改为每次读取1条消息,在消费者未回执确认之前,不在进行下一条消息的投送
        prefetch: 1

2、改造消费者消费消息代码

package com.cyun.demo.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.concurrent.TimeUnit;


/**
 * 工作模式：队列监听
 *
 * @author He PanFu
 * @date 2021-09-16 12:47:32
 */
@Slf4j
@Component
public class RabbitWorkListener {

    @RabbitListener(queues = "work_queue")
    public void messageListener1(Object msg, Channel channel, Message message) throws InterruptedException, IOException {
        log.info("1消息开始处理，消息内容：{}", msg);
        
        // 公平分发：手动进行确认消息
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        // 手动返回未确认消息,requeue 为true时,重新入队
        // channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,true);

    }

    @RabbitListener(queues = "work_queue")
    public void messageListener2(Object msg, Channel channel, Message message) throws IOException, InterruptedException {
        log.info("2消息开始处理，消息内容：{}", msg);
        
        TimeUnit.SECONDS.sleep(1);
        // 公平分发：手动进行确认消息
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

3、展示

在这里插入图片描述

五、发布/订阅模式：多个消费者消费同一个信息

1、注册

package com.cyun.demo.rabbitmq.provider;

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;

/**
 * 发布/订阅模式
 *
 * @author He PanFu
 * @date 2022-04-16 17:04:55
 */
@Configuration
public class RabbitmqFanoutConfig {

    /**
     * 设置交换机:
     * <p>
     * durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
     * exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
     * autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
     *
     * @return 发布/订阅交换机
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanout_exchange", true, false);
    }

    /**
     * 微信队列
     *
     * @return 队列
     */
    @Bean
    public Queue fanoutQueueWx() {
        return new Queue("fanout_queue_wx", true);
    }

    /**
     * 短信队列
     *
     * @return 队列
     */
    @Bean
    public Queue fanoutQueueDx() {
        return new Queue("fanout_queue_dx", true);
    }

    /**
     * 微信队列绑定交换机
     *
     * @return 绑定对象
     */
    @Bean
    public Binding fanoutBindingWx() {
        return BindingBuilder.bind(fanoutQueueWx()).to(fanoutExchange());
    }

    /**
     * 短信队列绑定交换机
     *
     * @return 绑定对象
     */
    @Bean
    public Binding fanoutBindingDx() {
        return BindingBuilder.bind(fanoutQueueDx()).to(fanoutExchange());
    }

}

2、添加消息到队列中

	 @GetMapping("/fanout")
    public String sendFanoutMessage() {
        for (int i = 0; i < 10; i++) {
            //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
            rabbitTemplate.convertAndSend("fanout_exchange", "", getStringObjectMap(), new CorrelationData(UUID.randomUUID().toString()));
        }
        return "ok";
    }

3、消费者消费消息

package com.cyun.demo.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.concurrent.TimeUnit;


/**
 * 发布/订阅模式：队列监听
 *
 * @author He PanFu
 * @date 2021-09-16 12:47:32
 */
@Slf4j
@Component
public class RabbitmqFanoutListener {

    @RabbitListener(queues = "fanout_queue_wx")
    public void messageListener1(Object msg, Channel channel, Message message, @Header(AmqpHeaders.DELIVERY_TAG) long tag) throws InterruptedException, IOException {
        log.info("订阅模式（微信），消息开始处理，消息内容：{}", msg);

        // 手动进行确认消息
        channel.basicAck(tag, false);

    }

    @RabbitListener(queues = "fanout_queue_dx")
    public void messageListener2(Object msg, Channel channel, Message message) throws IOException, InterruptedException {
        log.info("订阅模式（短信），消息开始处理，消息内容：{}", msg);

        // 手动进行确认消息
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

4、展示

在这里插入图片描述

六、路由模式

1、注册

package com.cyun.demo.rabbitmq.provider;

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 org.springframework.stereotype.Component;

/**
 * @author He PanFu
 * @date 2022-04-16 18:29:03
 */
@Configuration
public class RabbitmqDirectConfig {

    /**
     * 设置交换机:
     * <p>
     * durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
     * exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
     * autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
     *
     * @return 交换机:
     */
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("direct_exchange", true, false);
    }

    /**
     * 微信队列
     *
     * @return 队列
     */
    @Bean
    public Queue directQueueWx() {
        return new Queue("direct_queue_wx", true);
    }

    /**
     * 短信队列
     *
     * @return 队列
     */
    @Bean
    public Queue directQueueDx() {
        return new Queue("direct_queue_dx", true);
    }

    /**
     * 微信队列绑定交换机
     *
     * @return 绑定
     */
    @Bean
    public Binding directBindingWx() {
        return BindingBuilder.bind(directQueueWx()).to(directExchange()).with("wx");
    }

    /**
     * 短信队列绑定交换机
     *
     * @return 绑定
     */
    @Bean
    public Binding directBindingDx() {
        return BindingBuilder.bind(directQueueDx()).to(directExchange()).with("dx");
    }

}

2、添加消息到队列中

    @GetMapping("/direct/{routingKey}")
    public String sendDirectMessage(@PathVariable("routingKey") String routingKey) {
        rabbitTemplate.convertAndSend("direct_exchange", routingKey, getStringObjectMap());
        return "ok";
    }

3、消费者消费消息

package com.cyun.demo.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * 路由模式
 *
 * @author He PanFu
 * @date 2022-04-16 18:32:19
 */
@Slf4j
@Component
public class RabbitmqDirectListener {

    @RabbitListener(queues = "direct_queue_wx")
    public void messageListener1(Object msg, Channel channel, Message message, @Header(AmqpHeaders.DELIVERY_TAG) long tag) throws InterruptedException, IOException {
        log.info("订阅模式（微信），消息开始处理，消息内容：{}", msg);

        // 手动进行确认消息
        channel.basicAck(tag, false);

    }

    @RabbitListener(queues = "direct_queue_dx")
    public void messageListener2(Object msg, Channel channel, Message message) throws IOException, InterruptedException {
        log.info("订阅模式（短信），消息开始处理，消息内容：{}", msg);

        // 手动进行确认消息
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

4、展示

在这里插入图片描述

七、主题模式

1、注册

package com.cyun.demo.rabbitmq.provider;

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;

/**
 * 主题模式
 *
 * @author He PanFu
 * @date 2022-04-18 09:00:43
 */
@Configuration
public class RabbitmqTopicConfig {

    /**
     * 设置交换机:
     * <p>
     * durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
     * exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
     * autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
     *
     * @return 交换机
     */
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange("topic_exchange", true, false);
    }

    /**
     * 设置微信队列
     *
     * @return 队列
     */
    @Bean
    public Queue topicQueueWx() {
        return new Queue("topic_queue_wx", true);
    }

    /**
     * 设置短信队列
     *
     * @return 队列
     */
    @Bean
    public Queue topicQueueDx() {
        return new Queue("topic_queue_dx", true);
    }

    /**
     * 进行微信队列绑定交换机
     * "*" 表示任何一个词
     * "#" 表示0或1个词
     *
     * @return 绑定
     */
    @Bean
    public Binding topicBindingWx() {
        return BindingBuilder.bind(topicQueueWx()).to(topicExchange()).with("#.wx.#");
    }

    /**
     * 进行短信队列绑定交换机
     * "*" 表示任何一个词
     * "#" 表示0或1个词
     *
     * @return 绑定
     */
    @Bean
    public Binding topicBindingDx() {
        return BindingBuilder.bind(topicQueueDx()).to(topicExchange()).with("dx.*");
    }
}

2、添加消息到队列中

    @GetMapping("/topic")
    public String sendTopicMessage() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message, hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        map.put("key", "wx");
        rabbitTemplate.convertAndSend("topic_exchange", "wx", map);
        map.put("key", "wx.www");
        rabbitTemplate.convertAndSend("topic_exchange", "wx.www", map);
        map.put("key", "wx.www.www");
        rabbitTemplate.convertAndSend("topic_exchange", "wx.www.www", map);
        map.put("key", "dx");
        rabbitTemplate.convertAndSend("topic_exchange", "dx", map);
        map.put("key", "dx.www");
        rabbitTemplate.convertAndSend("topic_exchange", "dx.www", map);
        map.put("key", "dx.www.www");
        rabbitTemplate.convertAndSend("topic_exchange", "dx.www.www", map);
        return "ok";
    }

3、消费者消费消息

package com.cyun.demo.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Map;

/**
 * 主题模式
 *
 * @author He PanFu
 * @date 2022-04-18 09:18:47
 */
@Slf4j
@Component
public class RabbitmqTopicListener {

    /**
     * 微信队列监听
     *
     * @param testMessage 数据
     */
    @RabbitListener(queues = "topic_queue_wx")
    public void messageListener2(Map testMessage, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long tag) throws IOException {
        log.info("主题模式（微信），key：{}，testMessage：{}", testMessage.get("key"),testMessage);

        channel.basicAck(tag, false);
    }
    
    /**
     * 短信队列监听
     *
     * @param testMessage 数据
     */
    @RabbitListener(queues = "topic_queue_dx")
    public void messageListener1(Map testMessage, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long tag) throws IOException {
        log.info("主题模式（短信），key：{}，testMessage：{}", testMessage.get("key"),testMessage);
        channel.basicAck(tag, false);
    }

}

4、展示

在这里插入图片描述

八、参数模式

1、注册

package com.cyun.demo.rabbitmq.provider;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.HeadersExchange;
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;

/**
 * 参数模式
 *
 * @author He PanFu
 * @date 2022-04-18 09:53:43
 */
@Configuration
public class RabbitmqHeadersConfig {

    /**
     * 设置交换机:
     * <p>
     * durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
     * exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
     * autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
     *
     * @return 交换机
     */
    @Bean
    public HeadersExchange headersExchange() {
        return new HeadersExchange("headers_exchange", true, false);
    }

    /**
     * 设置微信队列
     *
     * @return 队列
     */
    @Bean
    public Queue headersQueueWx() {
        return new Queue("headers_queue_wx", true);
    }

    /**
     * 设置短信队列
     *
     * @return 队列
     */
    @Bean
    public Queue headersQueueDx() {
        return new Queue("headers_queue_dx", true);
    }

    /**
     * 设置邮箱队列
     *
     * @return 队列
     */
    @Bean
    public Queue headersQueueYx() {
        return new Queue("headers_queue_yx", true);
    }

    /**
     * 进行微信队列绑定交换机，请求头中包含两个
     *
     * @return 绑定
     */
    @Bean
    public Binding headersBindingWx() {
        Map<String, Object> map = new HashMap<>();
        map.put("One", "A");
        map.put("Two", "B");
        return BindingBuilder.bind(headersQueueWx()).to(headersExchange()).whereAll(map).match();
    }

    /**
     * 进行短信队列绑定交换机，请求头中包含任意一个
     *
     * @return 绑定
     */
    @Bean
    public Binding headersBindingDx() {
        Map<String, Object> map = new HashMap<>();
        map.put("One", "A");
        map.put("Two", "B");
        return BindingBuilder.bind(headersQueueDx()).to(headersExchange()).whereAny(map).match();
    }

    /**
     * 进行邮箱队列绑定交换机
     *
     * @return 绑定
     */
    @Bean
    public Binding headersBindingYx() {
        return BindingBuilder.bind(headersQueueYx()).to(headersExchange()).where("Three").matches("C");
    }
}

2、添加消息到队列中


    @GetMapping("/topic")
    public String sendTopicMessage() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message, hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        map.put("key", "wx");
        rabbitTemplate.convertAndSend("topic_exchange", "wx", map);
        map.put("key", "wx.www");
        rabbitTemplate.convertAndSend("topic_exchange", "wx.www", map);
        map.put("key", "wx.www.www");
        rabbitTemplate.convertAndSend("topic_exchange", "wx.www.www", map);
        map.put("key", "dx");
        rabbitTemplate.convertAndSend("topic_exchange", "dx", map);
        map.put("key", "dx.www");
        rabbitTemplate.convertAndSend("topic_exchange", "dx.www", map);
        map.put("key", "dx.www.www");
        rabbitTemplate.convertAndSend("topic_exchange", "dx.www.www", map);
        return "ok";
    }

3、消费者消费消息

package com.cyun.demo.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Map;

/**
 * 参数模式
 *
 * @author He PanFu
 * @date 2022-04-18 10:27:15
 */
@Slf4j
@Component
public class RabbitmqHeadersListener {

    /**
     * 微信队列监听
     *
     * @param testMessage 数据
     */
    @RabbitListener(queues = "headers_queue_wx")
    public void messageListener1(Message testMessage, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long tag) throws IOException {
        log.info("参数模式（微信），testMessage：{}", testMessage);

        channel.basicAck(tag, false);
    }

    /**
     * 短信队列监听
     *
     * @param testMessage 数据
     */
    @RabbitListener(queues = "headers_queue_dx")
    public void messageListener2(Message testMessage, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long tag) throws IOException {
        log.info("参数模式（短信），testMessage：{}", testMessage);

        channel.basicAck(tag, false);
    }

    /**
     * 邮箱队列监听
     *
     * @param testMessage 数据
     */
    @RabbitListener(queues = "headers_queue_yx")
    public void messageListener3(Message testMessage, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long tag) throws IOException {
        log.info("参数模式（邮箱），testMessage：{}", testMessage);

        channel.basicAck(tag, false);
    }
}

4、展示

在这里插入图片描述

九、死信队列

介绍：“死信”是RabbitMQ中的一种消息机制，当你在消费消息时，如果队列里的消息出现以下情况，那么该消息将成为“死信”。

  1. 消息被否定确认，使用 channel.basicNack 或 channel.basicReject ，并且此时requeue 属性被设置为false。
  2. 消息在队列的存活时间超过设置的TTL时间。
  3. 消息队列的消息数量已经超过最大队列长度。

“死信”消息会被RabbitMQ进行特殊处理，如果配置了死信队列信息，那么该消息将会被丢进死信队列中，如果没有配置，则该消息将会被丢弃。

注意：如果修改了队列的配置信息，需重新删除原有的队列重新注册。
在这里插入图片描述

1、注册

package com.cyun.demo.rabbitmq.provider;

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;

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

/**
 * 发布/订阅模式
 *
 * @author He PanFu
 * @date 2022-04-16 17:04:55
 */
@Configuration
public class RabbitmqFanoutTtlConfig {

    /**
     * 设置交换机:
     * <p>
     * durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
     * exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
     * autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
     *
     * @return 发布/订阅交换机
     */
    @Bean
    public FanoutExchange fanoutTtlExchange() {
        return new FanoutExchange("fanout_ttl_exchange", true, false);
    }

    /**
     * 微信队列
     *
     * @return 队列
     */
    @Bean
    public Queue fanoutTtlQueueWx() {
        Map<String, Object> map = new HashMap<>();
        // 过期时间
        map.put("x-message-ttl", 1000);
        // 死信队列，消息过期后，会放到死信交换机中
        map.put("x-dead-letter-exchange", "direct_exchange");
        map.put("x-dead-letter-routing-key", "wx");
        return new Queue("fanout_ttl_queue_wx", true, false, false, map);
    }

    /**
     * 微信队列绑定交换机
     *
     * @return 绑定对象
     */
    @Bean
    public Binding fanoutTtlBindingWx() {
        return BindingBuilder.bind(fanoutTtlQueueWx()).to(fanoutTtlExchange());
    }

}

2、添加消息到队列中


    @GetMapping("/fanout/ttl")
    public String sendFanoutTtlMessage() {
        rabbitTemplate.convertAndSend("fanout_ttl_exchange", "", getStringObjectMap());
        return "ok";
    }

3、消费者消费消息

package com.cyun.demo.rabbitmq.consumer;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.concurrent.TimeUnit;


/**
 * 发布/订阅模式：队列监听
 *
 * @author He PanFu
 * @date 2021-09-16 12:47:32
 */
@Slf4j
@Component
public class RabbitmqFanoutTtlListener {

    @RabbitListener(queues = "fanout_ttl_queue_wx")
    public void messageListener1(Object msg, Channel channel, Message message, @Header(AmqpHeaders.DELIVERY_TAG) long tag) throws InterruptedException, IOException {
        log.info("订阅模式TTL（微信），消息开始处理，消息内容：{}", msg);
        
        // 触发情况一：消息被否定确定。multiple：是否批量处理.true:将一次性ack所有小于deliveryTag的消息,requeue：为true时,重新入队
        // channel.basicNack(tag,false,false);
        // 触发情况二：超时
        TimeUnit.SECONDS.sleep(15);
        channel.basicAck(tag, false);
    }

}

4、展示

在这里插入图片描述

5、拓展：添加消息到队列时设置过期时间信息

注意：两个过期时间，以最小准。

    @GetMapping("/fanout/ttl/5000")
    public String sendFanoutTTLMessageMessage() {
        // 设置过期时间
        MessagePostProcessor processor = message -> {
            message.getMessageProperties().setExpiration("5000");
            message.getMessageProperties().setContentEncoding("UTF-8");
            return message;
        };

        rabbitTemplate.convertAndSend("fanout_ttl_exchange", "", getStringObjectMap(), processor);
        return "ok";
    }

十、总结

具体步骤为：注册（注册交换机 -> 注册队列 -> 绑定交换机与队列） -> 监听 -> 加入队列

apple_csdn
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot 整合RabbitMq ，用心看完这一篇就够了
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
Springboot整合RabbitMQ
weixin_49076273的博客
06-02 1万+
一、Springboot整合RabbitMQ的代码实现 1.引入Springboot整合RabbitMQ的依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> &l
Springboot+Rabbitmq消费者注解详解、改序列化方式
鸢尾_的博客
08-03 3999
Springboot+Rabbitmq消费者注解详解、改序列化方式
RabbitMq入门（与springboot简单使用）
weixin_43676950的博客
12-10 1268
RabbitMQ是一个开源的消息代理和队列服务器，用来通过普通协议在完成不同的应用之间共享数据，RabbitMQ是使用Erlang语言来编写的，并且RabbitMQ是基于AMQP协议的。在rabbitMq中，Exchange有四个类型：direct，topic，fanout，header，详见。
Spring Boot中使用RabbitMQ
JavaAlliance
07-08 4361
Message Broker与AMQP简介 Message Broker是一种消息验证、传输、路由的架构模式，其设计目标主要应用于下面这些场景： 消息路由到一个或多个目的地 消息转化为其他的表现方式 执行消息的聚集、消息的分解，并将结果发送到他们的目的地，然后重新组合成相应的结果返回给消息用户 调用Web服务来检索数据 响应事件或错误 使用发布-订阅模式来提供内容或基于主题的消息路由 AMQP...
详解Spring Boot 配置多个RabbitMQ
08-30
本篇文章主要介绍了Spring Boot 配置多个RabbitMQ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Boot整合RabbitMQ开发实战详解
08-28
主要介绍了Spring Boot整合RabbitMQ开发实战，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
Spring Boot RabbitMQ常用配置
最新发布
04-21
RabbitMQ 是一个开源的消息代理中间件，广泛用于构建分布式应用程序中的消息系统。在 Spring Boot 项目中，通过集成 RabbitMQ，可以实现异步消息传递、消息队列等功能，提高系统的可靠性和扩展性。
Spring Boot 整合 RabbitMQ 案例.zip
11-02
Spring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例...
Spring boot 配置整合RabbitMq
qq_16306629的博客
04-29 4531
适合新手的看的Spring boot 配置整合 RabbitMq 案例~ 详细介绍了Direct 和 Fanout 的Demo 介绍了Rabbit的优缺点
spring boot整合rabbitMq（AmqpAdmin的使用）
weixin_43241706的博客
12-23 1159
开发过程中遇到的场景：需要spring boot整合rabbitMQ，并且对外提供rabbitMQ的服务，包括：rabbitMq的创建与配置、消息的发布publish，网上搜了很多都没找到这种场景相关的记录，整体过程记录如下： 国际惯例，添加依赖 application.yml（property）配置 rabbitConfig配置类 @Configuration public class RabbitConfig { private Logger logger = LoggerFactory
2小时学会RabbitMQ-效仿抖音发送短信验证码
01-29
本课程全程使用目前比较流行的开发工具idea进行开发,采用现在互联网流行的微服务架构SpringBoot+SpringCloud+JPA, 同时也使用了互联网的高并发中间件redis,ElasticSearch,RabbitMQ，MongoDB数据库，springSecurity安全框架,还会涉及到一些后期运维的相关技术如jenkins，influxdb，ranchar等技术，还会涉及到代码生成器。   本课程全程使用目前比较流行的开发工具idea进行开发,采用现在互联网流行的微服务架构SpringBoot+SpringCloud+JPA, 同时也使用了互联网的高并发中间件redis,ElasticSearch,RabbitMQ，MongoDB数据库，springSecurity安全框架,还会涉及到一些后期运维的相关技术如jenkins，influxdb，ranchar等技术，还会涉及到代码生成器，不需要写简单的代码了，可以直接生成，,此课程内容丰富实战性强,非常符合现在市场的新技术走势,你学完本课程会,让你完全感受到了互联网思维带来的高并发解决方案的思路,如果你是开发的小白,建议你学完Spring,SpringMVC,MyBatis框架后再来学习本门课程,学完以后会让你完全体验到企业级开发的流程.在职的同学，学完后会让你的薪资更高,让你更了解互联网是如何解决高并发用过SSM框架的同学也可以学习这门课程，能让你感受到与SSM框架不同的感受，更简化的开发思维
@RabbitListener 与 @RabbitHandler 及 消息序列化
weixin_30797199的博客
05-23 9766
https://www.jianshu.com/p/911d987b5f11 转载于:https://www.cnblogs.com/zhangww/p/10899756.html
RabbitMQ - Spring boot 整合
热门推荐
wanght笔记
03-12 2万+
文章目录新建项目pom.xmlapplication.yml主程序简单模式创建主类生产者消费者测试类工作模式主类生产者生产者消费者ack模式设置 ack 模式手动执行确认操作抓取数量 新建项目 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4...
springboot项目RabbitMq手动开启/关闭监听
qq_26993175的博客
05-05 7346
前言 在springboot项目中使用rabbitmq的@RabbitListener自动开启监听。而如果直接上了生产环境，在升级时候贸然kill掉，可能会损坏业务链条。实为不妥。 1、自动启动监听 @RabbitListener(queues = "#{queue}",concurrency = "#{concurrency}") public void receiveMsg(SmsMsg message) { } 2、手动关闭所有监听 当我们想kill掉程序的时候，可以使用kill -15 pid发
springboot项目 rabbitMq 自定义监听类/消费者开启或关闭
weixin_43550533的博客
08-02 9585
1.找到监听类 代码： @RabbitListener(queues = "suggest_complaint_wechat",autoStartup= "false",id = "1111") 2.在测试类中 代码： @Autowired private RabbitListenerEndpointRegistry rabbitListenerEndpointRegistry; ...
RabbitMQ 实战（二）Spring Boot 整合 RabbitMQ
皂白
02-04 7278
这篇文章主要讲基本的整合。先把代码跑起来，再说什么高级特性。 RabbitMQ 中的一些术语 如果你打开 RabbitMQ web 控制台，你会发现其中有一个 Exhanges 不好理解。下面简单说明一下。 交换器（Exchange） 交换器就像路由器，我们先是把消息发到交换器，然后交换器再根据路由键（routingKey）把消息投递到对应的队列。（明白这个概念很重要，后面的代
SpringBoot中使用 RabbitMQ
孔繁玉的专栏
11-15 9539
本章主要建立在已经安装好Erlang以及RabbitMQ的基础上，接下来，简单介绍一下使用 一、Direct直接模式 通过routingKey和exchange决定的那个唯一的queue可以接收消息 1、首先到RabbitMQ的管理界面新建一个队列（Direct模式） 2、测试项目的基础结构如下： 这里为了方便测试，直接在父项目中建立两个子模块（生产者和消费者） 3、pom.xml文件的依赖如下： 父项目： <?xml version="1.0" encoding="UTF-8"?> &l
spring boot整合rabbitmq
08-24
Spring Boot与RabbitMQ的整合可以通过使用Spring AMQP实现。下面是一个简单的步骤： 1. 添加依赖：在`pom.xml`文件中添加以下依赖关系： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值