springboot集成RabbitMQ

springboot集成RabbitMQ

springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种支持。

简单使用

1、配置pom包，主要是添加spring-boot-starter-amqp的支持

1. <dependency>

2. <groupId>org.springframework.boot</groupId>

3. <artifactId>spring-boot-starter-amqp</artifactId>

4. </dependency>

2、配置文件

配置rabbitmq的安装地址、端口以及账户信息 ps：注意这些属性名称固定，项目启动时对应的以下属性名称不为空，会自动建立rabbitmq服务器的连接，自动创建connectionFactory，rabbitTemple，rabbitAdmin等对象；

1. spring.application.name=spirng-boot-rabbitmq 

2. spring.rabbitmq.host=192.168.0.86

3. spring.rabbitmq.port=5672

4. spring.rabbitmq.username=admin

5. spring.rabbitmq.password=123456

3、队列配置

1. @Configuration

2. public class RabbitConfig {

3. @Bean

4. public Queue Queue() {

5. return new Queue("hello");

6. }

7. }

3、发送者

rabbitTemplate是springboot 提供的默认实现

1. public class HelloSender {

2.  

3. @Autowired

4. private AmqpTemplate rabbitTemplate;

5.  

6. public void send() {

7. String context = "hello " + new Date();

8. System.out.println("Sender : " + context);

9. this.rabbitTemplate.convertAndSend("hello", context);

10. }

11.  

12. }

4、接收者

1. @Component

2. @RabbitListener(queues = "hello")

3. public class HelloReceiver {

4.  

5. @RabbitHandler

6. public void process(String hello) {

7. System.out.println("Receiver : " + hello);

8. }

9.  

10. }

实际配置:

package com.zcwk.core.rabbitmq;

import com.gexin.fastjson.JSON;
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.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;

@Configuration
public class RabbitMQConfig {
    private final static Logger log = LoggerFactory.getLogger("rabbitMqLog");

    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 PAYMENT_NOTICE_QUEUE = "payment_notice_queue";
    public static final String RE_PAYMENT_NOTICE_QUEUE = "re_payment_notice_queue";
    public static final String REGISTER_SUCCESS_QUEUE = "register_success_queue";
    public static final String BUY_SUCCESS_QUEUE = "buy_success_queue";
    public static final String PAYMENT_QUEUE = "payment_queue";
    public static final String BIND_CARD_QUEUE = "bind_card_queue";
    public static final String LOGIN_QUEUE = "login_queue";
    public static final String REAL_NAME_QUEUE = "real_name_queue";
    public static final String FULL_DEBT_AWARD_QUEUE = "full_debt_award_queue";
    public static final String RECHARGE_QUEUE = "recharge_queue";
    public static final String WITHDRAW_QUEUE = "withdraw_queue";
    public static final String WITHDRAW_FAIL_QUEUE = "withdraw_fail_queue";
    public static final String FIRST_INVEST_AWARD_QUEUE = "first_invest_award_queue";
    public static final String PAY_PASSWORD_QUEUE = "pay_password_queue";
    public static final String VALID_EMAIL_QUEUE = "valid_email_queue";
    public static final String TEST_QUEUE = "test_queue";


    public static final String PAYMENT_NOTICE_QUEUE_KEY = "payment_notice_queue_key";
    public static final String RE_PAYMENT_NOTICE_QUEUE_KEY = "re_payment_notice_queue_key";
    public static final String REGISTER_SUCCESS_QUEUE_KEY = "register_success_queue_key";
    public static final String BUY_SUCCESS_QUEUE_KEY = "buy_success_queue_key";
    public static final String PAYMENT_QUEUE_KEY = "payment_queue_key";
    public static final String BIND_CARD_QUEUE_KEY = "bind_card_queue_key";
    public static final String LOGIN_QUEUE_KEY = "login_queue_key";
    public static final String REAL_NAME_QUEUE_KEY = "real_name_queue_key";
    public static final String FULL_DEBT_AWARD_QUEUE_KEY = "full_debt_award_queue_key";
    public static final String RECHARGE_QUEUE_KEY= "recharge_queue_key";
    public static final String WITHDRAW_QUEUE_KEY = "withdraw_queue_key";
    public static final String WITHDRAW_FAIL_QUEUE_KEY = "withdraw_fail_queue_key";
    public static final String FIRST_INVEST_AWARD_QUEUE_KEY = "first_invest_award_queue_key";
    public static final String PAY_PASSWORD_QUEUE_KEY = "pay_password_queue_key";
    public static final String VALID_EMAIL_QUEUE_KEY = "valid_email_queue_key";
    public static final String ROUTINGKEY_TEST= "routingkey_test_key";

    @Autowired
    private Environment env;

    @Autowired
    private CachingConnectionFactory connectionFactory;

    @Autowired
    private SimpleRabbitListenerContainerFactoryConfigurer factoryConfigurer;

    @Bean
    public RabbitTemplate rabbitTemplate(){
        connectionFactory.setPublisherConfirms(true);
        connectionFactory.setPublisherReturns(true);
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                log.info("消息发送成功: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({}),route({}),replyCode({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,message);
            }
        });

        log.info("==================================================================");
        log.info("rabbitTemplate==============="+ JSON.toJSONString(rabbitTemplate));
        log.info("==================================================================");
        return rabbitTemplate;
    }


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

   */


    @Bean
    public DirectExchange defaultExchange() {
        return new DirectExchange(EXCHANGE_A);
    }

    /**
     * 获取队列
     * @return
     */
    @Bean
    public Queue paymentNoticeQueue() {
        return new Queue(PAYMENT_NOTICE_QUEUE, true); //队列持久
    }

    @Bean
    public Queue re_paymentNoticeQueue() {
        return new Queue(RE_PAYMENT_NOTICE_QUEUE, true); //队列持久
    }

    @Bean
    public Queue paymentQueue() {
        return new Queue(PAYMENT_QUEUE, true); //队列持久
    }

    @Bean
    public Queue registerSuccessQueue() {
        return new Queue(REGISTER_SUCCESS_QUEUE, true); //队列持久
    }

    @Bean
    public Queue buySuccessQueue() {
        return new Queue(BUY_SUCCESS_QUEUE, true); //队列持久
    }

    @Bean
    public Queue loginQueue() {
        return new Queue(LOGIN_QUEUE, true); //队列持久
    }

    @Bean
    public Queue bindCardQueue() {
        return new Queue(BIND_CARD_QUEUE, true); //队列持久
    }

    @Bean
    public Queue rechargeQueue() {
        return new Queue(RECHARGE_QUEUE, true); //队列持久
    }

    @Bean
    public Queue withdrawFailQueue() {
        return new Queue(WITHDRAW_FAIL_QUEUE, true); //队列持久
    }
    @Bean
    public Queue withdrawQueue() {
        return new Queue(WITHDRAW_QUEUE, true); //队列持久
    }

    @Bean
    public Queue realNameQueue() {
        return new Queue(REAL_NAME_QUEUE, true); //队列持久
    }

    @Bean
    public Queue payPasswordQueue() {
        return new Queue(PAY_PASSWORD_QUEUE, true); //队列持久
    }

    @Bean
    public Queue fullDebtAwardQueue() {
        return new Queue(FULL_DEBT_AWARD_QUEUE, true); //队列持久
    }

    @Bean
    public Queue validEmailQueue() {
        return new Queue(VALID_EMAIL_QUEUE, true); //队列持久
    }

    @Bean
    public Queue firstInvestAwardQueue() {
        return new Queue(FIRST_INVEST_AWARD_QUEUE, true); //队列持久
    }

    @Bean
    public Queue testQueue() {
        return new Queue(TEST_QUEUE, true); //队列持久
    }
    @Bean
    public Binding binding_paymentNotice() {

        return BindingBuilder.bind(paymentNoticeQueue()).to(defaultExchange()).with(PAYMENT_NOTICE_QUEUE_KEY);
    }

    @Bean
    public Binding binding_payment() {

        return BindingBuilder.bind(paymentQueue()).to(defaultExchange()).with(PAYMENT_QUEUE_KEY);
    }
    @Bean
    public Binding binding_re_paymentNotice() {

        return BindingBuilder.bind(re_paymentNoticeQueue()).to(defaultExchange()).with(RE_PAYMENT_NOTICE_QUEUE_KEY);
    }
    @Bean
    public Binding binding_registerSuccess() {

        return BindingBuilder.bind(registerSuccessQueue()).to(defaultExchange()).with(REGISTER_SUCCESS_QUEUE_KEY);
    }
    @Bean
    public Binding binding_buySuccess() {

        return BindingBuilder.bind(buySuccessQueue()).to(defaultExchange()).with(BUY_SUCCESS_QUEUE_KEY);
    }
    @Bean
    public Binding binding_login() {
        return BindingBuilder.bind(loginQueue()).to(defaultExchange()).with(LOGIN_QUEUE_KEY);
    }
    @Bean
    public Binding binding_bindCard() {
        return BindingBuilder.bind(bindCardQueue()).to(defaultExchange()).with(BIND_CARD_QUEUE_KEY);
    }
    @Bean
    public Binding binding_recharge() {
        return BindingBuilder.bind(rechargeQueue()).to(defaultExchange()).with(RECHARGE_QUEUE_KEY);
    }
    @Bean
    public Binding binding_withdrawFail() {
        return BindingBuilder.bind(withdrawFailQueue()).to(defaultExchange()).with(WITHDRAW_FAIL_QUEUE_KEY);
    }

    @Bean
    public Binding binding_withdraw() {
        return BindingBuilder.bind(withdrawQueue()).to(defaultExchange()).with(WITHDRAW_QUEUE_KEY);
    }
    @Bean
    public Binding binding_realName() {
        return BindingBuilder.bind(realNameQueue()).to(defaultExchange()).with(REAL_NAME_QUEUE_KEY);
    }
    @Bean
    public Binding binding_payPassword() {
        return BindingBuilder.bind(payPasswordQueue()).to(defaultExchange()).with(PAY_PASSWORD_QUEUE_KEY);
    }
    @Bean
    public Binding binding_fullDebtAward() {
        return BindingBuilder.bind(fullDebtAwardQueue()).to(defaultExchange()).with(FULL_DEBT_AWARD_QUEUE_KEY);
    }
    @Bean
    public Binding binding_validEmail() {
        return BindingBuilder.bind(validEmailQueue()).to(defaultExchange()).with(VALID_EMAIL_QUEUE_KEY);
    }
    @Bean
    public Binding firstInvestAward() {
        return BindingBuilder.bind(firstInvestAwardQueue()).to(defaultExchange()).with(FIRST_INVEST_AWARD_QUEUE_KEY);
    }
    @Bean
    public Binding testBinding() {

        return BindingBuilder.bind(testQueue()).to(defaultExchange()).with(ROUTINGKEY_TEST);
    }
  /* @Bean

    public SimpleMessageListenerContainer containerA(ConnectionFactory connectionFactory,
                                                     MessageListenerAdapter listenerAdapter) {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        container.setQueues(queueA());
        container.setExposeListenerChannel(true);
        container.setMaxConcurrentConsumers(1);
        container.setConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认
        container.setMessageListener(listenerAdapter);
        return container;
    }

    @Bean
    MessageListenerAdapter listenerAdapter(MsgReceiver receiver) {
        return new MessageListenerAdapter(receiver);
    }*/



}

 在配置类中做了 队列以及对应的rountingkey的声明。rabbitTemple中设置了消息发送的confirm机制。消息发送成功或失败均做日志记录；

并将队列根据rountingkey,绑定到交换机上；

 

 

注解的方式 配置队列：

@RabbitListener(bindings = {@QueueBinding(
        value = @Queue(value = RabbitMQConfig.LOGIN_QUEUE,durable="true",exclusive = "false",autoDelete="false"),
        exchange = @Exchange(value = "exchange.ff.ff.sendPush",durable="true"),
        key = "routingkey.ff.ff.sendPush")})
public class LoginListener extends BaseListener{}

或者可以使用上面的注解方式，来声明队列，并将队列与rountingkey绑定到交换机上；无需在配置类中对队列，交换机和绑定一一声明；发送消息可以采用与上面相同的方式处理；

发送者的简单代码如下：

@Service
public class RabbitHelper {
    private static final Logger LOG = LoggerFactory.getLogger(RabbitHelper.class);
    @Autowired
    private RabbitTemplate rabbitTemplate;

    

    public void sendMessage(String key, Object message) {
        CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
        //把消息放入ROUTINGKEY对应的队列当中去
        rabbitTemplate.convertAndSend(key, message,correlationId);
        LOG.info("rabbitmq|RabbitHelper发送消息:key="+key+",msg="+ JSON.toJSONString(message));
    }