rabbitmq配置

package com.xinsixian.caiyi.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitmqConfig {

    private static Logger log = LoggerFactory.getLogger(RabbitmqConfig.class);
    @Autowired
    private CachingConnectionFactory connectionFactory;

    @Bean
    public RabbitTemplate rabbitTemplate(){
        //若使用confirm-callback或return-callback，必須要配置publisherConfirms或publisherReturns爲true
        //每個rabbitTemplate只能有一個confirm-callback和return-callback，如果這裏配置了，那麼寫生產者的時候不能再寫confirm-callback和return-callback
        //使用return-callback時必須設置mandatory爲true，或者在配置中設置mandatory-expression的值爲true
        connectionFactory.setPublisherConfirms(true);
        connectionFactory.setPublisherReturns(true);
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMandatory(true);
//        /**
//         * 如果消息沒有到exchange,則confirm回調,ack=false
//         * 如果消息到達exchange,則confirm回調,ack=true
//         * exchange到queue成功,則不回調return
//         * exchange到queue失敗,則回調return(需設置mandatory=true,否則不回回調,消息就丟了)
//         */
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if(ack){
                    log.info("消息發送到exchange成功:correlationData({}),ack({}),cause({})",correlationData,ack,cause);
                }else{
                    log.info("消息發送exchange失敗:correlationData({}),ack({}),cause({})",correlationData,ack,cause);
                }
            }
        });
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                log.info("exchange到queue消息丟失:exchange({}),route({}),replyCode({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,message);
            }
        });
        return rabbitTemplate;
    }

    @Bean
    public Queue colorCQueue(){
        return new Queue("cayi_colorCQueue");
    }

    @Bean
    public Exchange colorCExchange() {
        return new DirectExchange("caiyi_colorCExchange");
    }

    @Bean
    Binding bindingExchangeDirect(@Qualifier("colorCQueue")Queue colorCQueue, DirectExchange colorCExchange){
        return  BindingBuilder.bind(colorCQueue).to(colorCExchange).with("caiyi_colorC");
    }

  //  @Bean
    MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }
}