前边我们使用RabbitMQ实现了高并发下对流量的削峰填谷。正常在实际应用中大概也就够用了。
有的时候呢，我们需要使用到延迟队列，RabbitMQ不像RocketMQ一样默认就支持延迟队列，RabbitMQ是不支持延迟队列的，但是呢？我们可以通过正常的队列加上消息的过期时间，配置死信队列，来模拟实现延迟队列。
一：创建普通队列（配置过期时间），绑定死信队列
很简单就是创建两个普通队列，将一个普通队列A指定为另一普通队列B的死信队列。
且给普通队列B配置过期时间。
1：配置类具体代码如下：
具体代码如下：
package com.modules.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class RabbitMQConfig
{
@Value("${spring.rabbitmq.host}")
private String host;
@Value("${spring.rabbitmq.port}")
private int port;
@Value("${spring.rabbitmq.username}")
private String userName;
@Value("${spring.rabbitmq.password}")
private String password;
@Value("${spring.rabbitmq.listener.prefetch}")
private int prefetch;
@Value("${spring.rabbitmq.listener.concurrency}")
private int concurrentConsumers;
@Value("${spring.rabbitmq.listener.max-concurrency}")
private int maxConcurrentConsumers;
/**
* 链接RabbitMQ
* @return
*/
@Bean
public ConnectionFactory connectionDirectFactory()
{
CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
connectionFactory.setHost(host);
connectionFactory.setPort(port);
connectionFactory.setUsername(userName);
connectionFactory.setPassword(password);
connectionFactory.setPublisherConfirms(true); //必须要设置
return connectionFactory;
}
/**
* 配置RabbitMQ参数
* @return
*/
@Bean
public SimpleRabbitListenerContainerFactory rabbitDirectListenerContainerFactory()
{
SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
factory.setConnectionFactory(connectionDirectFactory());
//设置最小并发的消费者数量
factory.setConcurrentConsumers(concurrentConsumers);
//设置最大并发的消费者数量
factory.setMaxConcurrentConsumers(maxConcurrentConsumers);
//限流，单位时间内消费多少条记录
factory.setPrefetchCount(prefetch);
// json转消息
//factory.setMessageConverter(new Jackson2JsonMessageConverter());
//设置rabbit 确认消息的模式，默认是自动确认
//factory.setAcknowledgeMode(AcknowledgeMode.AUTO);
//设置rabbit 确认消息的模式，默认是自动确认
factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
return factory;
}
/**
* 回调函数
* @param connectionFactory
* @return
*/
@Bean
public RabbitTemplate createDirectRabbitTemplate(ConnectionFactory connectionFactory)
{
RabbitTemplate rabbitTemplate = new RabbitTemplate();
rabbitTemplate.setConnectionFactory(connectionFactory);
//设置开启Manatory，才能触发回调函数，无论消息推送结果怎么样都会强制调用回调函数
rabbitTemplate.setMandatory(true);
// 设置确认发送到交换机的回调函数 =》 消息推送到server，但是在server里找不到交换机 / 消息推送到sever，交换机和队列啥都没找到 / 消息推送到server，找到交换机了，但是没找到队列 / 消息推送成功
rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
if(ack)
{
System.out.println("发送者消息确认成功！");
}
else
{
System.out.println("发送者消息确认失败，考虑重发："+cause);
}
//System.out.println("相关数据："+correlationData);
//System.out.println("确认情况："+ack);
//System.out.println("原因："+cause);
//System.out.println("===============================");
});
//设置确认消息已发送到队列的回调 =》 消息推送到server，找到交换机了，但是没找到队列 触发这个回调函数
rabbitTemplate.setReturnsCallback(returnedMessage -> {
System.out.println("交换机为："+returnedMessage.getExchange());
System.out.println("返回消息为："+returnedMessage.getMessage());
System.out.println("路由键为："+returnedMessage.getRoutingKey());
System.out.println("回应消息为："+returnedMessage.getReplyText());
System.out.println("回应代码为："+returnedMessage.getReplyCode());
System.out.println("===============================");
});
return rabbitTemplate;
}
//正常队列
// 交换机
public static final String NORMAL_EXCHANGE = "normal_exchange";
// 队列名称
public static final String NORMAL_QUEUE = "normal_queue";
// 路由键
public static final String NORMAL_ROUTE = "normal_route";
//死信队列
// 交换机
public static final String DEAD_EXCHANGE = "dead_exchange";
// 队列名称
public static final String DEAD_QUEUE = "dead_queue";
// 路由键
public static final String DEAD_ROUTE = "dead_route";
/**
* 死信交换机
* @return
*/
@Bean
public Exchange deadExchange()
{
// 创建死信队列交换机
return ExchangeBuilder.directExchange(DEAD_EXCHANGE).build();
}
/**
* 死信队列
* @return
*/
@Bean
public Queue deadQueue()
{
// 创建死信队列
return QueueBuilder.durable(DEAD_QUEUE).build();
}
/**
* 死信交换机绑定死信队列
* @param deadExchange
* @param deadQueue
* @return
*/
@Bean
public Binding deadBinding(Exchange deadExchange,Queue deadQueue)
{
// 死信交换机绑定死信队列
return BindingBuilder.bind(deadQueue).to(deadExchange).with(DEAD_ROUTE).noargs();
}
/**
* 设置正常队列（过期时间）
*/
/*@Bean
public Queue TTLQUEUE()
{
Map<String, Object> map = new HashMap<>();
map.put("x-message-ttl", 30000); // 队列中的消息未被消费则30秒后过期
return new Queue(NORMAL_QUEUE, true, false, false, map);
}//*/
/**
* 绑定死信交换机及路由key(该正常队列内的消息无法被正常消费时，会转发给绑定的死信交换机通过路由key转发到死信队列)
*/
@Bean
public Queue normalQueue()
{
// 创建队列
return QueueBuilder.durable(NORMAL_QUEUE)
.deadLetterExchange(DEAD_EXCHANGE)// 绑定死信队列交换机
.deadLetterRoutingKey(DEAD_ROUTE)// 绑定死信队列路由
.ttl(30000)// 设置消息过期时间
.build();
}
/**
* 正常队列交换机
*/
@Bean
public DirectExchange normalExchange()
{
// return new DirectExchange(NORMAL_EXCHANGE);
// 创建交换机
return ExchangeBuilder.directExchange(DEAD_EXCHANGE).build();
}
/**
* 正常交换机绑定正常队列
*/
@Bean
public Binding binding(Queue normalQueue,Exchange normalExchange)
{
// 将 队列 交换机 路由key绑定到一起。
return BindingBuilder.bind(normalQueue).to(normalExchange).with(NORMAL_ROUTE).noargs();
}//*/
}2：生产者代码如下：
package com.modules.controller.rabbitmq;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TTLController
{
@Autowired
private RabbitTemplate rabbitTemplate;
@GetMapping("/java/ttlproduct")
public String sendTrafficMessage(@RequestParam String message)
{
for (int i = 1; i <= 100; i++)
{
// 使用java多线程来模拟多用户并发请求
final int temp = i;
new Thread(
()->{
// 给RabbitMQ发送消息
rabbitTemplate.convertAndSend(
"normal_exchange",
"normal_route",
"hello world:"+temp,
new MessagePostProcessor() {
@Override
public Message postProcessMessage(Message message) throws
AmqpException
{
// System.out.println("发送回调:"+temp);
System.out.println(message);
return message;
}
});
}
).start();
}
return "Message sent";
}
}这里向上边创建的普通队列推送消息。
3：消费者
消费者监听死信队列，上边我们创建的普通队列的消息过期时间是30秒，相当于我们向普通队列中推送消息之后，30秒过期则进入死信队列中，消费者监听死信队列，等待消息进入死信队列之后再进行消费处理。这样就模拟了一个延迟队列。
代码如下：
package com.modules.controller.rabbitmq;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.IOException;
@Component
public class TTLConsumer
{
@Autowired
private RabbitTemplate rabbitTemplate;
/**
* 监听死信队列
* @param message
* @param channel
* @throws InterruptedException
* @throws IOException
*/
@RabbitListener(queues = "dead_queue")
public void receiveMessage(Message message, Channel channel) throws InterruptedException, IOException
{
// 为了演示一个一个消费的情况，这里使用线程暂停来延迟控制台输出
Thread.sleep(100);
// ===============================
// 处理消息，例如写入数据库或进行计算
System.out.println("TTL Received message: " + new String(message.getBody()));
//System.out.println("channel: " + channel);
// =================================
// 成功处理后手动确认消息
long deliveryTag = message.getMessageProperties().getDeliveryTag();
//System.out.println("deliveryTag:"+deliveryTag);
channel.basicAck(deliveryTag, false);
}
}运行生产者，登录RabbitMQ控制台，如下图所示：
以上大概就是SpringBoot集成RabbitMQ实现延迟队列的全过程。
PS：redis也是可以通过zset来模拟实现延迟队列的，score存时间戳，每次取当前时间多少秒之前的数据即可。这里不做过多讨论。
有好的建议，请在下方输入你的评论。