table of Contents
Explanation
As of this SpringBoot with RabbitMQ integration, including the confirmation mode of three kinds of messages, if the query detailed confirmation mode settings, please read: RabbitMQ three message acknowledgment mode
while the consumer side has also taken measures to limit the flow, if limited interested flow details, please refer to the article before reading: the consumer side current limit
Production end
First introduced maven dependent
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
<version>2.1.4.RELEASE</version>
</dependency>Application.properties the setting, turn confirm confirmation mechanism, open return confirmation mode, set the mandatoryproperty to true, when set to true, routing the message queue can not not be automatically deleted, so that it can be return to listen to the message mode .
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtual-host=/
spring.rabbitmq.connection-timeout=15000
#开启 confirm 确认机制
spring.rabbitmq.publisher-confirms=true
#开启 return 确认机制
spring.rabbitmq.publisher-returns=true
#设置为 true 后 消费者在消息没有被路由到合适队列情况下会被return监听，而不会自动删除
spring.rabbitmq.template.mandatory=true
Creating queues and switches here should not create ConnectionFactory and RabbitAdmin, should be set in application.properties username, the password, host, port, virtual host can be.
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MQConfig {
// @Bean
// public ConnectionFactory connectionFactory(){
// return new CachingConnectionFactory();
// }
//
// @Bean
// public RabbitAdmin rabbitAdmin(){
// return new RabbitAdmin(connectionFactory());
// }
@Bean
public Exchange bootExchange(){
return new TopicExchange("BOOT-EXCHANGE-1", true, false);
}
@Bean
public Queue bootQueue(){
return new Queue("boot.queue1", true);
}
}If the program has a special setup requirements, the pursuit of a more flexible way of setting can refer to the following encoding settings, so do not specify application.properties. For example, we configured in the test and production environments in virtual hosts, different password, we can determine in which environment in the program, the flexibility to switch settings.
@Bean
public ConnectionFactory connectionFactory(){
CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
if("生产环境"){
connectionFactory.set.....
} else {
......
}
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
return connectionFactory;
}
@Bean
public RabbitAdmin rabbitAdmin(){
RabbitAdmin rabbitAdmin = new RabbitAdmin();
rabbitAdmin.setAutoStartup(true);
return new RabbitAdmin(connectionFactory());
}MQSender following code, and sending a message comprising adding confirm listener, add a return listener. If the consumer end of the ACK to be set to manual, then the end of the production time must send a message sent correlationData, and globally unique for uniquely identifies the message.
import com.anqi.mq.bean.User;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
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.Component;
import java.util.Date;
import java.util.Map;
@Component
public class MQSender {
@Autowired
private RabbitTemplate rabbitTemplate;
final RabbitTemplate.ConfirmCallback confirmCallback= new RabbitTemplate.ConfirmCallback() {
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
System.out.println("correlationData: " + correlationData);
System.out.println("ack: " + ack);
if(!ack){
System.out.println("异常处理....");
}
}
};
final RabbitTemplate.ReturnCallback returnCallback = new RabbitTemplate.ReturnCallback() {
public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
System.out.println("return exchange: " + exchange + ", routingKey: "
+ routingKey + ", replyCode: " + replyCode + ", replyText: " + replyText);
}
};
//发送消息方法调用: 构建Message消息
public void send(Object message, Map<String, Object> properties) throws Exception {
MessageProperties mp = new MessageProperties();
//在生产环境中这里不用Message，而是使用 fastJson 等工具将对象转换为 json 格式发送
Message msg = new Message(message.toString().getBytes(),mp);
rabbitTemplate.setMandatory(true);
rabbitTemplate.setConfirmCallback(confirmCallback);
rabbitTemplate.setReturnCallback(returnCallback);
//id + 时间戳 全局唯一
CorrelationData correlationData = new CorrelationData("1234567890"+new Date());
rabbitTemplate.convertAndSend("BOOT-EXCHANGE-1", "boot.save", msg, correlationData);
}
//发送消息方法调用: 构建Message消息
public void sendUser(User user) throws Exception {
rabbitTemplate.setMandatory(true);
rabbitTemplate.setConfirmCallback(confirmCallback);
rabbitTemplate.setReturnCallback(returnCallback);
//id + 时间戳 全局唯一
CorrelationData correlationData = new CorrelationData("1234567890"+new Date());
rabbitTemplate.convertAndSend("BOOT-EXCHANGE-1", "boot.save", user, correlationData);
}
}
Consumer end
In the actual production environment, the production side and the consumer side are generally two systems, we are here also split into two projects.
The following is application.properties consumer side configuration, the first configuration mode is manual acknowledgment, ACK for manual processing, we can guarantee the reliability of message delivery, or failure of the consumer when the consumer side back to the queue can be done, The service processing such as logging. We can also set the maximum number of the number of listeners and the consumer side, for controlling concurrency consumer side. We want to open the current limit, each designated processing messages can only handle two messages.
spring.rabbitmq.host=localhost
spring.rabbitmq.virtual-host=/
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
#设置消费端手动 ack
spring.rabbitmq.listener.simple.acknowledge-mode=manual
#消费者最小数量
spring.rabbitmq.listener.simple.concurrency=1
#消费之最大数量
spring.rabbitmq.listener.simple.max-concurrency=10
#在单个请求中处理的消息个数，他应该大于等于事务数量(unack的最大数量)
spring.rabbitmq.listener.simple.prefetch=2
We can use @RabbitListenerand @RabblitHandlercombination listen queue, of course, @RabbitListenercan also be added to the method. We are here to create two methods used to monitor the same queue, which specific method calls are determined by the method of parameter matching, custom types of messages need to mark the @Payloadclass to implement the serialization interface.
package com.anqi.mq.receiver;
import com.anqi.mq.bean.User;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.Map;
@RabbitListener(
bindings = @QueueBinding(
value = @Queue(value = "boot.queue1", durable = "true"),
exchange = @Exchange(value = "BOOT-EXCHANGE-1", type = "topic", durable = "true", ignoreDeclarationExceptions = "true"),
key = "boot.*"
)
)
@Component
public class MQReceiver {
@RabbitHandler
public void onMessage(Message message, Channel channel) throws IOException {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
long deliveryTag = message.getMessageProperties().getDeliveryTag();
//手工ack
channel.basicAck(deliveryTag,true);
System.out.println("receive--1: " + new String(message.getBody()));
}
@RabbitHandler
public void onUserMessage(@Payload User user, Channel channel, @Headers Map<String,Object> headers) throws IOException {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
long deliveryTag = (Long)headers.get(AmqpHeaders.DELIVERY_TAG);
//手工ack
channel.basicAck(deliveryTag,true);
System.out.println("receive--11: " + user.toString());
}
}
Serialization and deserialization of messages is done internally by the converter, if we want to use other types of messages converter, we can set it SimpleMessageListenerContainer.
@Bean
public SimpleMessageListenerContainer simpleMessageListenerContainer(){
SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
container.setMessageConverter(new Jackson2JsonMessageConverter());
// 默认采用下面的这种转换器
// container.setMessageConverter(new SimpleMessageConverter());
return container;
}Unit test classes
import com.anqi.mq.bean.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@SpringBootTest
@RunWith(SpringRunner.class)
public class MQSenderTest {
@Autowired
private MQSender mqSender;
@Test
public void send() {
String msg = "hello spring boot";
try {
for (int i = 0; i < 15; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//mqSender.send(msg + ":" + i, null);
mqSender.sendUser(new User("anqi", 25));
}
} catch (Exception e) {
e.printStackTrace();
}
}
}The test results below, we use the method in the consumer Thread.sleep(5000)process to simulate the message, deliberately extended the processing time of the message, in order to better observe the limiting effect. We can find Unackedhas been the number of messages 2, being processed on behalf of 2, which is consistent with our limiting the number indicates the purpose of limiting has been achieved.
