springBoot中使用rabbitMQ以及消息丢失问题
一、rabbitMQ中常用的交换机
图源自官网：https://www.rabbitmq.com/getstarted.html
Direct exchange 直连交换机
- 一个生产者，一个交换机，两个队列，两个消费者
根据消息发送时携带的路由routingKey(假设为mq.key.name)，将消息投递给与交换机绑定的队列(该对列与交换机绑定的路由同样为mq.key.name)
Fanout exchange 扇形交换机
- 一个生产者，一个交换机，两个队列，两个消费者
扇形交换机会将消息路由到绑定到交换机上的所有队列，可以想象成一个广播，广播消息一发出，所有听众都能够接收到消息
Topic exchange 主题交换机
- 一个生产者，一个交换机，两个队列，两个消费者
主题交换机中*跟#的区别
*代表匹配一个标识符
#可以匹配0个或者多个标识符
标识符之间由.隔开，以上图为例，现在发送一条消息message1携带路由routingKey为topic.orange.name，根据队列与交换机的路由绑定规则，messgage1将会被路由到Q1队列中，最终被C1消费者消费；发送消息message2与message3携带的路由为lazy.key和lazy.key.name,根据队列与交换机的路由绑定规则，message2和message3都会被路由到Q2队列中，最终被C2消费者消费。
Dead Letter Exchange 死信交换机
- 先说死信队列，死信队列由死信交换机(DLX)、死信路由(DLK)、消息存活时间(TTL)组成，其中TTL为非必须部分，可以没有。
- 当我们发送消息message4到死信队列时，我们先要有一个普通的交换机，一个普通的路由，先将死信队列绑定到普通的交换机上。当message4的存活时间到期后，message4将会被发送到普通队列queue4中(queue4通过死信路由和死信交换机绑定)，此时会被监听queue4的消费者消费。
- 死信队列一般用在订单超时取消。
二、springBoot项目中使用rabbitMQ
创建两个项目，一个用作消息的生产者，一个用作消息的消费者
创建springBoot项目教程略过。如有疑问可自信查阅相关文档
1.两个项目中都需导入maven依赖
<!--amqp 依赖包-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
两个项目中的yml文件配置基本相同
spring:
rabbitmq:
host: *****
username: ****
password: ****
port: 5672
- host：填写rabbitmq服务的ip地址
- username：登录的用户名，如果安装时未指定，账号密码都是guest
- password：登录的密码
- port：默认是5672
yml文件的交换机、队列名称、路由名称配置
rabbit:
applicationManualTopicExchange: mq.manual.knowledge.exchange.name
applicationManualTopicQueue: mq.manual.knowledge.queue.name
applicationManualRoutingKey: mq.manual.knowledge.key.name
springBoot的启动类上添加注解
@EnableRabbit
生产者项目
1.在生产者中创建RabbitMqTemplateConfig配置类
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.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
/**
* 描述 : rabbitTemplate配置、交换机、队列创建
*
* @AUTHOR
* @DATE 2022/3/2 14:02
* @DESCRIPTION:
*/
@Configuration
public class RabbitMqTemplateConfig {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
@Resource
private CachingConnectionFactory connectionFactory;
@Value("${rabbit.applicationManualTopicExchange}")
private String applicationManualTopicExchange;
@Value("${rabbit.applicationManualTopicQueue}")
private String applicationManualTopicQueue;
@Value("${rabbit.applicationManualRoutingKey}")
private String applicationManualRoutingKey;
@Bean
public Queue applicationManualTopicQueue(){
//true代表持久化到磁盘
return new Queue(applicationManualTopicQueue,true);
}
@Bean
public TopicExchange applicationManualTopicExchange(){
//true代表持久化到磁盘
return new TopicExchange(applicationManualTopicExchange,true,false);
}
@Bean
public Binding manualBinding(){
return BindingBuilder.bind(applicationManualTopicQueue()).to(applicationManualTopicExchange()).with(applicationManualRoutingKey);
}
@Bean
public RabbitTemplate rabbitTemplate(){
//connectionFactory.setPublisherConfirms(true);
connectionFactory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.CORRELATED);
connectionFactory.setPublisherReturns(true);
RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
rabbitTemplate.setMandatory(true);
rabbitTemplate.setConfirmCallback((CorrelationData correlationData, boolean ack, String cause)->{
logger.info("消息发送成功:correlationData({}),ack({}),cause({})",correlationData,ack,cause);
});
rabbitTemplate.setReturnCallback((Message message, int replyCode, String replyText, String exchange, String routingKey)->{
logger.info("消息丢失:exchange({}),route({}),replyCode({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,message);
});
return rabbitTemplate;
}
}
2.要发送的消息实体类
注意如果消息要在MQ中持久化到磁盘中必须实现Serializable接口
import java.io.Serializable;
/**
* 描述 : 注意如果消息要在MQ中持久化到磁盘中必须实现Serializable接口
*
* @AUTHOR
* @DATE 2022/3/2 16:34
* @DESCRIPTION:
*/
public class Message implements Serializable {
private String messageId;
private String content;
public String getMessageId() {
return messageId;
}
public void setMessageId(String messageId) {
this.messageId = messageId;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
return "Message{" +
"messageId='" + messageId + '\'' +
", content='" + content + '\'' +
'}';
}
}
3.创建生产者类BasicPublisherManager
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.***.***.***.WeChatApplicationTextMessage;
import com.***.***.***.WeChatApplicationTextMessageContent;
import com.***.***.utils.IdWorker;
import com.***.****.***.ExamPaper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.AbstractJavaTypeMapper;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.nio.charset.StandardCharsets;
/**
* 描述 : 消息生产者
*
* @AUTHOR
* @DATE 2022/3/2 15:21
* @DESCRIPTION:
*/
@Component
public class ApplicationMsgPublisherManager {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
@Resource
private ObjectMapper objectMapper;
@Value("${rabbit.applicationManualTopicExchange}")
private String applicationManualTopicExchange;
@Value("${rabbit.applicationManualRoutingKey}")
private String applicationManualRoutingKey;
@Resource
private RabbitTemplate rabbitTemplate;
@Async
public void send(ExamPaper paper){
WeChatApplicationTextMessage message = new WeChatApplicationTextMessage();
WeChatApplicationTextMessageContent messageContent = new WeChatApplicationTextMessageContent();
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(paper.getExamPerson());
messageContent.setContent(String.valueOf(stringBuffer));
//雪花算法生成的ID
message.setId(IdWorker.getId());
message.setToUser(paper.getPaperBy());
message.setText(messageContent);
sendWeChatApplicationManualMsg(message);
}
/**
* 传入消息接收者，消息内容
* @param message
*/
public void sendWeChatApplicationManualMsg(WeChatApplicationTextMessage message){
try {
rabbitTemplate.setExchange(applicationManualTopicExchange);
rabbitTemplate.setRoutingKey(applicationManualRoutingKey);
Message msg = MessageBuilder.withBody(objectMapper.writeValueAsBytes(message))
.setDeliveryMode(MessageDeliveryMode.PERSISTENT)
.build();
rabbitTemplate.convertAndSend(msg);
logger.info("基于MANUAL机制-发送消息-内容为：{} ",message);
} catch (JsonProcessingException e) {
logger.error("基于MANUAL机制-息转换byte异常 ",message,e.fillInStackTrace());
} catch (Exception e){
logger.error("基于MANUAL机制-发送消息-发生异常：{} ",message,e.fillInStackTrace());
}
}
/**
*交换机、队列、路由绑定需创建，可在config类中创建
* 发送普通文本消息
* @param message
*/
public void sendStrMsg(String message){
try {
rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
rabbitTemplate.setExchange("str.exchange.name");
rabbitTemplate.setRoutingKey("str.routingKey.name");
Message msg = MessageBuilder.withBody(message.getBytes(StandardCharsets.UTF_8))
.setDeliveryMode(MessageDeliveryMode.PERSISTENT).build();
rabbitTemplate.convertAndSend(msg);
logger.info("文本消息发送成功，消息:{}",message);
} catch (AmqpException e) {
logger.error("基本消息模型-生产者-发送消息发生异常：{} ",message,e.fillInStackTrace());
}
}
/**
*交换机、队列、路由绑定需创建，可在config类中创建
* 发送普通文本消息
* @param message
*/
public void sendObjectMsg(Message message){
try {
rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
rabbitTemplate.setExchange("str.exchange.name");
rabbitTemplate.setRoutingKey("str.routingKey.name");
rabbitTemplate.convertAndSend(message,(Message msg)->{
MessageProperties messageProperties = msg.getMessageProperties();
messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
messageProperties.setHeader(AbstractJavaTypeMapper.DEFAULT_CONTENT_CLASSID_FIELD_NAME,Message.class);
return msg;
});
logger.info("基本消息模型-生产者-发送对象类型的消息：{} ",message);
} catch (AmqpException e) {
logger.error("基本消息模型-生产者-发送对象类型的消息发生异常：{} ",message,e.fillInStackTrace());
}
}
}
消费者项目
1.创建config类
import com.***.***.***.ApplicationKnowledgeManualConsumer;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.support.DefaultMessagePropertiesConverter;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
/**
* 描述 :
*
* @AUTHOR
* @DATE 2022/3/2 14:02
* @DESCRIPTION:
*/
@Configuration
public class RabbitMqTemplateConfig {
@Resource
private CachingConnectionFactory connectionFactory;
@Resource
private SimpleRabbitListenerContainerFactoryConfigurer factoryConfigurer;
@Value("${rabbit.applicationManualTopicExchange}")
private String applicationManualTopicExchange;
@Value("${rabbit.applicationManualTopicQueue}")
private String applicationManualTopicQueue;
@Value("${rabbit.applicationManualRoutingKey}")
private String applicationManualRoutingKey;
/**
* 手动确认消费者实例
*/
@Resource
private ApplicationKnowledgeManualConsumer applicationKnowledgeManualConsumer;
@Bean
public SimpleRabbitListenerContainerFactory simpleListenerContainerFactory(){
SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
factory.setConnectionFactory(connectionFactory);
//rabbitMQ的默认序列化方式为SerializerMessageConverter,这里我们使用Jackson2JsonMessageConverter序列化器
factory.setMessageConverter(new Jackson2JsonMessageConverter());
//配置多个消费者需注意消息重复消费的问题
factory.setConcurrentConsumers(1);
factory.setMaxConcurrentConsumers(1);
factory.setPrefetchCount(1);
return factory;
}
@Bean
public Queue applicationManualTopicQueue(){
//true代表持久化到磁盘
return new Queue(applicationManualTopicQueue,true);
}
@Bean
public TopicExchange applicationManualTopicExchange(){
//true代表持久化到磁盘
return new TopicExchange(applicationManualTopicExchange,true,false);
}
@Bean
public Binding applicationManualBinding(){
return BindingBuilder.bind(applicationManualTopicQueue()).to(applicationManualTopicExchange()).with(applicationManualRoutingKey);
}
/**
* 手动确认消费消息配置
* @param manualQueue
* @return
*/
@Bean
public SimpleMessageListenerContainer simpleContainerManual(@Qualifier("applicationManualTopicQueue") Queue manualQueue){
SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
container.setConnectionFactory(connectionFactory);
container.setMessagePropertiesConverter(new DefaultMessagePropertiesConverter());
//TODO：并发配置，若有多个实例消费者需加锁
container.setConcurrentConsumers(1);
container.setMaxConcurrentConsumers(1);
container.setPrefetchCount(1);
container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
container.setQueues(manualQueue);
//设置消费者
container.setMessageListener(applicationKnowledgeManualConsumer);
return container;
}
}
2.手动确认消费者类ApplicationKnowledgeManualConsumer
import com.fasterxml.jackson.databind.ObjectMapper;
import com.rabbitmq.client.Channel;
import com.***.***.***.WeChatApplicationTextMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 描述 : 消费者-手动确认
*
* @AUTHOR
* @DATE 2022/3/3 11:25
* @DESCRIPTION:
*/
@Component
public class ApplicationKnowledgeManualConsumer implements ChannelAwareMessageListener {
private static final Logger logger= LoggerFactory.getLogger(ApplicationKnowledgeManualConsumer.class);
@Resource
private ObjectMapper objectMapper;
@Override
public void onMessage(Message message, Channel channel) throws Exception {
MessageProperties messageProperties = message.getMessageProperties();
long deliveryTag = messageProperties.getDeliveryTag();
try {
byte[] messageBody = message.getBody();
WeChatApplicationTextMessage value = objectMapper.readValue(messageBody, WeChatApplicationTextMessage.class);
logger.info("确认消费模式-人为手动确认消费-监听器监听消费消息-内容为：{} ",value);
//第一个参数为：消息的分发标识(唯一);第二个参数：是否允许批量确认消费(在这里设置为true)
channel.basicAck(deliveryTag,true);
} catch (Exception e) {
logger.error("确认消费模式-人为手动确认消费-监听器监听消费消息-发生异常：",e.fillInStackTrace());
//如果在处理消息的过程中发生了异常,则照样需要人为手动确认消费掉该消息 (否则该消息将一直留在队列中,从而将导致消息的重复消费)
channel.basicReject(deliveryTag,false);
}
}
}
2.自动确认消费者类BasicConsumer
import com.***.***.***.Message;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;
/**
* 描述 : 对应的交换机、队列、路由需在config类中创建
*
* @AUTHOR
* @DATE 2022/3/2 15:53
* @DESCRIPTION:
*/
@Component
public class BasicConsumer {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
@RabbitListener(queues = "str.queue.name",containerFactory = "simpleListenerContainerFactory")
public void consumeMsg(@Payload Message msg){
try {
logger.info("基本消息模型-消费者-监听消费到消息：{} ",msg);
} catch (Exception e) {
logger.info("基本消息模型-消费者-监听消费发生异常 ",e.fillInStackTrace());
}
}
}
生产者中的springBoot的测试类可参考
/**
* 描述 :
*
* @AUTHOR
* @DATE 2022/3/2 15:41
* @DESCRIPTION:
*/
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ExamApplication.class)
public class RabbitMqTest {
@Autowired
private BasicPublisherManager publisherManager;
@Test
public void test02(){
Message message = new Message();
message.setMessageId("1");
message.setContent("这是一条消息");
publisherManager.sendObjectMsg(message);
}
}
三、消息丢失问题
生产者数据丢失
生产者向MQ发送消息的时候，可能由于网络原因殴导致消息丢失
解决方案：在生产者设置开启confirm模式(异步)后会为每一次写的消息分配一个唯一的ID，如果消息写入MQ中，MQ会给你回传一个ack消息，代表成功。相反，如果MQ没处理这个消息，会回调一个nack接口告诉你这个消息接收失败。当超过一段时间没有接收到ack消息我们可以选择重发。
MQ数据丢失
消息到MQ后，未被消费者消费，MQ挂了
解决方案：开启MQ的持久化(1.创建queue 的时候将其设置为持久化。2.在发送消息的时候将消息设置为持久化)，将消息持久化到磁盘，即使MQ挂了，恢复后会从磁盘中恢复queue，恢复这个queue里面的数据。
注意：消息到MQ后未来得及持久化到磁盘中MQ挂了也会导致数据丢失，这时候我们可以跟生产者的confirm机制结合，关闭自动ack，在数据持久化到磁盘后手动给生产者一个ack消息。
消费者数据丢失
消费者刚拿到数据还没来得及处理，消费者挂了。
解决方案：利用ack机制，在自己的代码中数据处理完之后手动ack。
注意：如果是多个消费者消费同一个消息，可能出现重复消费的问题。这时候可以结合redis，将消息id存入redis中，在redis中标识该消息是未消费还是消费中，或者消费完成。消费者消费消息前先根据消息ID去redis中查找。