springBoot集成rabbitmq 之延时（死信）队列

springBoot集成rabbitmq 之延时（死信）队列

comsumer 服务

配置类

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

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

@Configuration
public class RabbitDeadQueueConfig {

    /**
        * Queue 可以有4个参数
     *      1.队列名
     *      2.durable       持久化消息队列 ,rabbitmq重启的时候不需要创建新的队列 默认true
     *      3.auto-delete   表示消息队列没有在使用时将被自动删除 默认是false
     *      4.exclusive     表示该消息队列是否只在当前connection生效,默认是false
     */

    /**
     * 死信队列跟交换机类型没有关系 不一定为directExchange  不影响该类型交换机的特性.
     *
     * @return the exchange
     */
    @Bean
    public Exchange deadLetterExchange() {
        return ExchangeBuilder.directExchange("EXCHANGE_DL").durable(true).build();
    }

    /**
     * 声明一个死信队列.
     * x-dead-letter-exchange   对应  死信交换机
     * x-dead-letter-routing-key  对应 死信队列
     *
     * @return the queue
     */
    @Bean
    public Queue deadLetterQueue() {
        Map<String, Object> args = new HashMap<>(2);
//       x-dead-letter-exchange    声明  死信交换机
        args.put("x-dead-letter-exchange", "EXCHANGE_DL");
//       x-dead-letter-routing-key    声明 死信路由键
        args.put("x-dead-letter-routing-key","KEY_R");
        return QueueBuilder.durable("QUEUE_DL").withArguments(args).build();
    }

    /**
     * 定义死信队列转发队列.
     *
     * @return the queue
     */
    @Bean
    public Queue redirectQueue() {
        return QueueBuilder.durable("QUEUE_REDIRECT").build();
    }

    /**
     * 死信路由通过 DL_KEY 绑定键绑定到死信队列上.
     * @return the binding
     */
    @Bean
    public Binding deadLetterBinding() {
        return new Binding("QUEUE_DL", Binding.DestinationType.QUEUE,
                "EXCHANGE_DL", "KEY_DL", null);

    }

    /**
     * 死信路由通过 KEY_R 绑定键绑定到最终处理队列上.
     * @return the binding
     */
    @Bean
    public Binding redirectBinding() {
        return new Binding("QUEUE_REDIRECT", Binding.DestinationType.QUEUE,
                "EXCHANGE_DL", "KEY_R", null);
    }

}

接收者

import com.rabbitmq.client.Channel;
import org.springfram
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

@Configuration
public class RabbitDeadQueueConfig {

    /**
        * Queue 可以有4个参数
     *      1.队列名
     *      2.durable       持久化消息队列 ,rabbitmq重启的时候不需要创建新的队列 默认true
     *      3.auto-delete   表示消息队列没有在使用时将被自动删除 默认是false
     *      4.exclusive     表示该消息队列是否只在当前connection生效,默认是false
     */

    /**
     * 死信队列跟交换机类型没有关系 不一定为directExchange  不影响该类型交换机的特性.
     *
     * @return the exchange
     */
    @Bean
    public Exchange deadLetterExchange() {
        return ExchangeBuilder.directExchange("EXCHANGE_DL").durable(true).build();
    }

    /**
     * 声明一个死信队列.
     * x-dead-letter-exchange   对应  死信交换机
     * x-dead-letter-routing-key  对应 死信队列
     *
     * @return the queue
     */
    @Bean
    public Queue deadLetterQueue() {
        Map<String, Object> args = new HashMap<>(2);
//       x-dead-letter-exchange    声明  死信交换机
        args.put("x-dead-letter-exchange", "EXCHANGE_DL");
//       x-dead-letter-routing-key    声明 死信路由键
        args.put("x-dead-letter-routing-key","KEY_R");
        return QueueBuilder.durable("QUEUE_DL").withArguments(args).build();
    }

    /**
     * 定义死信队列转发队列.
     *
     * @return the queue
     */
    @Bean
    public Queue redirectQueue() {
        return QueueBuilder.durable("QUEUE_REDIRECT").build();
    }

    /**
     * 死信路由通过 DL_KEY 绑定键绑定到死信队列上.
     * @return the binding
     */
    @Bean
    public Binding deadLetterBinding() {
        return new Binding("QUEUE_DL", Binding.DestinationType.QUEUE,
                "EXCHANGE_DL", "KEY_DL", null); 
    }

    /**
     * 死信路由通过 KEY_R 绑定键绑定到最终处理队列上.
     * @return the binding
     */
    @Bean
    public Binding redirectBinding() {
        return new Binding("QUEUE_REDIRECT", Binding.DestinationType.QUEUE,
                "EXCHANGE_DL", "KEY_R", null);
    }

}ework.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.Date; 

@Component
@RabbitListener(queues = "QUEUE_REDIRECT")
public class DeadQueueReceiver { 
    @RabbitHandler
    public void process(String hello, Message message, Channel channel) { 
        try {
            //告诉服务器收到这条消息 已经被我消费了 可以在队列删掉 这样以后就不会再发了 否则消息服务器以为这条消息没处理掉 后续还会在发
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
            System.out.println("消息消费成功！");
        } catch (Exception e) {
            System.out.println("消息消费失败:"+e.getMessage() + e);
            //丢弃这条消息
            //channel.basicNack(message.getMessageProperties().getDeliveryTag(), false,false);
        }
        System.out.println("接收者 : " + hello +","+ new Date());
    }
}

producer服务

发送者

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.UUID;

@Component
public class DeadQueueSender implements  RabbitTemplate.ConfirmCallback ,RabbitTemplate.ReturnCallback {


	@Autowired
	private RabbitTemplate rabbitTemplate;

	public void send() {
		//设置回调对象
		this.rabbitTemplate.setConfirmCallback(this);
		this.rabbitTemplate.setReturnCallback(this);
		CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
		String content = "死信队列 = " + new Date() + ", 内容= " + UUID.randomUUID().toString();
		MessagePostProcessor messagePostProcessor = message -> {
			MessageProperties messageProperties = message.getMessageProperties();
//            设置编码
			messageProperties.setContentEncoding("utf-8");
//            设置过期时间10*1000毫秒
			messageProperties.setExpiration("10000");
			return message;
		};
//         向DL_QUEUE 发送消息  10*1000毫秒后过期 形成死信
		rabbitTemplate.convertAndSend("EXCHANGE_DL", "KEY_DL", content, messagePostProcessor, correlationData);
		System.out.println("发送成功,"+new Date()+","+content);
	}

	/**
	 * 消息回调确认方法
	 * 如果消息没有到exchange,则confirm回调,ack=false
	 * 如果消息到达exchange,则confirm回调,ack=true
	 * @param
	 */
	@Override
	public void confirm(CorrelationData correlationData, boolean isSendSuccess, String s) {
		System.out.println("confirm--message:回调消息ID为: " + correlationData.getId());
		if (isSendSuccess) {
			System.out.println("确认--消息:消息发送成功");
		} else {
			System.out.println("确认--消息:消息发送失败" + s);
		}
	}

	/**
	 * exchange到queue成功,则不回调return
	 * exchange到queue失败,则回调return(需设置mandatory=true,否则不回回调,消息就丢了)
	 */
	@Override
	public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
		System.out.println("返回--消息:" + new String(message.getBody()) + ",replyCode:" + replyCode
				+ ",replyText:" + replyText + ",exchange:" + exchange + ",routingKey:" + routingKey);
	}
}

测试

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController; 
@RestController
public class DeadQueueTests {
    @Autowired
    private DeadQueueSender deadQueueSender; 
    @GetMapping("DeadQueueTests")
    public void hello() {
        deadQueueSender.send();
    }
}

通过执行测试类，查看到了消息消费的情况，生产者共计生产了 1 个消息，被消费者消费了一次，但发送消息时间及实际消费时间差 10 秒钟。