En un artículo para comprender el uso del productor de RocketMQ, DefaultMQProducer, presentamos el uso del productor de RockerMQ en detalle. En este artículo, presentamos el uso del consumidor de RocketMQ. Hay dos implementaciones del consumidor de RocketMQ, DefaultMQPushConsumer y DefaultMQPullConsumer, que son respectivamente pull Modo y modo push. Entre ellos, el modo de extracción es para que los consumidores envíen solicitudes de forma activa y vayan al servidor de mensajes para extraer mensajes a intervalos regulares. El modo de envío utiliza un mecanismo de sondeo largo. El modo de sondeo del consumidor envía solicitudes de forma activa al agente del servidor. Si el agente detecta que hay Los mensajes nuevos se devolverán de inmediato, de lo contrario no se devolverán mensajes temporalmente y la solicitud se almacenará en caché localmente. El Broker tiene un hilo para detectar la solicitud pendiente, y cuando hay un nuevo mensaje, responderá a la solicitud. En este artículo, presentamos principalmente el uso de DefaultMQPushConsumer.
En comparación con las API de envío de mensajes múltiples proporcionadas por el productor de DefaultMQProducer, el método de consumo de mensajes proporcionado por DefaultMQPushConsumer es relativamente simple: proporciona el método registerMessageListener para registrar un oyente para el consumo de mensajes. Los siguientes métodos son proporcionados por DefaultMQPushConsumer:
//注册一个回调，在有消息存在时执行并发消费。
public void registerMessageListener(MessageListenerOrderly messageListener) {}
//注册一个回调，以便在消息到达时执行顺序消费。
public void registerMessageListener(MessageListenerConcurrently messageListener) {}DefaultMQPushConsumer utiliza principalmente los dos métodos anteriores para enviar mensajes de los productores de mensajes. El siguiente es un ejemplo de DefaultMQPushConsumer. Su enfoque está principalmente en la configuración de DefaultMQPushConsumer. Diferentes configuraciones pueden tener diferentes efectos. Primero veamos un ejemplo y lo presentamos. La configuración principal, el código es el siguiente:
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();
}
}
El código anterior es un ejemplo de un consumidor RocketMQ simple, la creación de una instancia del consumidor y la configuración del servidor de nombres no se explicará aquí, la siguiente es la configuración principal del consumidor 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) {}Anteriormente presentamos la configuración principal de los consumidores. A continuación, seleccionamos la configuración importante para una explicación detallada. Primero presentamos la configuración de la estrategia de equilibrio de carga AllocateMessageQueueStrategy. Su interfaz raíz es AllocateMessageQueueStrategy. A continuación presentamos su implementación, como se muestra en el siguiente diagrama de clases:
- AllocateMessageQueueAveragely distribuye igualmente, que también es la estrategia predeterminada
- AllocateMessageQueueAveragelyByCircle estrategia de asignación de anillo
- Configuración manual de AllocateMessageQueueByConfig
- AllocateMessageQueueConsistentHash Asignación de hash coherente
- AllocateMessageQueueByMachineRoom Estrategia de asignación de salas de máquinas
Después de presentar la estrategia de distribución, veamos la configuración setMessageModel, que se utiliza para configurar el modelo de mensaje y admite el consumo de clúster y el consumo de difusión. El valor predeterminado es el consumo de clúster. La definición de MessageModel es la siguiente:
public enum MessageModel {
/**
* 广播，消费组中的每个消费者都可以消费所有消息
*/
BROADCASTING("BROADCASTING"),
/**
* 集群，消费组中的每个消费者都可以消费消息中的一部分消息
*/
CLUSTERING("CLUSTERING");
......
}
setConsumeFromWhere se usa para configurar dónde comenzar el consumo de forma predeterminada. El valor predeterminado es CONSUME_FROM_LAST_OFFSET. La siguiente es la definición 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,
}No se mostrarán más ejemplos de consumidores aquí. De hecho, el funcionario también ha escrito muchos ejemplos de uso de RocketMQ. Si está interesado, puede encontrar los ejemplos oficiales de github. Más adelante presentaremos la alta disponibilidad de RocketMQ.