rabbitmq通过死信队列实现延迟任务——java

    @Configuration
    public class RabbitmqConfig {
    @Bean
    public Queue contractQueue() {
    // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
    // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
    // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
    // return new Queue("contractQueue",true,true,false);
    //一般设置一下队列的持久化就好,其余两个就是默认false 
    return new Queue("contractQueue", true);
    }
    @Bean
    //Direct 交 换 机 起 名 ：ordersExchange 
    public DirectExchange ordersExchange() {
    return new DirectExchange("ordersExchange", true, false);
    }
    //绑定 将队列和交换机绑定, 并设置用于匹配DirectRouting 
    @Bean
    public Binding bindingDirect(Queue contractQueue, DirectExchange ordersExchange) { 
    return BindingBuilder.bind(contractQueue)
    .to(ordersExchange)//交换机
    .with("DirectRouting");//路由键
    }
    }

    // 延迟时间
    public final static long CONTRACT_SIGN_DEAD_TIME = 1000 * 20;
    // 正常路由键名
    public final static String DELAY_QUEUE_CONTRACT_SIGN_ROUTING_KEY = "delay.queue.contract.sign.routingkey"; 
    // 死信路由键名
    public final static String DEAD_LETTER_QUEUE_CONTRACT_SIGN_ROUTING_KEY = "deadletter.queue.contract.sign.routingkey";
    // 正常交换机
    public final static String CONTRACT_SYNC_SIGN_EXCHANGE = "contract.sync.sign.exchange"; 
    // 死信交换机
    public final static String CONTRACT_SYNC_SIGN_DEAD_EXCHANGE =  "contract.sync.sign.dead.exchange"; 
    // 正常队列
    public final static String CONTRACT_SYNC_SIGN_QUEUE = "contract.sync.sign.queue";
    // 死信队列
    public final static String CONTRACT_SYNC_SIGN_DEAD_QUEUE = "contract.sync.sign.dead.queue";

    // 正常交换机
    @Bean
    public DirectExchange contractSyncSignExchange(){
        return new DirectExchange(RabbitmqConstant.CONTRACT_SYNC_SIGN_EXCHANGE,true,false);
    }
    // 死信交换机
    @Bean
    public DirectExchange contractSyncSignDeadExchange(){
        return new DirectExchange(RabbitmqConstant.CONTRACT_SYNC_SIGN_DEAD_EXCHANGE,true,false);
    }
    // 正常队列
    @Bean
    public Queue contractSyncSignQueue(){
        Map<String, Object> args = new HashMap<>();
        args.put("x-dead-letter-exchange", RabbitmqConstant.CONTRACT_SYNC_SIGN_DEAD_EXCHANGE); // 绑定死信交换机
        args.put("x-dead-letter-routing-key", RabbitmqConstant.DEAD_LETTER_QUEUE_CONTRACT_SIGN_ROUTING_KEY); // 设置死信routing-key
        args.put("x-message-ttl", RabbitmqConstant.CONTRACT_SIGN_DEAD_TIME);// 过期时间
        return new Queue(RabbitmqConstant.CONTRACT_SYNC_SIGN_QUEUE,true,false,false,args);
    }
    // 死信队列
    @Bean
    public Queue contractSyncSignDeadQueue(){
        return new Queue(RabbitmqConstant.CONTRACT_SYNC_SIGN_DEAD_QUEUE,true);
    }
    // 正常交换机与正常队列绑定
    @Bean
    public Binding bindingContractSyncSignQueue(Queue contractSyncSignQueue,DirectExchange contractSyncSignExchange){
        return BindingBuilder.bind(contractSyncSignQueue)
                .to(contractSyncSignExchange)
                .with(RabbitmqConstant.DELAY_QUEUE_CONTRACT_SIGN_ROUTING_KEY);
    }
    // 死信交换机与死信队列绑定
    @Bean
    public Binding bindingContractSyncSignDeadQueue(Queue contractSyncSignDeadQueue,DirectExchange contractSyncSignDeadExchange){
        return BindingBuilder.bind(contractSyncSignDeadQueue)
                .to(contractSyncSignDeadExchange)
                .with(RabbitmqConstant.DEAD_LETTER_QUEUE_CONTRACT_SIGN_ROUTING_KEY);
    }

    @RabbitHandler
    @RabbitListener(queues = RabbitmqConstant.CONTRACT_SYNC_SIGN_DEAD_QUEUE)
    public void comsume(String json)

    JSONObject jsonObject = new JSONObject();
    rabbitTemplate.convertAndSend(RabbitmqConstant.CONTRACT_SYNC_SIGN_EXCHANGE,RabbitmqConstant.DELAY_QUEUE_CONTRACT_SIGN_ROUTING_KEY,jsonObject.toJSONString());