1 问题引入
在实际环境下，每个消息的“大小”是不同的，所需要的处理时间也是不同的。在这种情况下，我们应该如何分配资源来令效率最大化呢？这就需要我们来学习 RabbitMQ 的消息分发机制了。
2 回顾分发机制
以下分发机制的内容来自我的前几篇博客，这里借用一下。
一般来说，一个队列有多个消费者同时消费数据，此时有两种分发数据的方式，一种是轮询分发，另一种是公平分发。
2.1 轮询分发
轮询分发，Round-robin dispatching，也是 RabbitMQ 的默认消息分发机制。队列会给每一个消费者发送的数据数量是一模一样的，并不会因为两个消费者处理数据速度不同而发生改变。这样很容易导致部分消费者天天加班，而部分消费者无所事事的情况。
轮询分发是 RabbitMQ 默认的消息分发机制。
2.2 公平分发
公平分发，Fair dispatch，消费者设置每次从队列里只取一条数据，并且关闭自动回复机制，每次取完一条数据后，手动回复并继续取下一条数据。这样每个消费者都只有消费完一条消息才会收到下一条消息，十分的“公平”。（每个消费者在同一时间点最多处理的消息个数由 prefetchCount 参数规定，而不是固定为1个）
需要注意的是，如果我们使用公平分发，那么必须关闭自动应答，同时改为手动应答。
3 测试
在 Spring Boot 环境下，RabbitMQ 默认使用何种分发机制呢？下面我们做一个小小的测试。
3.1 测试1
3.1.1 生产者设置
设置生产者配置类
package com.example.provider.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.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* 直连型交换机
* @author 30309
*
*/
@Configuration
public class DirectRabbitConfig {
//队列,名称为DirectQueue
@Bean
public Queue DirectQueue() {
return new Queue("DirectQueue",true); //true表示是否持久
}
//直连型交换机,名称为DirectExchange
@Bean
DirectExchange DirectExchange() {
return new DirectExchange("DirectExchange");
}
//将队列和交换机绑定, 并设置用于匹配键：DirectRouting
@Bean
Binding bindingDirect() {
return BindingBuilder.bind(DirectQueue()).to(DirectExchange()).with("DirectRouting");
}
@Bean
public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
// 消息发送失败返回到队列中, 配置文件需要配置 publisher-returns: true
rabbitTemplate.setMandatory(true);
return rabbitTemplate;
}
}设置生产者控制器
package com.example.provider.controller;
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;
/**
* 生产者
* @author 30309
*
*/
@RestController
public class SendMessageController{
@Autowired
RabbitTemplate rabbitTemplate;
@GetMapping("/sendDirectMessage")
public String sendDirectMessage() {
for(int i = 0;i < 10;i++) {
rabbitTemplate.convertAndSend("DirectExchange", "DirectRouting", (long)1000);
}
return "ok";
}
}生产者配置
server.port: 8080
spring.application.name: provider
spring.rabbitmq.host: 127.0.0.1
spring.rabbitmq.port: 5672
spring.rabbitmq.username: guest
spring.rabbitmq.password: guest
spring.rabbitmq.virtual-host: /
# 开启 confirm 确认机制
spring.rabbitmq.publisher-confirms: true
# 开启 return 确认机制
spring.rabbitmq.publisher-returns: true
# 手动应答
spring.rabbitmq.listener.simple.acknowledge-mode: manual
# 指定最小的消费者数量
spring.rabbitmq.listener.simple.concurrency: 1
# 指定最大的消费者数量
spring.rabbitmq.listener.simple.max-concurrency: 2
# 是否支持重试
spring.rabbitmq.listener.simple.retry.enabled: true3.1.2 消费者设置
设置消费者配置类
package com.example.consumer.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.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* 直连型交换机
* @author 30309
*
*/
@Configuration
public class DirectRabbitConfig {
//队列,名称为DirectQueue
@Bean
public Queue DirectQueue() {
return new Queue("DirectQueue",true); //true表示是否持久
}
//直连型交换机,名称为DirectExchange
@Bean
DirectExchange DirectExchange() {
return new DirectExchange("DirectExchange");
}
//将队列和交换机绑定, 并设置用于匹配键：DirectRouting
@Bean
Binding bindingDirect() {
return BindingBuilder.bind(DirectQueue()).to(DirectExchange()).with("DirectRouting");
}
@Bean
public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
// 消息发送失败返回到队列中, 配置文件需要配置 publisher-returns: true
rabbitTemplate.setMandatory(true);
return rabbitTemplate;
}
}消费者1
package com.example.consumer.receiver;
import java.io.IOException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import com.rabbitmq.client.Channel;
/**
* 消费者1
* @author 30309
*
*/
@Component
public class DirectReceiver1 {
@RabbitListener(queues = "DirectQueue")//监听的队列名称为DirectQueue
@RabbitHandler
public void process(long i,Channel channel, Message message) {
System.out.println("DirectReceiver1消费者收到消息:需要延时" + i);
work(i);
try {
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
} catch (IOException e) {
e.printStackTrace();
}
}
//延时,模拟消息的处理
private void work(long timeout) {
try {
Thread.sleep(timeout);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}消费者2
package com.example.consumer.receiver;
import java.io.IOException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import com.rabbitmq.client.Channel;
/**
* 消费者2
* @author 30309
*
*/
@Component
public class DirectReceiver2 {
@RabbitListener(queues = "DirectQueue")//监听的队列名称为DirectQueue
@RabbitHandler
public void process(long i,Channel channel, Message message) {
System.out.println("DirectReceiver2消费者收到消息:需要延时" + i);
work(i);
try {
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
} catch (IOException e) {
e.printStackTrace();
}
}
//延时,模拟消息的处理
private void work(long timeout) {
try {
Thread.sleep(timeout);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}消费者配置
server.port: 8079
spring.application.name: consumer
spring.rabbitmq.host: 127.0.0.1
spring.rabbitmq.port: 5672
spring.rabbitmq.username: guest
spring.rabbitmq.password: guest
spring.rabbitmq.virtual-host: /
# 开启 confirm 确认机制
spring.rabbitmq.publisher-confirms: true
# 开启 return 确认机制
spring.rabbitmq.publisher-returns: true
# 手动应答
spring.rabbitmq.listener.simple.acknowledge-mode: manual
# 指定最小的消费者数量
spring.rabbitmq.listener.simple.concurrency: 1
# 指定最大的消费者数量
spring.rabbitmq.listener.simple.max-concurrency: 2
# 是否支持重试
spring.rabbitmq.listener.simple.retry.enabled: true3.1.3 测试结果
结果如下
我们可以发现，消费者1与消费者2各自处理了5条消息。在两个消费者处理能力几乎一样的情况下，两个消费者处理消息几乎是同步的。这样其实我们并不能看出点什么，下面我们修改一下代码，让两个消费者的处理能力变为不同，看看会发生些什么。
3.2 测试2
3.2.1 修改生产者
package com.example.provider.controller;
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;
/**
* 生产者
* @author 30309
*
*/
@RestController
public class SendMessageController{
@Autowired
RabbitTemplate rabbitTemplate;
@GetMapping("/sendDirectMessage")
public String sendDirectMessage() {
rabbitTemplate.convertAndSend("DirectExchange", "DirectRouting", (long)5000);
for(int i = 0;i < 5;i++) {
rabbitTemplate.convertAndSend("DirectExchange", "DirectRouting", (long)1000);
}
return "ok";
}
}这次我们生产了6条消息，其中一条消息的处理时间为5秒，另外五条消息的处理时间为1秒。结果如下：
我们可以看到，每个消费者各自处理了三条消息，可发现在默认情况下是按轮询分发的模式来分发消息的。
4 公平分发模式的使用
修改一下配置文件，增加一行配置
# 指定一个请求能处理多少消息
spring.rabbitmq.listener.simple.prefetch: 1再次运行，结果如下
我们发现，修改配置以后，我们仍然生产了6条消息，其中一条消息的处理时间为5秒，另外五条消息的处理时间为1秒。与上次不同的是，消费者1只处理了一条消息，消费者2处理了5条消息，可见现在已使用公平分发的模式来分发消息。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
