手摸手系列之SpringBoot整合RabbitMQ详细教程

参考：Springboot 整合RabbitMq ，用心看完这一篇就够了
版本：SpringBoot 2.6.4

一、简介

在安装完RabbitMQ后，输入http://ip:15672/，可以看到一个简单后台管理界面。

在这个界面里面我们可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。

首先先介绍一个简单的一个消息推送到接收的流程，提供一个简单的图：

黄色的圈圈就是我们的消息推送服务，将消息推送到 中间方框里面也就是 rabbitMq的服务器，然后经过服务器里面的交换机、队列等各种关系（后面会详细讲）将数据处理入列后，最终右边的蓝色圈圈消费者获取对应监听的消息。

常用的交换机有以下三种，因为消费者是从队列获取信息的，队列是绑定交换机的（一般），所以对应的消息推送/接收模式也会有以下几种：

Direct Exchange

直连型交换机，根据消息携带的路由键将消息投递给对应队列。

大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key 。

然后当一个消息携带着路由值为X，这个消息通过生产者发送给交换机时，交换机就会根据这个路由值X去寻找绑定值也是X的队列。

Fanout Exchange

扇型交换机，这个交换机没有路由键概念，就算你绑了路由键也是无视的。 这个交换机在接收到消息后，会直接转发到绑定到它上面的所有队列。

Topic Exchange

主题交换机，这个交换机其实跟直连交换机流程差不多，但是它的特点就是在它的路由键和绑定键之间是有规则的，简单地介绍下规则：
(星号) 用来表示一个单词 (必须出现的)，# **(井号) 用来表示任意数量（零个或多个）**单词通配的绑定键是跟队列进行绑定的。
举个例子队列Q1 绑定键为 .TT. ，队列Q2绑定键为TT.#，如果一条消息携带的路由键为 A.TT.B，那么队列Q1将会收到；如果一条消息携带的路由键为TT.AA.BB，那么队列Q2将会收到。

主题交换机是非常强大的，当一个队列的绑定键为 “#”（井号） 的时候，这个队列将会无视消息的路由键，接收所有的消息。当 * (星号) 和 # (井号) 这两个特殊字符都未在绑定键中出现的时候，此时主题交换机就拥有的直连交换机的行为。所以主题交换机也就实现了扇形交换机的功能，和直连交换机的功能。

另外还有 Header Exchange 头交换机 ，Default Exchange 默认交换机，Dead Letter Exchange 死信交换机，这几个该篇暂不做讲述。

二、代码实现

1. 新建SpringBoot项目rabbitmq-server，做为RabbitMQ的消息生产者

pom依赖：

    org.springframework.boot
    spring-boot-starter-web
    2.6.4


    org.springframework.boot
    spring-boot-starter-amqp

application.yml配置文件：

# 服务端口
server:
  port: 8081

#rabbitMQ配置
spring:
  application:
    name: rabbitmq-server
  rabbitmq:
    host: 127.0.0.1
    username: yorma
    password: yormA2022
    virtual-host: /yorma

接着我们先使用下direct exchange(直连型交换机)，创建配置类DirectExchangeConfig（对于队列和交换机持久化以及连接使用设置，在注释里有说明，后面的不同交换机的配置就不做同样说明了）：

package com.junya.rabbitserver.config;

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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 直连型交换机配置
 *
 * @author ZHANGCHAO
 * @version 1.0.0
 * @date 2022/3/8 10:03
 */
@Configuration
public class DirectExchangeConfig {

    /**
     * 交换机
     *
     * @return org.springframework.amqp.core.DirectExchange
     * @author ZHANGCHAO
     * @date 2022/3/8 10:09
     */
    @Bean
    DirectExchange directExchange() {
        return new DirectExchange("directExchange", true, false);
    }

    /**
     * 队列
     *
     * @return org.springframework.amqp.core.Queue
     * @author ZHANGCHAO
     * @date 2022/3/8 10:08
     */
    @Bean
    public Queue directQueue() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
//        return new Queue("TestDirectQueue",true,true,false);

        // 一般设置一下队列的持久化就好,其余两个就是默认false
        return new Queue("directQueue", true);
    }

    /**
     * 绑定。将交换机和队列绑定，并设置用于匹配键：directRouting
     *
     * @return org.springframework.amqp.core.Binding
     * @author ZHANGCHAO
     * @date 2022/3/8 10:10
     */
    @Bean
    Binding directBinding() {
        return BindingBuilder.bind(directQueue()).to(directExchange()).with("directRouting");
    }
}

然后写个简单的接口进行消息推送（根据需求也可以改为定时任务等等，具体看需求）：

package com.junya.rabbitserver.web;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

/**
 * 消息发送控制器
 *
 * @author ZHANGCHAO
 * @version 1.0.0
 * @date 2022/3/8 10:14
 */
@RestController
public class SendMessageController {

    // 使用RabbitTemplate，这提供了接收/发送等等方法
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendDirectMessage")
    public String sendDirectMessage() {
        String messageId = IdUtil.fastSimpleUUID();
        String messageData = "测试direct message，欧耶！";
        String createTime = DateUtil.now();
        Map map = new HashMap<>(16);
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        rabbitTemplate.convertAndSend("directExchange", "directRouting", map);
        return "ok";
    }
}

运行rabbitmq-server，然后用postman调用接口测试：

因为我们目前还没弄消费者 rabbitmq-client，消息没有被消费的，我们去RabbitMQ管理页面看看，是否推送成功：

很好，消息已经推送到RabbitMQ服务器上面了。

2. 新建SpringBoot项目rabbitmq-client，做为RabbitMQ的消息消费者

pom依赖：

    org.springframework.boot
    spring-boot-starter-amqp


    org.springframework.boot
    spring-boot-starter-web

application.yml配置文件：

# 服务端口
server:
  port: 8082

#rabbitMQ配置
spring:
  application:
    name: rabbitmq-client
  rabbitmq:
    host: 127.0.0.1
    username: yorma
    password: yormA2022
    virtual-host: /yorma

PS：消费者单纯的使用，其实可以不用添加DirectExchangeConfig配置类，直接建后面的监听就好，使用注解来让监听器监听对应的队列即可。配置上了的话，其实消费者也是生成者的身份，也能推送该消息。此处忽略。

然后是创建消息接收监听类，用来监听和接收消息：

package com.junya.rabbitmqclient.receiver;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 直连型消费者
 *
 * @author ZHANGCHAO
 * @version 1.0.0
 * @date 2022/3/8 10:27
 */
@Slf4j
@Component
@RabbitListener(queues = {"directQueue"}) // 监听的队列名称 directQueue
public class DirectReceiver {

    @RabbitHandler
    public void process(Map message) {
        log.info("[test-direct]消费者收到消息：" + message.toString());
    }
}

然后将项目运行起来，可以看到把之前推送的那条消息消费下来了：

然后可以再继续调用rabbitmq-server项目的推送消息接口，可以看到消费者即时消费消息：

思考：直连交换机既然是一对一，那如果咱们配置多台监听绑定到同一个直连交换机的同一个队列，会怎么样？咱试验一下：

新建一个监听接收类NewDirectReceiver：

package com.junya.rabbitmqclient.receiver;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 直连型消费者
 *
 * @author ZHANGCHAO
 * @version 1.0.0
 * @date 2022/3/8 10:27
 */
@Slf4j
@Component
@RabbitListener(queues = {"directQueue"}) // 监听的队列名称 directQueue
public class NewDirectReceiver {

    @RabbitHandler
    public void process(Map message) {
        log.info("22222=>[test-direct]消费者收到消息：" + message.toString());
    }
}

再次调用生产消息接口，可以看到是实现了轮询的方式对消息进行消费，而且不存在重复消费。

总结
direct直连型的exchange路由规则很简单：
exchange在和queue进行binding时会设置routingkey
然后我们在将消息发送到exchange时会设置对应的routingkey
在direct类型的exchange中，只有这两个routingkey完全相同，exchange才会选择对应的binging进行消息路由。