我正在开发一个应用程序,它接收按会话ID分组的休息消息(会话1可以由2条消息组成,会话2可以由10条消息组成)并将它们发送到数据库。给定会话的消息内部具有相同的会话ID。
对于给定的会话,第一条消息应该先发送到数据库,然后发送到第二条等。顺序在会话中非常重要。
会话顺序并不重要,我们可以混合他们的消息,例如我们可以按此顺序将消息发送到数据库:
我创建了10个rabbitmq队列。应用程序选择有关会话ID的队列:来自给定会话的所有消息都在同一队列中。
每个队列有1个消费者,因此保证了同一队列中的顺序。
出于性能原因(以及流量增长),我们必须设置更高的队列数(由节点创建的100个队列)或部署应用程序的其他实例(每个队列上有1个使用者的10个节点 - 所以10个消费者每个队列。)
设置更高的队列数并不困难,但我的方式有点难看并且有代码重复(见下文)。我需要建议让它变得更好(当天我们需要1000个队列)。
如果我们部署10个节点而不是1个节点,则每个队列将有10个消费者,并且队列中的消息顺序将无法保证(因此会话A中的消息2可以在会话A的消息2之前发送到数据库)。
首选解决方案是10个节点,因为我们可以将其设置为动态,我们可以在需要时启动/停止docker中的节点。
以下是我使用的依赖项:
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-amqp</artifactId>
<version>1.6.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>1.6.3.RELEASE</version>
</dependency>
这是兔子配置:
@Bean
public SimpleRabbitListenerContainerFactory myRabbitListenerContainerFactory() {
SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
factory.setConnectionFactory(connectionFactory());
factory.setPrefetchCount(50);
factory.setAcknowledgeMode(AcknowledgeMode.AUTO);
return factory;
}
@Bean
public ConnectionFactory connectionFactory() {
String addresses = "address1,address2";
com.rabbitmq.client.ConnectionFactory rabbitConnection = new com.rabbitmq.client.ConnectionFactory();
rabbitConnection.setAutomaticRecoveryEnabled(true);
rabbitConnection.setUsername("username");
rabbitConnection.setPassword("password");
rabbitConnection.setVirtualHost("virtualHost");
CachingConnectionFactory connectionFactory = new CachingConnectionFactory(rabbitConnection);
connectionFactory.setPublisherConfirms(true);
connectionFactory.setAddresses(addresses);
connectionFactory.setChannelCacheSize(100);
return connectionFactory;
}
目前,我有10个队列,我创建了10个队列。这是一个队列示例:
@Component
@RabbitListener(containerFactory = "myRabbitListenerContainerFactory", bindings = @QueueBinding(value = @Queue(value = "queue2", durable = "true"), exchange = @Exchange(type = "topic", value = "exchange2", durable = "true"), key = "key2"))
public class QueueGroup2Listener {
@RabbitHandler
public void processOrder(RequestMessage received) throws DataAccessResourceFailureException {
process(received);
}
}
我没有找到比使用注释中的不同值(从1到10)创建10次此类更好的方法。
问题是: 如何在队列中添加使用者并保证给定会话中的消息顺序?我的意思是队列中有10个消费者。消费者A使用会话A中的消息1,因此其他消费者不应使用会话A中的其他消息。
奖金问题是: 如何使队列创建优于每个队列1个类?
非常感谢
更新
这个问题的答案可以帮助我很多 RabbitMQ : Create Dynamic queues in Direct Exchange:我可以为每个会话创建一个队列(在这种情况下,下一个问题是rabbitmq可以同时管理多少个队列?)
加里回答后更新
感谢您的回复,我尝试了以下内容,但启动消费者的应用程序非常长:
@Bean
public QueueMessageListener listener() {
return new QueueMessageListener();
}
@Bean(name="exchange")
public Exchange exchange() {
TopicExchange exchange = new TopicExchange(EXCHANGE, true, false);
SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
MessageListenerAdapter adapter = new MessageListenerAdapter(listener(), "processOrder");
container.setMessageListener(adapter);
admin().declareExchange(exchange);
createQueues(exchange, QUEUE, numberOfQueues, BINDING_KEY, container, null, true);
container.start(); // very very very long
return exchange;
}
private void createQueues(Exchange exchange, String queuePrefix, int numberOfQueues, String bindingPrefix,
SimpleMessageListenerContainer container, Map<String, Object> args) {
int length = 1;
if(numberOfQueues > 1) {
length = (int)(Math.log10(numberOfQueues - 1) + 1);
}
for (int i = 0; i < numberOfQueues; i++) {
Queue queue = new Queue(queuePrefix + String.format("%0" + length + "d", i), true, false, false, args);
container.addQueues(queue);
admin().declareQueue(queue);
Binding binding = BindingBuilder.bind(queue).to(exchange).with(bindingPrefix + i).noargs();
admin().declareBinding(binding);
}
}
如果我没有调用启动功能,则不会创建消费者。
答案 0 :(得分:2)
您可以通过编程方式启动SimpleMessageListenerContainer
,而不是使用声明性范例。
您还可以使用RabbitAdmin
以编程方式声明队列,绑定等。
由于Spring AMQP缓存通道,因此无法保证在同一通道上会发生两次发送(这会导致订单丢失的可能性非常小);为确保订单,您需要在即将发布的2.0版本中使用新的RabbitTemplate.invoke()
方法。它将在同一个通道上执行调用范围内的发送,以保证顺序。
如果您的发送代码是单线程的,这不是问题,因为在这种情况下将始终使用相同的通道。