springboot整合rabbitmq

• 配置

package com.ultrapower.config;

import com.ultrapower.mq.ConfirmCallBackListener;
import com.ultrapower.mq.ReturnCallBackListener;
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.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

/**
 * 本地rabbitmq的访问地址 http://127.0.0.1:15672/
 */
@Configuration
public class RabbitConfig {
    //rabbitmq连接参数
    @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;

    //交换机名声明
    public static final String EXCHANGE_A = "my-mq-exchange_A";
    public static final String EXCHANGE_B = "my-mq-exchange_B";
    public static final String EXCHANGE_C = "my-mq-exchange_C";
    public static final String FANOUTEXCHANGE = "FANOUTEXCHANGE";

    //队列名声明
    public static final String QUEUE_A = "QUEUE_A";
    public static final String QUEUE_B = "QUEUE_B";
    public static final String QUEUE_C = "QUEUE_C";

    //routingkey声明
    public static final String ROUTINGKEY_A = "spring-boot-routingKey_A";
    public static final String ROUTINGKEY_B = "spring-boot-routingKey_B";
    public static final String ROUTINGKEY_C = "spring-boot-routingKey_C";

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory(host, port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setPublisherConfirms(true);
        return connectionFactory;
    }

    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    //必须是prototype类型
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory());
        //设置mandatory=true,否则不会回调,消息就丢了
        template.setMandatory(true);
        //消息到exchange成功则ack=true否则ack=false
        template.setConfirmCallback(new ConfirmCallBackListener());
        //exchange到queue成功,则不回调return,否则回调return
        template.setReturnCallback(new ReturnCallBackListener());
        return template;
    }


    //获取queueA
    @Bean
    public Queue queueA() {
        return new Queue(RabbitConfig.QUEUE_A, true); //队列持久
    }

    //获取exchangeA
    @Bean
    public DirectExchange exchangeA() {
        return new DirectExchange(RabbitConfig.EXCHANGE_A);
    }

    //绑定exchangeA和queueA
    @Bean
    public Binding bindingA() {
        return BindingBuilder.bind(queueA()).to(exchangeA()).with(RabbitConfig.ROUTINGKEY_A);
    }


    //获取queueB
    @Bean
    public Queue queueB() {
        return new Queue(RabbitConfig.QUEUE_B, true); //队列持久
    }

    //获取exchangeB
    @Bean
    public DirectExchange exchangeB() {
        return new DirectExchange(RabbitConfig.EXCHANGE_B);
    }

    //绑定exchangeB和queueB
    @Bean
    public Binding bindingB() {
        return BindingBuilder.bind(queueB()).to(exchangeB()).with(RabbitConfig.ROUTINGKEY_B);
    }


    //获取queueC
    @Bean
    public Queue queueC() {
        return new Queue(RabbitConfig.QUEUE_C, true); //队列持久
    }

    //获取exchangeC
    @Bean
    public DirectExchange exchangeC() {
        return new DirectExchange(RabbitConfig.EXCHANGE_C);
    }

    //绑定exchangeC和queueC
    @Bean
    public Binding bindingC() {
        return BindingBuilder.bind(queueC()).to(exchangeC()).with(RabbitConfig.ROUTINGKEY_C);
    }
}

• ConfirmCallBack

package com.ultrapower.mq;

import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

/**
  如果消息没有到exchange,则confirm回调,ack=false
  如果消息到达exchange,则confirm回调,ack=true
 */
@Component
public class ConfirmCallBackListener implements RabbitTemplate.ConfirmCallback {

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        System.out.println("confirm--:correlationData:"+correlationData+",ack:"+ack+",cause:"+cause);
    }

}

• ReturnCallBack

package com.ultrapower.mq;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

/**
 exchange到queue成功,则不回调return
 exchange到queue失败,则回调return(需设置mandatory=true,否则不回回调,消息就丢了)
 */
@Component
public class ReturnCallBackListener implements RabbitTemplate.ReturnCallback {

    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        System.out.println("return--message:" + new String(message.getBody()) + ",replyCode:" + replyCode + ",replyText:" + replyText + ",exchange:" + exchange + ",routingKey:" + routingKey);
    }
}

• producer

package com.ultrapower.mq;

import com.ultrapower.config.RabbitConfig;
import lombok.extern.slf4j.Slf4j;
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.UUID;

@Component
@Slf4j
public class MsgProducer {
    //由于rabbitTemplate的scope属性设置为ConfigurableBeanFactory.SCOPE_PROTOTYPE，所以不能自动注入
    private RabbitTemplate rabbitTemplate;

    //构造方法注入rabbitTemplate
    @Autowired
    public MsgProducer(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    /**
     * 向A发送消息
     *
     * @param content
     */
    public void sendMsgA(String content) {
        if (content != null && !"".equals(content)) {
            CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
            rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE_A, RabbitConfig.ROUTINGKEY_A, content, correlationId);
        }
    }

    /**
     * 向B发送消息
     *
     * @param content
     */
    public void sendMsgB(String content) {
        if (content != null && !"".equals(content)) {
            CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
            rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE_B, RabbitConfig.ROUTINGKEY_B, content, correlationId);
        }
    }
    /**
     * 向C发送消息
     *
     * @param content
     */
    public void sendMsgC(String content) {
        if (content != null && !"".equals(content)) {
            CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
            rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE_C, RabbitConfig.ROUTINGKEY_C, content, correlationId);
        }
    }
    //向ABC发送消息
    public void sendAll(String content) {
        rabbitTemplate.convertAndSend(RabbitConfig.FANOUTEXCHANGE,"", content);
    }
}

• consumer

package com.ultrapower.mq;

import com.ultrapower.config.RabbitConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
//不同的消费者监听不同的队列
@RabbitListener(queues = RabbitConfig.QUEUE_A)
public class MsgConsumerA {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @RabbitHandler
    public void process(String content) {
        logger.info("接收处理队列A当中的消息： " + content);
    }

}