Kafka

已于 2024-08-05 11:03:52 修改
阅读量617 收藏 11
点赞数 21
分类专栏： Spring 文章标签： kafka 分布式
于 2024-08-05 09:46:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43349479/article/details/140918340
版权

在Apache Kafka中，单播和多播的概念与传统网络通信中的定义有所不同。Kafka是一种分布式流处理平台，主要用于构建实时数据管道和流应用。它的核心概念包括主题（Topic）、分区（Partition）、生产者（Producer）和消费者（Consumer）。

Kafka中的单播

在Kafka中，单播通常指的是数据从生产者发送到一个特定的分区，然后由一个特定的消费者组中的一个消费者进行消费。这种模式下，每个消息只会被一个消费者处理。

  • 特点：
    • 点对点：消息从生产者发送到一个特定的分区，然后由一个消费者处理。
    • 负载均衡：消费者组中的多个消费者可以分担处理不同分区的数据，从而实现负载均衡。
    • 应用场景：适用于需要确保每个消息只被处理一次的场景，如订单处理系统。

Kafka中的多播

在Kafka中，多播指的是数据从生产者发送到一个主题，然后由多个消费者组进行消费。每个消费者组中的消费者都可以独立地消费同一个主题中的消息。

  • 特点：
    • 点对多点：消息从生产者发送到一个主题，然后由多个消费者组独立消费。
    • 独立消费：每个消费者组可以独立地消费同一个主题中的消息，不会相互影响。
    • 应用场景：适用于需要将同一数据流发送给多个不同应用的场景，如日志收集系统、实时监控系统等。

对比

  • 单播：消息从生产者发送到一个特定的分区，由一个消费者组中的一个消费者处理，适用于需要确保每个消息只被处理一次的场景。
  • 多播：消息从生产者发送到一个主题，由多个消费者组独立消费，适用于需要将同一数据流发送给多个不同应用的场景。

示例

假设有一个主题 orders，生产者将订单数据发送到这个主题：

  • 单播：消费者组 order-processing 中的消费者会处理这些订单数据，每个订单只会被一个消费者处理。
  • 多播：除了 order-processing 组，还有一个 order-analytics 组，这两个组可以独立地消费 orders 主题中的数据，order-processing 组处理订单，而 order-analytics 组进行订单分析。

在Apache Kafka中，不同分区之间的消息传递并不直接涉及多播的概念。为了更好地理解这个问题，我们需要明确Kafka的分区和多播的定义。

分区 (Partition)

Kafka中的主题（Topic）可以分为多个分区（Partition），每个分区是一个有序的、不可变的消息序列。分区的存在使得Kafka能够实现高吞吐量和水平扩展。

多播 (Multicast)

在Kafka的上下文中，多播通常指的是一个主题中的消息可以被多个消费者组独立消费。每个消费者组中的消费者可以独立地读取和处理消息。

不同分区之间的关系

不同分区之间的消息传递并不涉及多播的概念。分区的主要作用是实现数据的并行处理和负载均衡。以下是一些关键点：

  • 独立性：每个分区是独立的，消息在一个分区内是有序的，但不同分区之间没有顺序保证。
  • 负载均衡：生产者可以将消息分配到不同的分区，以实现负载均衡。消费者组中的消费者可以并行地消费不同分区的数据。
  • 并行处理：多个消费者可以并行地处理不同分区的数据，从而提高处理效率。

多播的实现

多播在Kafka中是通过消费者组来实现的。一个主题中的消息可以被多个消费者组独立消费，每个消费者组中的消费者可以独立地读取和处理消息。

示例

假设有一个主题 orders，它有3个分区：

  • 生产者：生产者将订单数据发送到 orders 主题，数据会被分配到不同的分区。
  • 消费者组A：消费者组A中的消费者会并行地消费 orders 主题的不同分区的数据。
  • 消费者组B：消费者组B中的消费者也会并行地消费 orders 主题的不同分区的数据。

在这个例子中，orders 主题中的消息被多个消费者组（A和B）独立消费，这就是Kafka中的多播概念。

总结

  • 不同分区之间：不同分区之间的消息传递不涉及多播，它们是独立的，用于实现并行处理和负载均衡。
  • 多播：多播是通过消费者组来实现的，一个主题中的消息可以被多个消费者组独立消费。

在Apache Kafka中，不同分区之间的消息传递并不直接涉及多播的概念。为了更好地理解这个问题，我们需要明确Kafka的分区和多播的定义。

分区 (Partition)

Kafka中的主题（Topic）可以分为多个分区（Partition），每个分区是一个有序的、不可变的消息序列。分区的存在使得Kafka能够实现高吞吐量和水平扩展。

多播 (Multicast)

在Kafka的上下文中，多播通常指的是一个主题中的消息可以被多个消费者组独立消费。每个消费者组中的消费者可以独立地读取和处理消息。

不同分区之间的关系

不同分区之间的消息传递并不涉及多播的概念。分区的主要作用是实现数据的并行处理和负载均衡。以下是一些关键点：

  • 独立性：每个分区是独立的，消息在一个分区内是有序的，但不同分区之间没有顺序保证。
  • 负载均衡：生产者可以将消息分配到不同的分区，以实现负载均衡。消费者组中的消费者可以并行地消费不同分区的数据。
  • 并行处理：多个消费者可以并行地处理不同分区的数据，从而提高处理效率。

多播的实现

多播在Kafka中是通过消费者组来实现的。一个主题中的消息可以被多个消费者组独立消费，每个消费者组中的消费者可以独立地读取和处理消息。

示例

假设有一个主题 orders，它有3个分区：

  • 生产者：生产者将订单数据发送到 orders 主题，数据会被分配到不同的分区。
  • 消费者组A：消费者组A中的消费者会并行地消费 orders 主题的不同分区的数据。
  • 消费者组B：消费者组B中的消费者也会并行地消费 orders 主题的不同分区的数据。

在这个例子中，orders 主题中的消息被多个消费者组（A和B）独立消费，这就是Kafka中的多播概念。

总结

  • 不同分区之间：不同分区之间的消息传递不涉及多播，它们是独立的，用于实现并行处理和负载均衡。
  • 多播：多播是通过消费者组来实现的，一个主题中的消息可以被多个消费者组独立消费。

在Apache Kafka中，消费者组（Consumer Group）是一个非常重要的概念，它允许多个消费者实例共同消费一个或多个主题中的消息，并且每条消息只会被一个消费者实例处理。要指定消费者组，你需要在消费者配置中设置group.id属性。

配置消费者组

以下是一个完整的示例，展示如何在Spring Kafka中配置消费者组并使用@KafkaListener注解来接收消息。

1. 配置消费者属性和消费者工厂

首先，你需要配置消费者属性，并在其中指定消费者组ID。

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;

import java.util.HashMap;
import java.util.Map;

@EnableKafka
@Configuration
public class KafkaConsumerConfig {

    @Bean
    public ConsumerFactory<String, String> consumerFactory() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "benefit-test-group"); // 指定消费者组ID
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        return new DefaultKafkaConsumerFactory<>(props);
    }

    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        return factory;
    }
}
2. 创建消费者监听器

接下来，你需要创建一个消费者监听器来处理接收到的消息。使用@KafkaListener注解并指定主题和消费者组ID。

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class KafkaConsumerService {

    @KafkaListener(topics = "benefit-test", groupId = "benefit-test-group")
    public void listen(String message) {
        System.out.println("Received message: " + message);
    }
}

运行应用

当你运行应用时，KafkaConsumerService中的listen方法会自动订阅benefit-test主题，并作为benefit-test-group消费者组的一部分来接收和处理消息。

关键点总结

  • 消费者组ID：在消费者配置中通过ConsumerConfig.GROUP_ID_CONFIG属性指定消费者组ID。
  • @KafkaListener注解：在监听方法上使用@KafkaListener注解，并通过groupId属性指定消费者组ID。

示例代码

以下是完整的示例代码：

KafkaConsumerConfig.java
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;

import java.util.HashMap;
import java.util.Map;

@EnableKafka
@Configuration
public class KafkaConsumerConfig {

    @Bean
    public ConsumerFactory<String, String> consumerFactory() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "benefit-test-group"); // 指定消费者组ID
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        return new DefaultKafkaConsumerFactory<>(props);
    }

    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        return factory;
    }
}
KafkaConsumerService.java
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class KafkaConsumerService {

    @KafkaListener(topics = "benefit-test", groupId = "benefit-test-group")
    public void listen(String message) {
        System.out.println("Received message: " + message);
    }
}

在Apache Kafka中，发送消息通常是通过生产者（Producer）来完成的。在Spring Kafka中，你可以使用KafkaTemplate来发送消息。以下是一个完整的示例，展示如何配置生产者并使用KafkaTemplate发送消息。

配置生产者

首先，你需要配置生产者属性和生产者工厂。

1. 配置生产者属性和生产者工厂

创建一个配置类来配置生产者属性和生产者工厂。

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class KafkaProducerConfig {

    @Bean
    public ProducerFactory<String, String> producerFactory() {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return new DefaultKafkaProducerFactory<>(configProps);
    }

    @Bean
    public KafkaTemplate<String, String> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }
}
2. 使用KafkaTemplate发送消息

创建一个服务类，使用KafkaTemplate发送消息。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class KafkaProducerService {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public void sendMessage(String topic, String message) {
        kafkaTemplate.send(topic, message);
    }
}

示例代码

以下是完整的示例代码，包括生产者配置和发送消息的服务类。

KafkaProducerConfig.java
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class KafkaProducerConfig {

    @Bean
    public ProducerFactory<String, String> producerFactory() {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return new DefaultKafkaProducerFactory<>(configProps);
    }

    @Bean
    public KafkaTemplate<String, String> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }
}
KafkaProducerService.java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class KafkaProducerService {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public void sendMessage(String topic, String message) {
        kafkaTemplate.send(topic, message);
    }
}

发送消息

你可以在你的应用程序中调用KafkaProducerService的sendMessage方法来发送消息。例如：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class KafkaMessageSender implements CommandLineRunner {

    @Autowired
    private KafkaProducerService kafkaProducerService;

    @Override
    public void run(String... args) throws Exception {
        kafkaProducerService.sendMessage("benefit-test", "this is a text");
    }
}

总结

  • 配置生产者：通过ProducerFactory和KafkaTemplate配置生产者。
  • 发送消息：使用KafkaTemplate的send方法发送消息。

在Apache Kafka中，每个分区只能被一个消费者组中的一个消费者实例消费。这是Kafka实现高吞吐量和负载均衡的关键机制之一。以下是详细解释：

消费者组和分区的关系

  • 消费者组（Consumer Group）：一个消费者组由多个消费者实例组成，这些消费者实例共同消费一个或多个主题中的消息。
  • 分区（Partition）：每个主题可以分为多个分区，每个分区是一个有序的、不可变的消息序列。

消费者组中的消费者和分区的映射

  • 独占消费：在一个消费者组内，每个分区只能被一个消费者实例消费。这意味着同一个消费者组中的多个消费者不会同时消费同一个分区的数据。
  • 负载均衡：Kafka会自动将分区分配给消费者组中的消费者，以实现负载均衡。如果消费者组中的消费者数量多于分区数量，则一些消费者将不会分配到任何分区。

示例

假设有一个主题 my_topic，它有3个分区（Partition 0, Partition 1, Partition 2），并且有一个消费者组 my_group，该组有3个消费者（Consumer A, Consumer B, Consumer C）。

  • 分区分配：
    • Partition 0 -> Consumer A
    • Partition 1 -> Consumer B
    • Partition 2 -> Consumer C

如果消费者组 my_group中有4个消费者（Consumer A, Consumer B, Consumer C, Consumer D），则其中一个消费者将不会分配到任何分区。

  • 分区分配：
    • Partition 0 -> Consumer A
    • Partition 1 -> Consumer B
    • Partition 2 -> Consumer C
    • Consumer D -> 无分区

多个消费者组

多个消费者组可以独立地消费同一个主题中的消息。每个消费者组中的消费者实例会独立地消费分区中的消息，不会相互影响。

  • 消费者组1（group1）：

    • Partition 0 -> Consumer A1
    • Partition 1 -> Consumer B1
    • Partition 2 -> Consumer C1

  • 消费者组2（group2）：

    • Partition 0 -> Consumer A2
    • Partition 1 -> Consumer B2
    • Partition 2 -> Consumer C2

在这种情况下，group1和group2中的消费者可以独立地消费my_topic中的消息。

总结

  • 一个分区只能被一个消费者组中的一个消费者实例消费：在一个消费者组内，每个分区只能被一个消费者实例消费，以实现负载均衡和高吞吐量。
  • 多个消费者组可以独立消费同一个主题：多个消费者组可以独立地消费同一个主题中的消息，不会相互影响。

通过这种机制，Kafka能够高效地处理大量数据，并确保消息的有序消费。

你这个代码我看不懂
关注
  • 21
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
查询Kafka生产者是否连接到Kafka服务
weixin_44976692的博客
06-22 5万+
java领域优质创作者🌐。
Doris 数据集成 Kafka
04-26 6万+
这是我们Doris 数据集成篇的第二篇，前面我们介绍过通过 Catalog进行集成的例子目前公司的很多数据服务都开始使用Doris 了，目前使用下来感觉还是很方便的，比起Hadoop 那一套少了很多运维的成本，而且整体的效率也不错，现在也要把ELK 那一套日志分析的替换掉，后面日志分析也走Doris。关于如何使用Doris做日志分析，可以参考之前的文章，不过第一步也不是日志分析，而是如何对接Kafka ，因为目前日志数据是在kafka 里的，这里我调研了一下使用Flink 和 Doris 的。
SpringBoot集成kafka全面实战
热门推荐
Felix
03-28 20万+
本文是SpringBoot+Kafka的实战讲解，如果对kafka的架构原理还不了解的读者，建议先看一下《大白话kafka架构原理》、《秒懂kafka HA（高可用）》两篇文章。 一、生产者实践 普通生产者 带回调的生产者 自定义分区器 kafka事务提交 二、消费者实践 简单消费 指定topic、partition、offset消费 ...
【Kafka】Windows下安装Kafka（图文记录详细步骤）
tttzzzqqq2018的博客
08-06 3万+
(一)、Kafka是由Apache软件基金会开发的一个开源流处理平台，由Scala和Java编写。Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者在网站中的所有动作流数据。 (二)、Kafka 本质上是⼀个消息队列。与zeromq不同的是，Kafka是一个独立的框架而不是一个库。通过O(1)的磁盘数据结构提供消息的持久化，这种结构对于即使数以TB的消息存储也能够保持长时间的稳定性能。高吞吐量 ：即使是非常普通的硬件Kafka也可以支持每秒数百万的消息。
kafka
Django的博客
01-29 2万+
Kafka是什么 Apache Kafka是一个开源消息系统，由Scala写成。是由Apache软件基金会开发的一个开源消息系统项目。 Kafka最初是由LinkedIn开发，并于2011年初开源。2012年10月从Apache Incubator毕业。该项目的目标是为处理实时数据提供一个统一、高通量、低等待的平台。 Kafka是一个分布式消息队列：生产者、消费者的功能。它提供了类似于JMS的特...
kafka常用命令
zhangmuqiang的博客
07-05 9189
bin/kafka-consumer-groups.sh --bootstrap-server $nodes --group $groupname --reset-offsets --all-topics --to-earliest --execute # 重设消费者组位移(待验证)bin/kafka-console-consumer.sh --bootstrap-server $nodes --topic $topicName --from-beginning # 使用消费者。
Kafka 副本
02-11 3万+
follower发生故障后会被临时踢出ISR，待该follower恢复后，follower会读取本地磁盘记录的上次的HW，并将log文件高于HW的部分截取掉（HW之前每个节点都有，故安全），从HW开始向leader进行同步。leader发生故障之后，会从ISR中选出一个新的leader，之后，为保证多个副本之间的数据一致性，其余的follower会先将各自的log文件高于HW的部分截掉，然后从新的leader同步数据。HW：指的是消费者能见到的最大的offset，ISR队列中最小的LEO。
查询Kafka集群中消费组（group）信息和对应topic的消费情况
weixin_44976692的博客
06-18 4万+
通过上述方法，可以方便地查询Kafka集群中的消费组信息和topic的消费情况，从而更好地管理和监控Kafka集群的运行状态。希望这篇博客对你有所帮助！如果有更多问题，欢迎留言讨论。
Kafka集群部署
想你依然心痛的博客
06-15 5万+
好了，Kafka的集群部署我们就讲到这里了，这几篇主要针对大数据集群环境的搭建进行了讲解，包括创建虚拟机、Linux操作系统的安装与配置、安装JDK、ZooKeeper集群部署、Hadoop集群部署、Spark集群部署、HBase集群部署以及Kafka集群部署。通过这几篇的学习，希望读者熟悉大数据集群环境的搭建流程，并掌握ZooKeeper、Hadoop、Spark、HBase和Kafka集群的部署，为后续项目的开展奠定基础。启动Kafka集群时，需要确保ZooKeeper集群是正常启动的。
使用 JMX 监控 Kafka 集群性能指标
weixin_44976692的博客
06-05 3万+
在大规模的生产环境中，实时监控 Kafka 集群的性能指标是确保系统稳定运行的重要手段。本文将介绍如何使用 JMX（Java Management Extensions）监控 Kafka 集群，并展示一些常用的 JMX 指令和指标。通过使用 JMX 监控 Kafka 集群的性能指标，我们可以更好地了解系统的运行状况，并及时发现和处理潜在的问题。结合使用 JConsole、jcmd 和 jstat 等工具，我们可以全面监控 Kafka 集群的各项性能指标，确保系统的稳定运行。
kafka 插件kafka 插件kafka 插件
06-26
**Kafka插件详解** Kafka插件是Apache Kafka与各种工具集成的重要组成部分，它使得开发者和运维人员能够更方便地在不同的系统中利用Kafka的功能。Kafka是一款分布式流处理平台，常用于构建实时数据管道和流应用，...
kafka-3.5.1
09-27
开源软件kafka_2.13-3.5.1版本，仅供学习安装，不可用做其他用途，建议直接在官网进行下载，版本为3.5.1，Scala版本2.13;开源软件kafka_2.13-3.5.1版本，仅供学习安装，不可用做其他用途，建议直接在官网进行下载，...
Maven项目整合Kafka
03-12
使用Maven整合Kafka 包括生产者，消费者 Kafka各种配置 //1.设置参数 Properties props = new Properties(); props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "81.68.232.188:9092,81.68.232.188:9093,81...
kafka-2.13-3.7.0.tgz
04-08
**Kafka概述** Kafka是由LinkedIn开发并贡献给Apache软件基金会的一个开源分布式流处理平台。它的设计目标是成为一个高吞吐、低延迟的消息系统，能够处理海量实时数据。Kafka作为一个分布式消息中间件，它在大数据...
kafka-2.12-3.6.1.tgz
12-19
《Kafka 2.12-3.6.1在Linux环境下的快速部署与使用》 Kafka，作为一款高效、可扩展且持久化的分布式消息中间件，被广泛应用于大数据实时处理、日志收集和流处理等场景。本文将详细介绍如何在Linux环境下部署并使用...
测试环境搭建整套大数据系统（十九：kafka ssl）
weixin_43446246的博客
08-05 82
kafka ssl
消息队列：Kafka吞吐量为什么比RocketMQ大
最新发布
qq_64680177的博客
08-05 558
mmap返回的值可以让应用层获取到消息内容，可以进行一些逻辑处理，但sendfile返回的只是已经传输的字节数，具体发送了什么内容，内容层无法得知。而RocketMQ的一些功能需要具体了解到发送了什么消息才能实现（二次投递）。而Kafka主要追求吞吐量，也就不需要这些独特的功能，所以选择sendfile（）文件，以达到更高的吞吐量。 所以不同消息队列都有自己的特征，并不是说Kafka的架构就比RocketMQ比好，而是他们各自的选择。
kafka+zookeeper教程
08-05 227
创建节点(znode)-s: 创建顺序节点。-e: 创建临时节点。获取znode的数据。设置znode的数据。查看znode的状态。递归删除其子节点使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你这个代码我看不懂

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值