RocketMQ消费模式

最新推荐文章于 2024-09-18 16:02:30 发布
最新推荐文章于 2024-09-18 16:02:30 发布
阅读量1.6k 收藏 4
点赞数 1
文章标签： 人工智能 json
原文链接：https://my.oschina.net/mingxungu/blog/3083951
版权

RocketMQ提供两种消费策略CLUSTERING集群消费(默认)和BROADCASTING广播消费，在创建Consumer消费者时可以指定消费策略，策略不同其内部机制也不同，消息的消费方式、记录消费进度、消息的消费状态等也都各不相同。下面我们具体来探讨一下。

1、集群消费(默认)

集群模式：一个ConsumerGroup中的Consumer实例根据队列分配策略算法为Consumer分配队列，平均分摊（默认）消费消息。例如Topic是Test的消息发送到该主题的不同队列中，发送了有100条消息，其中一个ConsumerGroup有3个Consumer实例，那么根据队列分配算法，每个队列都会有消费者，每个消费者实例只消费自己队列上的数据，消费完的消息不能被其他消费实例消费。

一个消费队列会分配一个消费者，有且只有一个

一个消费者可能消费0到多个队列，例如：某个主题有4个消费队列，然而消费者有5个那么根据第一条原则，一个消费队列只能有一个消费者，就会有消费者没有分配到队列。

1.1、创建集群消费者

创建两个集群消费者Consumer1、Consumer2，下面写出了Consumer1的代码，Consumer2也是一样的不再重复了。

public class Consumer1 {	
	public static void main(String[] args){
		try {
			DefaultMQPushConsumer consumer = new DefaultMQPushConsumer();
			consumer.setConsumerGroup("consumer_test_clustering");
			consumer.setNamesrvAddr("10.10.12.203:9876;10.10.12.204:9876");
			consumer.subscribe("TopicTest", "*");
			consumer.registerMessageListener(new MessageListenerConcurrently(){

				@Override
				public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> paramList,
						ConsumeConcurrentlyContext paramConsumeConcurrentlyContext) {
					try {
					    for(MessageExt msg : paramList){
					    	String msgbody = new String(msg.getBody(), "utf-8");
					    	System.out.println("Consumer1===  MessageBody: "+ msgbody);//输出消息内容
					    }
					} catch (Exception e) {
					    e.printStackTrace();
					    return ConsumeConcurrentlyStatus.RECONSUME_LATER; //稍后再试
					}
					return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消费成功
				}
			});
			consumer.start();
			System.out.println("Consumer1===启动成功!");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

我们发现这里面并没有明显的说是集群消费，怎么能判断是集群消费呢，我们查看下源码分析下。

我们发现DefaultMQPushConsumer consumer = new DefaultMQPushConsumer()；创建消费者的时候已经默认了很多内置参数，其中就有消费模式CLUSTERING集群消费。

我们先启动Consumer1和Consumer2，发送10条消息看一下消费情况，RocketMQ消息是基于订阅发布模型的。

我们发现10条消息都消费了，没有重复的。集群消息每条消息都是集群内的消费者共同消费且不会重复消费。

可视化界面查看其客户端信息

查看其消息情况发了10条消息，我们查看其状态。

1.2、队列分配策略

1.2.1、平均分配策略(默认)(AllocateMessageQueueAveragely)

我们首先查看其原理图

分析其源码AllocateMessageQueueAveragely类的核心方法是allocate

public List<MessageQueue> allocate(String consumerGroup, String currentCID, List<MessageQueue> mqAll,
		List<String> cidAll) {
    //校验当前消费者id是否存在的校验
	if ((currentCID == null) || (currentCID.length() < 1)) {
		throw new IllegalArgumentException("currentCID is empty");
	}
    //校验消息队列是否存在
	if ((mqAll == null) || (mqAll.isEmpty())) {
		throw new IllegalArgumentException("mqAll is null or mqAll empty");
	}
    //校验所有的消费者id的集合是否为null
	if ((cidAll == null) || (cidAll.isEmpty())) {
		throw new IllegalArgumentException("cidAll is null or cidAll empty");
	}
	List result = new ArrayList();
    //校验当前的消费者id是否在消费者id的集群中
	if (!(cidAll.contains(currentCID))) {
		this.log.info("[BUG] ConsumerGroup: {} The consumerId: {} not in cidAll: {}",
				new Object[] { consumerGroup, currentCID, cidAll });

		return result;
	}
	//获取当前的消费者id在集合中的下标
	int index = cidAll.indexOf(currentCID);
    
	int mod = mqAll.size() % cidAll.size();
	int averageSize = ((mod > 0) && (index < mod)) ? mqAll.size() / cidAll.size() + 1
			: (mqAll.size() <= cidAll.size()) ? 1 : mqAll.size() / cidAll.size();
	int startIndex = ((mod > 0) && (index < mod)) ? index * averageSize : index * averageSize + mod;
	int range = Math.min(averageSize, mqAll.size() - startIndex);
	for (int i = 0; i < range; ++i) {
		result.add(mqAll.get((startIndex + i) % mqAll.size()));
	}
	return result;
}

分析其源码

  • 26行：消息队列总数和消费者总数取余

  • 27、28行：计算当前的消费者分配的消息队列数

    （1）取余大于0且当前消费者的下标小于取余数(mod > 0) && (index < mod) -》确定当前的消费者是否在取余里，在则在整除数中+1，mqAll.size() / cidAll.size() + 1

    （2）如果已经整除或者不在取余里则判断消息队列是否小于等于消费者总数mqAll.size() <= cidAll.size()，在则该消费者分配的消息队列为1

    （3）如果（2）中不成立则，mqAll.size() / cidAll.size()

  • 29、30行：计算当前消费者在消息队列数组中的开始的下标

    （1）取余大于0且当前消费者的下标小于取余数((mod > 0) && (index < mod)) -》当前下标乘以每个队列的平均队列数index * averageSize

    （2）如果（1）中不成立则index * averageSize + mod

  • 31行：根据Math.min()计算消费者最终需要消费的数量

  • 32行：获取当前的消费者的队列集合

1.2.2、环形分配策略(AllocateMessageQueueAveragelyByCircle)

我们首先查看其原理图

分析其源码AllocateMessageQueueAveragelyByCircle类的核心方法是allocate

public List<MessageQueue> allocate(String consumerGroup, String currentCID, List<MessageQueue> mqAll,
			List<String> cidAll) {
		if ((currentCID == null) || (currentCID.length() < 1)) {
			throw new IllegalArgumentException("currentCID is empty");
		}
		if ((mqAll == null) || (mqAll.isEmpty())) {
			throw new IllegalArgumentException("mqAll is null or mqAll empty");
		}
		if ((cidAll == null) || (cidAll.isEmpty())) {
			throw new IllegalArgumentException("cidAll is null or cidAll empty");
		}
		
		List result = new ArrayList();
		if (!(cidAll.contains(currentCID))) {
			this.log.info("[BUG] ConsumerGroup: {} The consumerId: {} not in cidAll: {}",
					new Object[] { consumerGroup, currentCID, cidAll });

			return result;
		}
        //上面一堆校验我们之间略过
		int index = cidAll.indexOf(currentCID);
		for (int i = index; i < mqAll.size(); ++i) {
			if (i % cidAll.size() == index) {
				result.add(mqAll.get(i));
			}
		}
		return result;
	}

分析其源码

  • 23、24、25行：遍历消息的下标, 对下标取模(mod), 如果与index相等, 则存储到result集合中

1.2.3、手动配置分配策略(AllocateMessageQueueByConfig)

分析其源码AllocateMessageQueueByConfig类

public class AllocateMessageQueueByConfig implements AllocateMessageQueueStrategy {
	private List<MessageQueue> messageQueueList;

	public List<MessageQueue> allocate(String consumerGroup, String currentCID, List<MessageQueue> mqAll,
			List<String> cidAll) {
		return this.messageQueueList;
	}

	public String getName() {
		return "CONFIG";
	}

	public List<MessageQueue> getMessageQueueList() {
		return this.messageQueueList;
	}

	public void setMessageQueueList(List<MessageQueue> messageQueueList) {
		this.messageQueueList = messageQueueList;
	}
}

通过配置来记性消息队列的分配

1.2.4、机房分配策略(AllocateMessageQueueByMachineRoom)

分析其源码AllocateMessageQueueByMachineRoom类的核心方法是allocate

	public List<MessageQueue> allocate(String consumerGroup, String currentCID, List<MessageQueue> mqAll,
			List<String> cidAll) {
		List result = new ArrayList();
		int currentIndex = cidAll.indexOf(currentCID);
		if (currentIndex < 0) {
			return result;
		}
		List premqAll = new ArrayList();
		for (MessageQueue mq : mqAll) {
			String[] temp = mq.getBrokerName().split("@");
			if ((temp.length == 2) && (this.consumeridcs.contains(temp[0]))) {
				premqAll.add(mq);
			}
		}

		int mod = premqAll.size() / cidAll.size();
		int rem = premqAll.size() % cidAll.size();
		int startIndex = mod * currentIndex;
		int endIndex = startIndex + mod;
		for (int i = startIndex; i < endIndex; ++i) {
			result.add(mqAll.get(i));
		}
		if (rem > currentIndex) {
			result.add(premqAll.get(currentIndex + mod * cidAll.size()));
		}
		return result;
	}

分析源码

  • 4-7行, 计算当前消费者在消费者集合中的下标(index), 如果下标 < 0 , 则直接返回

  • 8-14行, 根据brokerName解析出所有有效机房信息(其实是有效mq), 用Set集合去重, 结果存储在premqAll中

  • 16行, 计算消息整除的平均结果mod

  • 17行, 计算消息是否能够被平均消费rem,(即消息平均消费后还剩多少消息(remaing))

  • 18行, 计算当前消费者开始消费的下标(startIndex)

  • 19行, 计算当前消费者结束消费的下标(endIndex)

  • 20-26行, 将消息的消费分为两部分, 第一部分 – (cidAllSize * mod) , 第二部分 – (premqAll - cidAllSize * mod) ; 从第一部分中查询startIndex ~ endIndex之间所有的消息, 从第二部分中查询 currentIndex + mod * cidAll.size() , 最后返回查询的结果result

1.2.5、一致性哈希分配策略(AllocateMessageQueueConsistentHash)

分析其源码AllocateMessageQueueByMachineRoom类的核心方法是allocate

	public List<MessageQueue> allocate(String consumerGroup, String currentCID, List<MessageQueue> mqAll,
			List<String> cidAll) {
		if ((currentCID == null) || (currentCID.length() < 1)) {
			throw new IllegalArgumentException("currentCID is empty");
		}
		if ((mqAll == null) || (mqAll.isEmpty())) {
			throw new IllegalArgumentException("mqAll is null or mqAll empty");
		}
		if ((cidAll == null) || (cidAll.isEmpty())) {
			throw new IllegalArgumentException("cidAll is null or cidAll empty");
		}

		List result = new ArrayList();
		if (!(cidAll.contains(currentCID))) {
			this.log.info("[BUG] ConsumerGroup: {} The consumerId: {} not in cidAll: {}",
					new Object[] { consumerGroup, currentCID, cidAll });

			return result;
		}

		Collection cidNodes = new ArrayList();
		for (String cid : cidAll)
			cidNodes.add(new ClientNode(cid));
		ConsistentHashRouter router;
		ConsistentHashRouter router;
		if (this.customHashFunction != null)
			router = new ConsistentHashRouter(cidNodes, this.virtualNodeCnt, this.customHashFunction);
		else {
			router = new ConsistentHashRouter(cidNodes, this.virtualNodeCnt);
		}

		List results = new ArrayList();
		for (MessageQueue mq : mqAll) {
			ClientNode clientNode = (ClientNode) router.routeNode(mq.toString());
			if ((clientNode != null) && (currentCID.equals(clientNode.getKey()))) {
				results.add(mq);
			}
		}

		return results;
	}

2、广播消费

广播消费：一条消息被多个consumer消费，即使这些consumer属于同一个ConsumerGroup,消息也会被ConsumerGroup中的每个Consumer都消费一次，广播消费中ConsumerGroup概念可以认为在消息划分方面无意义。

2.1、创建广播消费者

创建两个集群消费者ConsumerGB1、ConsumerGB2，下面写出了ConsumerGB1的代码，ConsumerGB2也是一样的不再重复了。

public class ConsumerGB1 {
	public static void main(String[] args){
		try {
			DefaultMQPushConsumer consumer = new DefaultMQPushConsumer();
			consumer.setConsumerGroup("consumer_test_broadcasting");
			//设置广播消费
			consumer.setMessageModel(MessageModel.BROADCASTING);
			consumer.setNamesrvAddr("10.10.12.203:9876;10.10.12.204:9876");
			consumer.subscribe("TopicTest", "*");
			consumer.registerMessageListener(new MessageListenerConcurrently(){

				@Override
				public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> paramList,
						ConsumeConcurrentlyContext paramConsumeConcurrentlyContext) {
					try {
					    for(MessageExt msg : paramList){
					    	String msgbody = new String(msg.getBody(), "utf-8");
					    	System.out.println("ConsumerGB1===  MessageBody: "+ msgbody);//输出消息内容
					    }
					} catch (Exception e) {
					    e.printStackTrace();
					    return ConsumeConcurrentlyStatus.RECONSUME_LATER; //稍后再试
					}
					return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消费成功
				}
			});
			consumer.start();
			System.out.println("ConsumerGB1===启动成功!");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

**consumer.setMessageModel(MessageModel.BROADCASTING);**设置其为广播模式

广播模式下的消息的消费进度存储在客户端本地，服务端上不存储其消费进度

集群模式下的消息的消费进度存储在服务端

广播模式消费进度文件夹：C:/Users/gumx/.rocketmq_offsets 文件夹下

查看消费进度文件

{
	"offsetTable":{{
			"brokerName":"broker-a",
			"queueId":3,
			"topic":"TopicTest"
		}:14,{
			"brokerName":"broker-a",
			"queueId":2,
			"topic":"TopicTest"
		}:14,{
			"brokerName":"broker-b",
			"queueId":3,
			"topic":"TopicTest"
		}:14,{
			"brokerName":"broker-b",
			"queueId":0,
			"topic":"TopicTest"
		}:14,{
			"brokerName":"broker-a",
			"queueId":1,
			"topic":"TopicTest"
		}:14,{
			"brokerName":"broker-b",
			"queueId":2,
			"topic":"TopicTest"
		}:14,{
			"brokerName":"broker-a",
			"queueId":0,
			"topic":"TopicTest"
		}:13,{
			"brokerName":"broker-b",
			"queueId":1,
			"topic":"TopicTest"
		}:13
	}
}

通过这个我们可以发现主题是TopicTest一共有8个消费队列，分布在两个Broker节点上broker-a、broker-b，队列的ID从0~3分别是4个，每个队列现在消息的偏移量不同，两个13六个14。

通过界面客户端查看其消费者信息

发送10条消息

我们发现两个消费组都消费了10条消息

再次通过界面客户端查看其消费者信息

广播模式下消息发送前后其消费位点还是0，其实是因为广播模式下消息消费后其消息的状态不做改变

集群模式下消息发送后，如果消费者消费成功后消费位点也会增加，该消费组的消息状态会改变

我们查看下本地的消费进度文件

{
	"offsetTable":{{
			"brokerName":"broker-a",
			"queueId":3,
			"topic":"TopicTest"
		}:15,{
			"brokerName":"broker-a",
			"queueId":2,
			"topic":"TopicTest"
		}:15,{
			"brokerName":"broker-b",
			"queueId":3,
			"topic":"TopicTest"
		}:15,{
			"brokerName":"broker-b",
			"queueId":0,
			"topic":"TopicTest"
		}:15,{
			"brokerName":"broker-a",
			"queueId":1,
			"topic":"TopicTest"
		}:15,{
			"brokerName":"broker-b",
			"queueId":2,
			"topic":"TopicTest"
		}:16,{
			"brokerName":"broker-a",
			"queueId":0,
			"topic":"TopicTest"
		}:14,{
			"brokerName":"broker-b",
			"queueId":1,
			"topic":"TopicTest"
		}:15
	}
}

发现已经改变了其消费位点

2.2、注意事项

广播模式下会有一些问题，我们具体分析下。

当看到这个图的时候是不是会有一些疑问我们明明启用了两个消费者为什么消费者的ID为什么是相同的，难道图中标注的有问题？其实不然，这个就是消费者的ID我们进一步探讨下。

**consumer.start();**消费者启动的源码查找，其核心方法是DefaultMQPushConsumerImpl.start(),分析其源码，我们查看一下其消费者的ID生成

this.mQClientFactory=MQClientManager.getInstance().getAndCreateMQClientInstance(this.defaultMQPushConsumer,this.rpcHook);

public MQClientInstance getAndCreateMQClientInstance(final ClientConfig clientConfig, RPCHook rpcHook) {
        String clientId = clientConfig.buildMQClientId();
        MQClientInstance instance = this.factoryTable.get(clientId);
        if (null == instance) {
            instance =
                new MQClientInstance(clientConfig.cloneClientConfig(),
                    this.factoryIndexGenerator.getAndIncrement(), clientId, rpcHook);
            MQClientInstance prev = this.factoryTable.putIfAbsent(clientId, instance);
            if (prev != null) {
                instance = prev;
                log.warn("Returned Previous MQClientInstance for clientId:[{}]", clientId);
            } else {
                log.info("Created new MQClientInstance for clientId:[{}]", clientId);
            }
        }

        return instance;
    }

String clientId = clientConfig.buildMQClientId();

private String instanceName = System.getProperty("rocketmq.client.name", "DEFAULT");
public String buildMQClientId() {
	StringBuilder sb = new StringBuilder();
	sb.append(this.getClientIP());

	sb.append("@");
	sb.append(this.getInstanceName());
	if (!UtilAll.isBlank(this.unitName)) {
		sb.append("@");
		sb.append(this.unitName);
	}

	return sb.toString();
}

我们发现其clientId 是由两部分组成客户端IP地址，和InstanceName中间用了“@”连接，当然InstanceName可以设置，默认则是DEFAULT，这样我们就解释了其为什么消费者启动了两个其客户端消费者的ID只有一个。

广播模式消费下当客户端需要启动多个消费者的时候，建议手动设置其InstanceName，没有设置时会发现其消费进度是使用的一个文件。

广播模式消费时我们如果迁移客户端则会重新生成其消费进度文件，默认开始消费的位置为队列的尾部，之前的消费默认放弃，消费的起始位置可以配置（PS：下一章节会介绍）

广播模式消费时.rocketmq_offsets文件夹下的消费者ID/消费组名称文件夹下的offsets.json很重要，切记不能删除或损坏，否则消费进度会有影响，消费时可能导致数据重复或丢失

C:/Users/gumx/.rocketmq_offsets/192.168.1.102@DEFAULT/consumer_test_broadcasting/offsets.json

改造其消费端ConsumerGB1、ConsumerGB2分别设置InstanceName为00001、00002

public class ConsumerGB1 {
	public static void main(String[] args){
		try {
			DefaultMQPushConsumer consumer = new DefaultMQPushConsumer();
			consumer.setConsumerGroup("consumer_test_broadcasting");
			//设置广播消费
			consumer.setMessageModel(MessageModel.BROADCASTING);
			consumer.setNamesrvAddr("10.10.12.203:9876;10.10.12.204:9876");
			consumer.subscribe("TopicTest", "*");
			//设置其InstanceName
			consumer.setInstanceName("00001");
			consumer.registerMessageListener(new MessageListenerConcurrently(){

				@Override
				public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> paramList,
						ConsumeConcurrentlyContext paramConsumeConcurrentlyContext) {
					try {
					    for(MessageExt msg : paramList){
					    	String msgbody = new String(msg.getBody(), "utf-8");
					    	System.out.println("ConsumerGB1===  MessageBody: "+ msgbody);//输出消息内容
					    }
					} catch (Exception e) {
					    e.printStackTrace();
					    return ConsumeConcurrentlyStatus.RECONSUME_LATER; //稍后再试
					}
					return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; //消费成功
				}
			});
			consumer.start();
			System.out.println("ConsumerGB1===启动成功!");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

我们查看其消费进度文件夹

广播模式下如果两个消费者GB1、GB2的InstanceName相同消费组相同，都启动情况下，发送消息时都会消费消息，其中GB1异常停止，GB2正常消费，则GB1手动干预启动后，异常停止期间的消息不会再消费，因为公用一个消费进度文件。

转载于:https://my.oschina.net/mingxungu/blog/3083951

chongshui129727
关注
RocketMQ（11）——消费者拉模式和推模式
Elim的博客
09-05 3268
RocketMQ提供了两种消息的消费模式，拉模式和推模式。我们先来看一下拉模式消费的应用。
Spring Boot集成RocketMQ消费端更多扩展属性配置 | Spring Cloud 35
gmHappy
04-10 1万+
现在开始我们正式学习`Spring Boot`集成`RocketMQ`消费端更多扩展属性配置，在本章节主要进行对以下部分讲解说明： - `consumer`设置消费失败最大重试次数 - `consumer`设置消费起始位点
RocketMQ（七） RocketMQ的两种消费模式
m0_67402970的博客
06-12 1535
目录一、概述二、集群消费三、广播消费RocketMQ主要提供了两种消费模式：集群消费以及广播消费。我们只需要在定义消费者的时候通过**setMessageModel(MessageModel.XXX)**方法就可以指定是集群还是广播式消费，默认是集群消费模式，即每个Consumer Group中的Consumer均摊所有的消息。下面我们通过简单的示例演示一下。一个 Consumer Group 中的 Consumer 实例平均分摊消费消息。使用方法：setMessageModel(MessageModel.
细谈RocketMQ的消费模式
热门推荐
凡是过往，皆为序章
10-17 2万+
目录 集群消费 广播消费 使用集群消费模拟广播消费 首先明确一点，RocketMQ 是基于发布订阅模型的消息中间件。所谓的发布订阅就是说，consumer 订阅了 broker 上的某个 topic，当 producer 发布消息到 broker 上的该 topic 时，consumer 就能收到该条消息。 之前我们讲过 consumer group 的概念，即消费同一类消息的多个 co...
RocketMQ 消费方式
最新发布
m0_68570169的博客
09-18 295
在消息传递系统中，“推（Push）”和“拉（Pull）”是两种不同的消息消费方式，RocketMQ 也支持这两种模式。下面是对这两种模式的详细解释：模式简介：工作原理：优点：缺点：适用场景：模式简介：工作原理：优点：缺点：适用场景：在 RocketMQ 中，你可以选择使用推模式或拉模式来消费消息：具体使用哪种模式，可以根据业务需求和系统特性来决定。
RocketMQ 消费模式详解
My_wife_QBL的博客
07-13 875
RocketMQ 提供了多种消费模式，包括集群消费模式、广播消费模式和顺序消费模式，每种模式都有其特定的应用场景和优势。理解这些消费模式的原理和特点，有助于开发者在实际项目中选择合适的消费模式，从而优化系统的性能和可靠性。希望本文能帮助读者全面了解 RocketMQ 的消费模式，并在实际应用中发挥其优势。
RocketMQ——消费者消费模式（集群模式、广播模式）
浮沉此间的博客
05-22 7143
1、负载均衡模式（集群模式） 消费者采用负载均衡方式消费消息，一个分组(Group)下的多个消费者共同消费队列消息，每个消费者处理的消息不同。一个Consumer Group中的各个Consumer实例分摊去消费消息，即一条消息只会投递到一个Consumer Group下面的一个实例。例如某个Topic有3个队列，其中一个Consumer Group 有 3 个实例，那么每个实例只消费其中的1个队列。集群消费模式是消费者默认的消费方式。 代码中由这一行代码控制： // 消费模式 默认是集群模式.
rocketmq消费模式
03-26
RocketMQ支持以下几种消费模式： 1. 集群消费模式（Cluster） 多个消费者同时消费同一个Topic下的消息，每条消息只有一个消费者可以消费。当一个消费者出现故障或者停机，其他消费者会自动均摊该消费者的消息。...
RocketMQ 消费端PUSH 模式详解
bingfengxiyang703的博客
01-12 1532
一.简介 从这一期开始，我们对RocketMQ进行源码分析，我们知道，RocketMQ消费分为两种模式，pulll和push， pull即消费者客户端主要向服务端拉取消息，push模式为服务端主动将消息推到客户端，这次我们从源码的角度分析下push模式的实现 二.问题分析 先简单分析下，什么为推？ 我们知道设计模式中有一个模式叫监听器模式，实际上很多框架的实现...
RocketMq之消费方式
猎户星座
06-03 6579
最近仍然畅游在RocketMQ的源码中，这几天刚好翻到了消费者的源码，发现RocketMQ的对于push消费方式的实现简直太聪明了，所以趁着我脑子里还有点印象的时候，赶紧来写一篇文章，来掰扯一下，防止过两天就忘得一干二净了。 MQ消费方式 消费方式就是指消费者如何从MQ中获取到消息，分为两种方式，push（推方式）和pull（拉方式）。 1、push（推方式） push，顾名思义，就是推的意思。就是当MQ收到生产者产生的消息的时候，会主动将消息推送到消费者进行消费，这种模式就叫push，也就是MQ将
七、RocketMQ的消费模式
HueyLong的博客
10-15 952
*优点：**及时性好**缺点：**如果客户端没有做好流控，一旦服务端推送大量消息到客户端时，就会导致客户端消息堆积甚至崩溃。主要关注点在订阅topic后，消费方式模式。
RocketMQ（五）——消费模式
张连海
08-26 2万+
RocketMQ的消费方式有2种，在默认情况下，就是集群消费，也就是消息的负载均衡消费。另一种消费模式，是广播消费。广播消费，类似于ActiveMQ中的发布订阅模式，消息会发给Consume Group中的每一个消费者进行消费。
rocketMq-Consumer的两种消费模式:push和pull(含源码解读)
软件工程探索之旅
02-04 2496
在RocketMQ中，虽然从概念上讲Consumer有两种消费模式：Push和Pull，push模式让人感觉由broker将消息主动push到consumer。但在实际实现时，这两种模式都采用了类似长轮询（long polling）的机制，即由Consumer主动向Broker拉取消息。不过，它们的具体行为有所不同，我们主要介绍一下Push模式。
RocketMQ的两种消费模式
m0_54187478的博客
03-13 707
集群消费模式更适合处理业务数据，确保消息的稳定和高效处理，支持负载均衡和故障转移。广播消费模式适合于那些需要每个消费者都获得完整消息的场景，例如系统警告、配置更新等。选择合适的消费模式，可以根据你的具体需求和消息的特点来决定。RocketMQ的灵活性让它能够适应各种不同的应用场景，从而提供高效、可靠的消息服务。
【 RocketMQ —— 03 消费模式】
m0_72328778的博客
07-05 425
在RocketMQ中，消费者可以以两种主要模式来消费消息：集群消费（Clustering Consumption）和广播消费（Broadcasting Consumption）。这两种模式在消费策略上有所不同，适用于不同的场景。
rocketmq集群消费模式和广播消费模式代码分享
ZYunfei的博客
03-26 1367
集群消费模式适用于每条消息只需要被处理一次的场景，也就是说整个消费组会Topic收到全量的消息，而消费组内的消费分担消费这些消息，因此可以通过扩缩消费者数量，来提升或降低消费能力，具体示例如下图所示，是最常见的消费方式。广播消费模式适用于每条消息需要被消费组的每个消费者处理的场景，也就是说消费组内的每个消费者都会收到订阅Topic的全量消息，因此即使扩缩消费者数量也无法提升或降低消费能力，具体示例如下图所示。
RocketMQ——Consumer消费模式及两种消费者辨析（DefaultMQPushConsumer和DefaultMQPullConsumer）
Stay Hungry Stay Foolish
03-03 3532
RocketMQ的Consumer有两种消费模式，通过 consumer.setMessageModel(MessageModel.BROADCASTING) 和consumer.setMessageModel(MessageModel.CLUSTERING)设置 广播模式 当使用广播消费模式时，MQ 会将每条消息推送给集群内所有订阅该topic和tag的客户端，保证消息至少被每台机器消费一次。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值