Dans un article pour comprendre l'utilisation du producteur RocketMQ DefaultMQProducer, nous présentons en détail l'utilisation du producteur RockerMQ. Dans cet article, nous présentons l'utilisation du consommateur RocketMQ. Il existe deux implémentations de RocketMQ consumer, DefaultMQPushConsumer et DefaultMQPullConsumer, qui sont respectivement pull Mode et mode push. Parmi eux, le mode d'extraction permet aux consommateurs d'envoyer activement des demandes et d'aller au serveur de messages pour extraire des messages à intervalles réguliers. Le mode d'envoi utilise un long mécanisme d'interrogation. Le mode d'interrogation des consommateurs envoie activement des demandes au courtier du serveur. Si le courtier détecte qu'il y a Les nouveaux messages seront renvoyés immédiatement, sinon aucun message ne sera renvoyé temporairement et la demande sera mise en cache localement. Le courtier dispose d'un thread pour détecter la demande en attente, et lorsqu'il y a un nouveau message, il répondra à la demande. Dans cet article, nous présentons principalement l'utilisation de DefaultMQPushConsumer.
Par rapport aux API d'envoi de messages multiples fournies par le producteur DefaultMQProducer, la méthode de consommation de messages fournie par DefaultMQPushConsumer est relativement simple. Elle fournit la méthode registerMessageListener pour enregistrer un écouteur pour la consommation de messages. Les méthodes suivantes sont fournies par DefaultMQPushConsumer:
//注册一个回调，在有消息存在时执行并发消费。
public void registerMessageListener(MessageListenerOrderly messageListener) {}
//注册一个回调，以便在消息到达时执行顺序消费。
public void registerMessageListener(MessageListenerConcurrently messageListener) {}DefaultMQPushConsumer utilise principalement les deux méthodes ci-dessus pour envoyer des messages à partir de producteurs de messages. Voici un exemple de DefaultMQPushConsumer. Il se concentre principalement sur la configuration de DefaultMQPushConsumer. Différentes configurations peuvent avoir des effets différents. Examinons d'abord un exemple et présentons-le. La configuration de base, le code est le suivant:
public class Consumer {
public static void main(String[] args) throws InterruptedException, MQClientException {
//实例化消费者，传入消费者组，表示消费同一类消息
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("OnewayProducer");
//设置nameserver地址
consumer.setNamesrvAddr("127.0.0.1:9876");
//设置订阅的主图
consumer.subscribe("BenchmarkTest", "*");
//设置如何从何处开始消费
consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
//注册消息监听器，用于消费生产者生产的消息
consumer.registerMessageListener(new MessageListenerConcurrently() {
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
System.out.printf("%s Receive New Messages: %s %n", Thread.currentThread().getName(), msgs);
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
//启动消费者
consumer.start();
}
}
Le code ci-dessus est un exemple d'un simple consommateur RocketMQ, instanciant le consommateur et définissant le nameServer ne sera pas expliqué ici, ce qui suit est la configuration de base du consommateur RocketMQ:
//订阅主题为topic的消息，并且可以通过subExpression过滤消息
public void subscribe(String topic, String subExpression){}
//订阅主题为topic的消息，可以订阅某Class实例的消息
public void subscribe(String topic, String fullClassName, String filterClassSource){}
//订阅主题为topic的消息，使用MessageSelector过滤消息
public void subscribe(final String topic, final MessageSelector messageSelector){}
//取消订阅主题为topic的消息
public void unsubscribe(String topic){}
//消息模型，支持集群消费和广播消费，默认为集群消费
public void setMessageModel(MessageModel messageModel){}
//Consumer 启动后，默认从什么位置开始消费,默认为CONSUME_FROM_LAST_OFFSET
public void setConsumeFromWhere(ConsumeFromWhere consumeFromWhere) {}
//集群模式下消息队列Rebalance 算法实现策略
public void setAllocateMessageQueueStrategy(AllocateMessageQueueStrategy allocateMessageQueueStrategy){}
//消费进度存储
public void setOffsetStore(OffsetStore offsetStore){}
//消费线程池数量的最大值
public void setConsumeThreadMax(int consumeThreadMax) {}
//消费线程池数量的最小值
public void setConsumeThreadMin(int consumeThreadMin){}
//单队列并行消费允许的最大跨度
public void setConsumeConcurrentlyMaxSpan(int consumeConcurrentlyMaxSpan){}
//默认值为1000，每1000次流控后打印流控日志
public void setPullThresholdForQueue(int pullThresholdForQueue) {}
//推模式下拉取任务间隔时间，默认一次拉取任务完成继续拉取
public void setPullInterval(long pullInterval) {}
//每次消息拉取拉取的消磁条数，默认为32条
public void setPullBatchSize(int pullBatchSize) {}
//消息并发消费时一次消费的消息条数
public void setConsumeMessageBatchMaxSize(int consumeMessageBatchMaxSize) {}
//是否每次拉取消息都更新订阅信息，默认为false
public void setPostSubscriptionWhenPull(boolean postSubscriptionWhenPull) {}
//最大消费重试次数
public void setMaxReconsumeTimes(final int maxReconsumeTimes){}
//延迟将队列的消息提交到消费线程的等待时长，默认为延迟1秒
public void setSuspendCurrentQueueTimeMillis(final long suspendCurrentQueueTimeMillis) {}
//信息消费超时时间，默认为15秒
public void setConsumeTimeout(final long consumeTimeout) {}Ci-dessus, nous avons présenté la configuration de base des consommateurs. Ci-dessous, nous sélectionnons les configurations importantes pour une explication détaillée. Commençons par présenter la configuration de la stratégie d'équilibrage de charge AllocateMessageQueueStrategy. Son interface racine est AllocateMessageQueueStrategy. Nous présentons ci-dessous son implémentation, comme illustré dans le diagramme de classes suivant:
- AllocateMessageQueueAveragely distribue équitablement, ce qui est également la stratégie par défaut
- AllocateMessageQueueAveragelyByCircle stratégie d'allocation d'anneau
- Configuration manuelle AllocateMessageQueueByConfig
- AllocateMessageQueueConsistentHash Allocation de hachage cohérente
- AllocateMessageQueueByMachineRoom stratégie d'allocation de la salle des machines
Après avoir présenté la stratégie de distribution, examinons la configuration setMessageModel, qui est utilisée pour configurer le modèle de message et prend en charge la consommation de cluster et la consommation de diffusion. La valeur par défaut est la consommation de cluster. La définition de MessageModel est la suivante:
public enum MessageModel {
/**
* 广播，消费组中的每个消费者都可以消费所有消息
*/
BROADCASTING("BROADCASTING"),
/**
* 集群，消费组中的每个消费者都可以消费消息中的一部分消息
*/
CLUSTERING("CLUSTERING");
......
}
setConsumeFromWhere est utilisé pour configurer où démarrer la consommation par défaut. La valeur par défaut est CONSUME_FROM_LAST_OFFSET. Voici la définition de ConsumeFromWhere:
public enum ConsumeFromWhere {
//从上次消费的位点开始消费，相当于断电继续
CONSUME_FROM_LAST_OFFSET,
//从ConsumeQueue最小位点开始消费
CONSUME_FROM_FIRST_OFFSET,
//从指定的时间开始消费
CONSUME_FROM_TIMESTAMP,
@Deprecated
CONSUME_FROM_LAST_OFFSET_AND_FROM_MIN_WHEN_BOOT_FIRST,
@Deprecated
CONSUME_FROM_MIN_OFFSET,
@Deprecated
CONSUME_FROM_MAX_OFFSET,
}D'autres exemples de consommateurs ne seront pas affichés ici. En fait, le responsable a également écrit de nombreux exemples d'utilisation de RocketMQ. Si vous êtes intéressé, vous pouvez trouver les exemples officiels de github. Nous présenterons la haute disponibilité de RocketMQ plus tard.