在SpringBoot中使用RabbitMQ

1. 添加pom依赖

 

 <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.22</version>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>2.1.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
            <version>2.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>

2. 定义消息队列的一些常量

package com.devin.order.config;

/**
 * @author Devin Zhang
 * @className RabbitConstants
 * @description TODO
 * @date 2020/4/25 10:11
 */

public class RabbitConstants {

    /**
     * 分列模式
     */
    public final static String FANOUT_MODE_QUEUE = "fanout.mode";

    /**
     * 日志打印队列
     */
    public final static String QUEUE_LOG_PRINT = "queue.log.recode";

    /**
     * 主题模式
     */
    public final static String TOPIC_MODE_QUEUE = "topic.mode";

    /**
     * 主题模式
     */
    public final static String TOPIC_ROUTING_KEY = "topic.*";

}

3. 设置RabbitMQ的配置类

   

package com.devin.order.config;

/**
 * @author Devin Zhang
 * @className RabbitMqConfig
 * @description TODO
 * @date 2020/4/25 10:12
 */


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Slf4j
@Configuration
public class RabbitMqConfig {

    @Bean
    public RabbitTemplate rabbitTemplate(CachingConnectionFactory connectionFactory) {
        connectionFactory.setPublisherConfirms(true);
        connectionFactory.setPublisherReturns(true);
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> log.info("消息发送成功:correlationData[{}],ack[{}],cause[{}]", correlationData, ack, cause));
        rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> log.info("消息丢失:exchange[{}],route[{}],replyCode[{}],replyText[{}],message:{}", exchange, routingKey, replyCode, replyText, message));
        return rabbitTemplate;
    }

    /**
     * 日志打印队列
     */
    @Bean
    public Queue logPrintQueue() {
        return new Queue(RabbitConstants.QUEUE_LOG_PRINT);
    }

    /**
     * 分列模式队列
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(RabbitConstants.FANOUT_MODE_QUEUE);
    }

    /**
     * 分列模式绑定队列
     *
     * @param logPrintQueue  绑定队列
     * @param fanoutExchange 分列模式交换器
     */
    @Bean
    public Binding fanoutBinding(Queue logPrintQueue, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(logPrintQueue).to(fanoutExchange);
    }

    /**
     * 主题队列
     */
    @Bean
    public Queue topicQueue() {
        return new Queue(RabbitConstants.TOPIC_ROUTING_KEY);
    }

    /**
     * 主题模式队列
     * <li>路由格式必须以 . 分隔，比如 user.email 或者 user.aaa.email</li>
     * <li>通配符 * ，代表一个占位符，或者说一个单词，比如路由为 user.*，那么 user.email 可以匹配，但是 user.aaa.email 就匹配不了</li>
     * <li>通配符 # ，代表一个或多个占位符，或者说一个或多个单词，比如路由为 user.#，那么 user.email 可以匹配，user.aaa.email 也可以匹配</li>
     */
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(RabbitConstants.TOPIC_MODE_QUEUE);
    }

    /**
     * 主题模式绑定队列2
     *
     * @param topicQueue    主题队列
     * @param topicExchange 主题模式交换器
     */
    @Bean
    public Binding topicBinding(Queue topicQueue, TopicExchange topicExchange) {
        return BindingBuilder.bind(topicQueue).to(topicExchange).with(RabbitConstants.TOPIC_ROUTING_KEY);
    }

}

  4. 消息的处理类

   

package com.devin.order.Service;

/**
 * 【消息队列处理器】
 *
 * @author Devin Zhang
 * @className RabbitMqHandler
 * @description TODO
 * @date 2020/4/25 10:54
 */


import com.devin.order.config.RabbitConstants;
import com.devin.order.mapper.OrderMapper;
import com.devin.order.model.Order;
import com.devin.order.util.RedisClient;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;


@Slf4j
@Component
public class RabbitMqHandler {

    @Resource
    private RedisClient redisClient;

    @Resource
    private OrderMapper orderMapper;

    /**
     * 日志打印处理handler
     *
     * @param message 待处理的消息体
     */
    @RabbitListener(queues = RabbitConstants.QUEUE_LOG_PRINT)
    public void queueLogPrintHandler(String message) {
        log.info("接收到操作日志记录消息：[{}]", message);
    }

    /**
     * 主题模式处理handler
     *
     * @param message 待处理的消息体
     */
    @RabbitListener(queues = RabbitConstants.TOPIC_ROUTING_KEY)
    public void queueTopicHandler(String message) {
        log.info("主题模式处理器，接收消息：[{}]", message);
        
        //todo 逻辑处理

        

    }

}

5. 发送消息测试

import com.devin.order.OrderGrabbingApplication;
import com.devin.order.config.RabbitConstants;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

/**
 * @author Devin Zhang
 * @className MqSendTest
 * @description TODO
 * @date 2020/4/28 16:49
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {OrderGrabbingApplication.class})// 指定启动类
@Slf4j
public class MqSendTest {

    @Resource
    private RabbitTemplate rabbitTemplate;


    @Test
    public void mqSend(){
        String message = "topic message";
        rabbitTemplate.convertAndSend(RabbitConstants.TOPIC_MODE_QUEUE, "topic.queue", message);
        log.info("消息发送成功：[{}]", message);
    }
}