SpringBoot RabbitMQ 实战

RabbitMQ

RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。

RabbitMQ是一套开源（MPL）的消息队列服务软件，是由 LShift 提供的一个 Advanced Message Queuing Protocol (AMQP) 的开源实现，由以高性能、健壮以及可伸缩性出名的 Erlang 写成。

RabbitMQ 七种队列模式

• 简单模式（Hello World）：
  
  做最简单的事情，一个生产者对应一个消费者，RabbitMQ相当于一个消息代理，负责将A的消息转发给B。
• 工作队列模式（Work queues）：
  
  在多个消费者之间分配任务（竞争的消费者模式），一个生产者对应多个消费者，一般适用于执行资源密集型任务，单个消费者处理不过来，需要多个消费者进行处理。
• 订阅模式（Publish/Subscribe）：
  
  一次向许多消费者发送消息，一个生产者发送的消息会被多个消费者获取，也就是将消息将广播到所有的消费者中。
• 路由模式（Routing）：
  
  有选择地（Routing key）接收消息，发送消息到交换机并且要指定路由key ，消费者将队列绑定到交换机时需要指定路由key，仅消费指定路由key的消息。
• 主题模式（Topics）：
  
  根据主题（Topics）来接收消息，将路由key和某模式进行匹配，此时队列需要绑定在一个模式上，#匹配一个词或多个词，*只匹配一个词。
• 远程过程调用（RPC）：客户端发送一个请求消息，服务端以一个响应消息回应。
• 发布者确认（Publisher Confirms）：与发布者进行可靠的发布确认，发布者确认是RabbitMQ扩展，可以实现可靠的发布。在通道上启用发布者确认后，RabbitMQ将异步确认发送者发布的消息，这意味着它们已在服务器端处理。

四种交换机

• 直连交换机（Direct exchange）：
  
  具有路由功能的交换机，绑定到此交换机的时候需要指定一个routing_key，交换机发送消息的时候需要routing_key，会将消息发送道对应的队列。
• 扇形交换机（Fanout exchange）：
  
  广播消息到所有队列，没有任何处理，速度最快。
• 主题交换机（Topic exchange）：
  
  在直连交换机基础上增加模式匹配，也就是对routing_key进行模式匹配，*代表一个单词，#代表多个单词。
• 首部交换机（Headers exchange）：
  
  忽略routing_key，使用Headers信息（一个Hash的数据结构）进行匹配，优势在于可以有更多更灵活的匹配规则。

安装环境（centos7）

安装包下载

Erlang和RabbitMQ官网下载速度特别慢，可用 erlang-solutions.com 下载，速度特别快。

https://www.erlang-solutions.com/downloads/

安装版本

• Erlang：esl-erlang_23.0-1_centos_7_amd64.rpm

• RabbitMQ：rabbitmq-server-generic-unix-3.7.7.tar.xz

一、安装Erlang

1.编译依赖

yum install esl-erlang_23.0-1_centos_7_amd64.rpm

2.查看Erlang版

erl -version

二、安装RabbitMq

1.解压包

xz -d rabbitmq-server-generic-unix-3.7.7.tar.xz

tar -xvf rabbitmq-server-generic-unix-3.7.7.tar

2.设置RabbitMq的环境变量

进入到rabbit文件内，其命令文件存在于sbin文件夹下，因此需要将sbin文件夹的路径添加到PATH中：修改/etc/profile

cd rabbitmq_server-3.7.7/sbin

export PATH=/usr/local/rabbitmq_server-3.7.7/sbin:$PATH

3.PATH路径更新

source /etc/profile

4.开启 web 管理插件

rabbitmq-plugins enable rabbitmq_management

5.启动

#启动后台管理
./rabbitmq-plugins enable rabbitmq_management   

#后台运行rabbitmq
./rabbitmq-server -detached

6.新建用户

由于guest用户被限制，只能通过localhost访问，因此我们需要新建一个用户，并授予管理员权限。

新建一个用户名为admin,密码为admin的用户，并授予管理员（administrator）权限

./rabbitmqctl add_user admin admin

./rabbitmqctl set_user_tags admin administrator

7.浏览器访问

默认端口为：15672

http://127.0.0.1:15672

效果

SpringBoot整合

以下贴出的代码只是关键代码，涉及业务相关的已删除，请自行处理。

1、说明

使用是主题模式 + 主题交换机 + 消息确认机制

2、添加依赖

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

3、核心配置文件

spring:
  # 配置rabbitMq 服务器
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    # 开启confirm确认机制
    publisher-confirms: true
    # 开启return确认机制
    publisher-returns: true
    template:
      # 设置为true后，消费者在消息没有被路由到合适队列情况下会被return监听，而不会自动删除
      mandatory: true
    listener:
      simple:
        # 设置消费端手动 ack
        acknowledge-mode: manual
        # 消费者最小数量
        concurrency: 1
        # 消费之最大数量
        max-concurrency: 20
        # 每次只处理一个消息
        prefetch: 1
        retry:
          # 是否支持重试
          enabled: true

4、常量配置（AmqpConstant.java）

public class AmqpConstant {

	/**
	 * 支付路由key
	 * *：匹配不多不少一个词
	 * #：匹配一个或多个词
	 */
	public static final String PAY_QUEUE = "pay_queue";
	public static final String PAY_ROUTING_KEY = "pay.order";
	public static final String _PAY_ROUTING_KEY = "pay.#";

	/**
	 * 查询路由key
	 */
	public static final String QUERY_QUEUE = "query_queue";
	public static final String QUERY_ROUTING_KEY = "query.order";
	public static final String _QUERY_ROUTING_KEY = "query.#";

	/**
	 * 交换机名称
	 */
	public static final String PAY_EXCHANGE_NAME = "PAY-EXCHANGE";

	//===================================================================================

	/**
	 * 使用Redis保证消息幂等性
	 */
	public static final String PAY_QUEUE_REDIS_KEY = "pay-queue:";

	/**
	 * Redis消息ID key 的过期时间，单位：秒
	 */
	public static final Integer PAY_QUEUE_REDIS_KEY_TIMEOUT = 7200;

	/**
	 * 轮询查询订单状态的睡眠时间，单位：秒
	 */
	public static final Integer POLLING_STATUS_TIME = 2000;

}

5、配置队列、路由交换机，TopicQueueConfig.java

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

@Configuration
public class TopicQueueConfig {

	@Autowired
	private RabbitTemplate rabbitTemplate;

	/**
	 * 支付队列
	 *
	 * @return
	 */
	@Bean
	public Queue payTopicQueue() {
		return new Queue(AmqpConstant.PAY_QUEUE, true);
	}

	/**
	 * 查询队列
	 *
	 * @return
	 */
	@Bean
	public Queue queryTopicQueue() {
		return new Queue(AmqpConstant.QUERY_QUEUE, true);
	}

	/**
	 * 路由交换机
	 *
	 * @return
	 */
	@Bean
	public TopicExchange topicExchange() {
		return new TopicExchange(AmqpConstant.PAY_EXCHANGE_NAME);
	}

	/**
	 * 队列绑定交换机,指定routingKey,也可在可视化工具中进行绑定
	 *
	 * @return
	 */
	@Bean
	Binding payBindingTopicExchange(Queue payTopicQueue, TopicExchange exchange) {
		return BindingBuilder.bind(payTopicQueue).to(exchange).with(AmqpConstant._PAY_ROUTING_KEY);
	}

	/**
	 * 队列绑定交换机,指定routingKey,也可在可视化工具中进行绑定
	 *
	 * @return
	 */
	@Bean
	Binding queryBindingTopicExchange(Queue queryTopicQueue, TopicExchange exchange) {
		return BindingBuilder.bind(queryTopicQueue).to(exchange).with(AmqpConstant._QUERY_ROUTING_KEY);
	}

	@PostConstruct
	public void initRabbitTemplate() {
		// 设置生产者消息确认
		rabbitTemplate.setConfirmCallback(new RabbitConfirmCallback());
		rabbitTemplate.setReturnCallback(new RabbitConfirmReturnCallBack());
	}

}

6、生产端 Confirm 消息确认机制

消息的确认，是指生产者投递消息后，如果 Broker 收到消息，则会给我们生产者一个应答。生产者进行接收应答，用来确定这条消息是否正常的发送到 Broker ，这种方式也是消息的可靠性投递的核心保障!

RabbitConfirmCallback.java

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;

/**
 * 消息发送确认类
 */
@Slf4j
public class RabbitConfirmCallback implements RabbitTemplate.ConfirmCallback {

	@Override
	public void confirm(CorrelationData correlationData, boolean ack, String cause) {
		log.info("=======ConfirmCallback===correlationData:{}=====ack:{}=====cause:{}========", correlationData, ack, cause);
	}
}

7、Return 消息机制

Return Listener 用于处理一-些不可路 由的消息!

当exchange不存在或者指定的路由 key 路由不到时，这个时候如果我们需要监听这种不可达的消息，就要使用 Return Listener !

RabbitConfirmReturnCallBack.java

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;

/**
 * 消息发送交换机返回机制
 */
@Slf4j
public class RabbitConfirmReturnCallBack implements RabbitTemplate.ReturnCallback{

	@Override
	public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
		log.info("===RabbitConfirmReturnCallBack====exchange: {}======routingKey:{}=====replyCode:{}====replyText: {}======", exchange, routingKey, replyCode, replyText);
	}
}

在基础API中有一个关键的配置项:Mandatory：如果为 true，则监听器会接收到路由不可达的消息，然后进行后续处理，如果为 false，那么 broker 端自动删除该消息!

8、消息生产者相关

一个发送支付生产者、一个查询订单转态的生产者。

8.1、生产者 OrderProvider.java

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.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Objects;

/**
 * 消息生产者
 */
@Slf4j
@Service
public class OrderProvider {

	@Autowired
	private RabbitTemplate rabbitTemplate;

	/**
	 * 支付消息生产者方法
	 *
	 * @param messages
	 */
	public void sendObject(List<Message> messages) {
		try {
			if (!Objects.isNull(messages) && messages.size() > 0) {
				log.info("========支付生产消息开始=====总消息个数为：{}==========", messages.size());
				messages.forEach(message -> {
					// 全局唯一
					CorrelationData correlationData = new CorrelationData(message.getMessageId());
					rabbitTemplate.convertAndSend(AmqpConstant.PAY_EXCHANGE_NAME, AmqpConstant.PAY_ROUTING_KEY, message, correlationData);
				});
				log.info("========支付生产消息结束=====总消息个数为：{}==========", messages.size());
			}
		} catch (Exception e) {
			log.error("====支付生产消息异常=======：{}", e.getMessage());
			e.printStackTrace();
		}
	}

	/**
	 * 查询消息生产者方法
	 *
	 * @param message
	 */
	public void sendQuery(Message message) {
		try {
			if (Objects.nonNull(message)) {
				log.info("========查询消息生产者开始=====");
				// 全局唯一
				CorrelationData correlationData = new CorrelationData(message.getMessageId());
				rabbitTemplate.convertAndSend(AmqpConstant.PAY_EXCHANGE_NAME, AmqpConstant.QUERY_ROUTING_KEY, message, correlationData);
				log.info("========查询消息生产者结束=======消息ID:{}", correlationData);
			}
		} catch (Exception e) {
			log.error("====查询消息生产者异常=======：{}", e.getMessage());
			e.printStackTrace();
		}
	}

}

8.2、消息实体 Message.java

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

import java.io.Serializable;
import java.time.LocalDateTime;

@Data
@SuperBuilder
@AllArgsConstructor
@NoArgsConstructor
public class Message implements Serializable {

	/**
	 * 消息Id
	 */
	private String messageId;

	/**
	 * 消息内容
	 */
	private Object messageData;

	/**
	 * 消息创建时间
	 */
	private LocalDateTime createTime;

}

8.3、生产者Controller OrderProviderController.java

import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@Slf4j
@RestController
@RequestMapping(value = "/mqprovider")
@AllArgsConstructor
public class OrderProviderController {

	@Autowired
	private OrderProvider orderProvider;

	/**
    *支付消息生产者
    */
	@PostMapping("/sendobject")
	public String sendobject(@RequestBody List<Message> messageList) {
		orderProvider.sendObject(messageList);
		return "success";
	}

    /**
    *查询消息生产者
    */
	@PostMapping("/sendquery")
	public String sendQuery(@RequestBody Message message) {
		orderProvider.sendQuery(message);
		return "success";
	}

}

9、消费者相关

9.1、支付消息接收监听 OrderPayReceiver.java

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * 支付消息接收监听
 */
@Slf4j
@Component
public class OrderPayReceiver {

	@Autowired
	private OrderProvider orderProvider;

	@Autowired
	private RedisTemplate redisTemplate;

	@RabbitListener(queues = AmqpConstant.PAY_QUEUE)
	public void payMessage(@Payload Message message, Channel channel, @Headers Map<String, Object> headers) {
		try {
			// 保证消息幂等性
			Object redisMessageId = redisTemplate.opsForValue().get(AmqpConstant.PAY_QUEUE_REDIS_KEY + message.getMessageId());
			if (!Objects.isNull(redisMessageId) && message.getMessageId().equals(String.valueOf(redisMessageId))) {
				// 手工ack
				channel.basicAck((Long) headers.get(AmqpHeaders.DELIVERY_TAG), true);
				return;
			}
			log.info("==============支付消费者开始======消息ID：{}====消息创建时间：{}", message.getMessageId(), message.getCreateTime());

			// 调用支付接口  TODO

			// 消息ID存入Redis
			redisTemplate.opsForValue().set(AmqpConstant.PAY_QUEUE_REDIS_KEY + message.getMessageId(), message.getMessageId(), AmqpConstant.PAY_QUEUE_REDIS_KEY_TIMEOUT, TimeUnit.SECONDS);

			// 将支付调用成功的消息放入查询队列中 TODO
			// orderProvider.sendQuery();

			// 手工ack
			channel.basicAck((Long) headers.get(AmqpHeaders.DELIVERY_TAG), true);
			log.info("==============支付消费者结束==========");
		} catch (Exception e) {
			log.error("==============支付消费者异常，异常信息：{}", e.getMessage());
			e.printStackTrace();
		}
	}

}

9.2、查询消息接收监听 OrderQueryReceiver.java

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

import java.util.Map;
import java.util.Objects;

/**
 * 查询消息接收监听
 */
@Slf4j
@Component
public class OrderQueryReceiver {

	@RabbitListener(queues = AmqpConstant.QUERY_QUEUE)
	public void onUserMessage(@Payload Message message, Channel channel, @Headers Map<String, Object> headers) {
		try {
			log.info("==============查询消费者开始======消息ID：{}====消息创建时间：{}", message.getMessageId(), message.getCreateTime());
			// 调用查询订单状态接口 TODO

			log.info("=====查询支付接口返回======支付状态：{}====支付状态描述：{}=====", result.getCode(), result.getMessage());
			// 手工ack
			long deliveryTag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);
			channel.basicAck(deliveryTag, true);
			log.info("==============查询消费者结束======deliveryTag:{}====", deliveryTag);
		} catch (Exception e) {
			log.error("==============查询消费者异常，异常信息：{}", e.getMessage());
			e.printStackTrace();
		}
	}

}

业务架构

需求：每天按照需求批量生产订单数据，进行调用三方支付接口进行支付操作。有实时放回支付状态的，也有异步返回状态的，具需求要求本业务不提供回调更新状态机制，需自身请求三方接口更新订单转态（业务中有批量支付操作）。

简易业务架构图如下：

以上是结合项目需求设计的业务实现。

如何保证消息不被重复消费?

生产时消息重复

为什么会出现消息重复？消息重复的原因有两个：

• 1.生产时消息重复，

• 2.消费时消息重复。

由于生产者发送消息给MQ，在MQ确认的时候出现了网络波动，生产者没有收到确认，实际上MQ已经接收到了消息。这时候生产者就会重新发送一遍这条消息。

生产者中如果消息未被确认，或确认失败，可以使用定时任务+（redis/db）来进行消息重试。

消费时消息重复

以订单ID作为消息ID，即可保证消息的幂等性，消费过程为：

• 消费者获取到消息后先根据id去查询redis/db是否存在该消息；

• 如果不存在，则正常消费，消费完毕后写入redis/db；

• 如果存在，则证明消息被消费过，直接丢弃。