Kafka知识点

原创 已于 2023-06-15 14:16:36 修改
· 208 阅读 · 1 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#kafka #java-rabbitmq #rabbitmq

于 2023-06-14 14:34:45 首次发布

一、RabbitMQ和Kafka区别

RabbitMQ和Kafka是两个常用的分布式消息队列系统，它们的主要区别包括以下几个方面：

  1. 架构模式：RabbitMQ采用点对点模式和订阅-发布模式，即消息生产者将消息发送到特定的队列，然后等待消费者来处理这个消息，或者发送到订阅的exchange，由绑定到此exchange的队列接收；而Kafka采用发布-订阅模式，即消息生产者把消息发送给主题（topic），然后订阅这个主题的所有消费者都可以接收到消息。

  2. 性能：Kafka是高吞吐量、低延迟的消息队列系统，由于其使用M_MAP存储消息，所以可以在单大型消息流中处理数百MB或更大的消息；而RabbitMQ在高吞吐量方面表现不如Kafka，但在消息持久化和交付确认方面表现优秀。

  3. 消息处理机制：RabbitMQ支持多种消息处理机制，如消息优先级、消息交换、消息队列、路由等，可以更好地满足不同的消息处理需求；而Kafka仅仅是消息的存储系统，并不涉及消息处理机制。

  4. 部署和管理：Kafka部署和管理相对简单，只需要至少三台服务器即可，而RabbitMQ需要更多的服务器才能保证高可用和可靠性。

  5. 应用场景：Kafka适用于海量数据处理和实时数据处理，如日志、指标数据、事件数据等，而RabbitMQ更适合于任务队列和消息通信，如邮件发送、任务调度等。

总的来说，Kafka适用于高吞吐量的场景，对数据的存储、发布和订阅具有高效、可靠、灵活等优势，适用于大数据平台中的任务处理、实时处理等场景；而RabbitMQ适合于任务队列和消息通信等场景，对消息的处理机制和交付确认具有支持多种协议、高可靠性等优势，适用于任务处理、通信交互等场景。

二、Kafka 应用场景

Kafka是一个高吞吐量、低延迟的分布式流式处理平台，具有以下几个主要的应用场景：

  1. 日志数据处理：Kafka具有高效、可靠、低延迟的数据传输能力，可以用于处理日志数据，如访问日志、错误日志、性能日志等。

  2. 流式数据处理：Kafka支持按照时间有序的数据流处理模式，可以用于端到端的实时流式数据处理，如数据ETL、实时统计、实时更新等。

  3. 事件驱动架构：Kafka作为事件驱动架构的消息承载系统，可以用于实现基于事件的异步系统，如实时监控、消息推送等。

  4. 实时数据处理：Kafka可以通过消息队列实现实时数据的持久性和可靠性，支持高并发的数据处理能力，并且能直接集成Spark、Storm等实时计算引擎，具备强大的实时数据处理能力。

  5. 大数据平台：Kafka可以作为大数据平台的基础设施，用于数据的收集、存储和传输，与Hadoop、HBase、Cassandra等大数据存储系统进行集成，可以实现大规模的数据处理和分析。

总的来说，Kafka适用于中、大规模数据的实时处理，支持高性能、高可靠、高可用的特性，具有非常广泛的应用场景，如日志数据处理、流式数据处理、事件驱动架构、实时数据处理和大数据平台等。

三、java中Kafka安装和使用

Java开发人员可以使用官方提供的Kafka客户端API，安装和使用步骤如下：

  1. 下载Kafka：从Kafka官方网站下载Kafka安装包，解压到指定目录中。

  2. 配置Broker和Zookeeper：修改Kafka配置文件，设置Broker和Zookeeper的地址、端口等信息。

  1. 配置Broker的信息 在Kafka的配置文件server.properties中，主要需要配置以下几个参数：
  • broker.id：表示当前Broker的唯一标识符，每个Broker在集群中需要有唯一的标识符。例如：broker.id=1；
  • listeners：表示Broker启动的监听地址和端口。监听地址一般为localhost，端口为9092，多个地址和端口用逗号分隔。例如：listeners=PLAINTEXT://localhost:9092；
  • log.dirs：表示存储消息数据的目录。例如：log.dirs=/var/log/kafka。
  1. 配置Zookeeper的信息 在Kafka的配置文件server.properties中，主要需要配置以下几个参数：
  • zookeeper.connect：表示连接Zookeeper集群的地址和端口。多个地址和端口用逗号分隔。例如：zookeeper.connect=localhost:2181。
    将server.properties文件修改好之后，将文件保存，重启Kafka Broker即可使得新的配置生效。
  1. 启动Zookeeper：使用命令行工具启动Zookeeper服务，以便Kafka的Broker和Consumer节点之间进行通信。

  1. 下载Zookeeper：从Apache官网下载对应版本的Zookeeper，解压到指定目录中。

  2. 配置Zookeeper：在Zookeeper的conf目录下，找到zoo.cfg文件，用编辑器打开。

  3. 配置Zookeeper参数：在zoo.cfg文件中按自己的需求配置Zookeeper参数，例如dataDir=/tmp/zookeeper，clientPort=2181等。

  4. 启动Zookeeper：进入Zookeeper的bin目录下，在命令行中输入./zkServer.sh start命令，即可启动Zookeeper服务。

  1. 启动Kafka Broker：使用命令行工具启动Kafka Broker，可以通过kafka-server-start.sh脚本启动Broker，并指定配置文件的路径。
    具体步骤如下：

进入Kafka的bin目录下，在命令行中输入./kafka-server-start.sh config/server.properties命令，即可启动Kafka Broker。

  1. 创建Topic：使用kafka-topics.sh命令创建Topic，可以指定Topic的名称、副本数、分区数等参数。

  1. 进入Kafka的bin目录中，打开命令行工具。

  2. 执行以下命令创建Topic，并指定Topic的名称、副本数、分区数等参数，例如：

    ./kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 10 --topic my_topic

    说明：

    • --create：表示创建Topic的命令；
    • --zookeeper：表示连接的Zookeeper地址和端口；
    • --replication-factor：表示副本数，即每个分区的复制数。应该把副本数设置成集群中Broker数量的一部分。如果是单节点的测试环境，可以将其设置为1，表示每个分区只有一份拷贝；
    • --partitions：表示分区数。可以根据需求自行指定分区数；
    • --topic：表示要创建的Topic的名称。如果该Topic不存在，则会自动创建。

  3. 执行以上命令后，如果创建成功，会看到以下信息：

    bash Created topic "my_topic".

  1. 生产者使用：使用Producer API实现生产者功能，可以发送消息到指定的Topic。
    是的，使用Kafka Producer API可以实现生产者功能，可以通过发送消息将数据传输到Kafka集群的指定Topic中。

  1. 导入Kafka Producer API相关依赖，例如：

        <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>2.8.0</version>    </dependency>

  2. 在代码中通过Kafka Producer API创建Producer对象：

    Properties props = new Properties();   
props.put("bootstrap.servers", "localhost:9092");    
props.put("acks","all");    
props.put("key.serializer",org.apache.kafka.common.serialization.StringSerializer");   
props.put("value.serializer",org.apache.kafka.common.serialization.StringSerializer");   
Producer<String, String> producer = new KafkaProducer<>(props);

    说明：

    • bootstrap.servers：表示Kafka Broker的连接地址和端口；
    • acks：表示请求的确认模式。可选值有：0、1、all，分别表示生产者发送消息后是否等待Broker的确认，默认值是1；
    • key.serializer：表示用于序列化生产者发送的键的序列化器；
    • value.serializer：表示用于序列化生产者发送的值的序列化器。

  3. 通过Producer对象发送消息到指定的Topic中：

    ProducerRecord<String, String> record = newProducerRecord<>("my_topic", "key", "value");   
producer.send(record);

    说明：

    • ProducerRecord：表示待发送到Topic的消息记录。其中，第一个参数是Topic名称，第二个参数是消息的键，第三个参数是消息的值。

  4. 发送完消息后，关闭Producer：

    producer.close();

四、go中Kafka安装和使用

Go语言提供了Sarama库来实现Kafka的生产者和消费者，安装和使用的步骤如下：

  1. 安装Sarama库：在Go语言环境中使用go get命令安装Sarama，命令行如下：go get -u github.com/Shopify/sarama

  2. 导入Sarama库：在Go程序中导入Sarama库，以便在程序中使用Kafka的API。

import "github.com/Shopify/sarama"
  1. 创建生产者：在Go程序中使用Sarama库创建生产者，示例代码如下：
config := sarama.NewConfig()
config.Producer.RequiredAcks = sarama.WaitForAll // 等待所有副本接收到消息
config.Producer.Partitioner = sarama.NewRandomPartitioner // 随机分区
config.Producer.Return.Successes = true // 记录成功发送的消息

message := &sarama.ProducerMessage{
    Topic: "test",
    Value: sarama.StringEncoder("this is a test message"),
}

producer, err := sarama.NewAsyncProducer([]string{"localhost:9092"}, config)
if err != nil {
    panic(err)
}

for {
    select {
    case <- producer.Successes():
        fmt.Println("sent message successfully")
    case <- producer.Errors():
        fmt.Println("failed to send message:", err)
    case producer.Input() <- message:
        fmt.Println("start sending message...")
    }
}
  1. 创建消费者：在Go程序中使用Sarama库创建消费者，示例代码如下：
config := sarama.NewConfig()
config.Consumer.Return.Errors = true // 记录消费错误

consumer, err := sarama.NewConsumer([]string{"localhost:9092"}, config)
if err != nil {
    panic(err)
}
defer consumer.Close()

partitionConsumer, err := consumer.ConsumePartition("test", 0, sarama.OffsetNewest)
if err != nil {
    panic(err)
}
defer partitionConsumer.Close()

for {
    select {
    case message := <- partitionConsumer.Messages():
        fmt.Printf("received message: %s\n", string(message.Value))
    case err := <- partitionConsumer.Errors():
        fmt.Println("failed to consume message:", err)
    }
}

需要注意的是，在实际生产环境中，需要对Go程序进行优化、配置Sarama库参数、关注Kafka集群的状态和性能等方面，以保证Kafka的高可用性、低延迟和高吞吐量。

五、学习Kafka可以遵循以下的学习路径：

  1. 了解Kafka的基础概念和原理

Kafka是一个高吞吐量的分布式消息系统，具有高可靠性、高扩展性、灵活性等特点。需要首先理解Kafka的本概念，例如Topic、Broker、Producer、Consumer、Partition、Offset等，并对Kafka的基本工作原理有一个初步的认识。

  1. 安装和配置Kafka

了解如何安装和配置Kafka，包括Kafka集群的规划、Kafka软件的安装、配置文件的编辑等。

  1. 熟悉Kafka的API和工具

了解Kafka的API和工具，例如Producer API、Consumer API、Streams API、Connect API、Kafka CLI、Kafka Manager等。

  1. Producer API： Producer API是Kafka中的一种API，用于向Kafka集群发送消息。使用Producer
    API，可以将消息发送到Kafka中的一个或多个Topic中，并可以指定消息的Key和Value。

  2. Consumer API： Consumer API是Kafka中的一种API，用于从Kafka集群中消费消息。使用Consumer
    API，可以从指定的Topic中消费消息，支持基于消息Key的过滤，支持以不同的顺序消费消息。

  3. Streams API：Streams API是Kafka中的一种API，用于流处理。使用Streams
    API，可以对Kafka中的消息进行流处理，例如实时聚合、数据清洗、实时计算等。Streams
    API可以与其他流处理框架集成，例如Spark Streaming、Flink、Storm等。

  4. Connect API： Connect API是Kafka中的一种API，用于构建数据连接器。使用Connect
    API，可以将Kafka集群与其他系统连接起来，例如将Kafka与MySQL连接起来，将Kafka与HDFS连接起来等。Connect
    API提供了基本的连接器框架，可以根据需求编写或定制具体的连接器。

  5. Kafka CLI： Kafka命令行接口（CLI）是Kafka中的一种工具，用于执行Kafka相关的一些命令。使用Kafka
    CLI，可以进行一些基本操作，例如创建Topic、发送消息、消费消息、查看集群状态等。

  6. Kafka Manager： Kafka Manager是一个开源的Kafka管理工具，提供了图形化的界面，可用于监控和管理Kafka集群。使用Kafka
    Manager，可以查看Kafka的Topic、Partition、Offset的详细信息，并对集群进行监控和诊断，以及执行各种管理操作。

学习如何使用这些API和工具，包括创建Topic、发送消息、消费消息、处理流数据、连接外部系统等功能。

一、创建Topic

  1. 创建Kafka配置对象，并设置相关配置项，例如Kafka集群的地址、Topic的分区等等。
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
  1. 创建KafkaAdminClient对象，该对象可以用于创建、删除和查询Topic等操作。
   AdminClient admin = AdminClient.create(props);
  1. 创建新的Topic，指定Topic名称、分区数和副本数等信息。
    NewTopic newTopic = new NewTopic("test", Optional.empty(), Optional.empty());
    newTopic.numPartitions(1);
    newTopic.replicationFactor((short) 1);
  1. 调用AdminClient.createTopics()方法，以创建新的Topic。
    CreateTopicsResult ctr = admin.createTopics(Arrays.asList(newTopic));

二、发送消息

  1. 创建Kafka配置对象，并设置相关配置项，例如Kafka集群的地址、消息的序列化和反序列化类等等。
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("acks", "all");
    props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
  1. 创建KafkaProducer对象，用于将消息发送到Kafka Broker。
    Producer<String, String> producer = new KafkaProducer<>(props);
  1. 创建一个消息，指定消息的Key和Value，并使用Producer.send()方法将消息发送到指定的Topic。
    ProducerRecord<String, String> record = new ProducerRecord<>("test", "key1", "value1");
    producer.send(record);
  1. 最后，关闭KafkaProducer对象，释放资源。
    producer.close();

三、消费消息

在Java中消费Kafka消息一般需要以下步骤：

  1. 创建Kafka配置对象，设置Kafka集群的地址和消息的反序列化类等信息。
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("group.id", "test-consumer-group");
    props.put("enable.auto.commit", "true");
    props.put("auto.commit.interval.ms", "1000");
    props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
    props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
  1. 创建KafkaConsumer对象，用于消费Kafka消息。
    Consumer<String, String> consumer = new KafkaConsumer<>(props);
  1. 订阅一个或多个Topic。
    consumer.subscribe(Arrays.asList("test"));
  1. 不断地轮询消息，并处理每一条消息。
    while (true) {
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
        for (ConsumerRecord<String, String> record : records) {
            System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
        }
    }
  1. 最后，关闭KafkaConsumer对象，释放资源。
    consumer.close();

四、处理流数据

  1. 引入依赖

首先需要引入Kafka Streams API的依赖，可以在Maven或Gradle中添加如下依赖：

<artifactId>kafka-streams</artifactId>   <version>2.8.0</version>
</dependency>
  1. 编写代码

假设要从Kafka集群中消费名为my-input-topic的消息，对消息进行处理，并将处理结果写入名为my-output-topic的Topic中。代码如下：

// 创建KafkaStreams配置，并指定应用程序ID和Kafka集群地址。
Properties config = new Properties();
config.put(StreamsConfig.APPLICATION_ID_CONFIG,"my-stream-processing-application");
config.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
// 创建StreamsBuilder对象，用于构建流处理拓扑结构。
StreamsBuilder builder = new StreamsBuilder(); 
// 构造KStream对象，并从名为my-input-topic的Topic中消费消息。
KStream<String, String> inputStream = builder.stream("my-input-topic"); 
// 对消息进行处理，并将结果写入名为my-output-topic的Topic中。
KStream<String,String> outputStream = inputStream.mapValues(value -> value.toUpperCase()); 
outputStream.to("my-output-topic",Produced.with(Serdes.String(), Serdes.String()));
// 创建KafkaStreams对象，并启动流处理应用程序。
KafkaStreams streams = new KafkaStreams(builder.build(), config);
streams.start();

在流处理拓扑结构的构造过程中，可以使用多种操作函数，例如filter、map、flatMap、reduce、aggregate等。使用这些操作函数可以对流数据进行各种处理任务。

  1. 运行程序

最后可以将代码打包成jar包，通过命令行或Shell脚本启动流处理应用程序，并将jar包上传到Kafka集群中。在启动过程中可以指定其他参数，如Kafka集群地址、Zookeeper地址、应用程序ID等。启动命令如下：

bin/kafka-run-class.sh org.apache.kafka.streams.examples.WordCountDemo

五、连接外部系统
在Java中，可以使用Kafka Connect连接外部系统。Kafka Connect是一个用于数据连接的框架，可以将Kafka集群和其他系统进行连接并进行数据导入和导出。

  1. 引入依赖

首先需要引入Kafka Connect的依赖，可以在Maven或Gradle中添加如下依赖：

<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-connect-api</artifactId>
    <version>2.8.0</version> </dependency>
  1. 编写代码

然后可以编写Java代码，使用Kafka Connect连接外部系统。以下是一个简单的样例，将来自MySQL数据库的数据导入Kafka集群：

// 创建Kafka Connect的配置，并设置外部系统的连接信息和一些配置参数。
Properties props = new Properties(); props.put("connection.url","jdbc:mysql://localhost:3306/mydb"); > > props.put("connection.user","user"); 
props.put("connection.password", "password");
// 创建JdbcSourceConnector对象，并将配置传递给它。
props.put("connector.class", "io.confluent.connect.jdbc.JdbcSourceConnector");
props.put("topic.prefix", "mytopic-");
props.put(JdbcSourceConnectorConfig.MODE_CONFIG,JdbcSourceConnectorConfig.MODE_INCREMENTING);
props.put(JdbcSourceConnectorConfig.INCREMENTING_COLUMN_NAME_CONFIG,"id");
// 启动Kafka Connect并开始从MySQL数据库中读取增量数据并导入Kafka集群中，所有导入的数据都会存储在名为mytopic-的Topic中。
Connector connector = new JdbcSourceConnector();
connector.start(props);
  1. 运行程序

最后可以将代码打包成jar包，通过命令行或Shell脚本启动Kafka
Connect。在启动时可以指定其他参数，如Kafka集群地址、Zookeeper地址、连接器类名等。启动命令如下：

bin/connect-standalone.sh connect-standalone.properties my-connect-jdbc-source.properties

以上命令中，connect-standalone.properties文件中包含了连接Kafka集群和Zookeeper的信息和配置，my-connect-jdbc-source.properties文件中包含了连接MySQL数据库的信息和配置。

使用Kafka Connect连接外部系统非常灵活和方便，可以通过配置简单的参数来对不同的外部系统进行连接。

  1. 学习Kafka生态系统

Kafka具有丰富的生态系统，需要了解各个生态组件的功能和特点。例如Kafka Connect、Kafka Streams、KSQL、Schema Registry、Mirror Maker等，都是常用的生态组件，学习它们的使用方法和部署方式。

  1. Kafka Connect：是一个用于数据连接的框架，用于将Kafka集群和其他系统进行连接。
    支持从其他系统导入数据到Kafka，也支持将Kafka数据导出到其他系统。
    支持各种数据源和数据目标，例如文件系统、关系数据库、NoSQL数据库、消息队列等。
    部署方式：是以插件的方式进行，即根据需求安装和配置相应的Kafka Connect插件，例如JDBC、Connect、HDFS Connect等。

  2. Kafka Streams：是一个用于流处理的库，可以将Kafka作为流处理引擎，在Kafka中进行实时流处理。
    提供了统一的编程模型和API，支持对流进行转换、聚合、过滤、窗口等流处理操作。
    还支持各种数据格式，例如JSON、AVRO等。
    Kafka Streams 主要特点是具有幂等性的处理模型、摒弃状态共享，支持插件化的数据存储和数据源。
    部署方式：是在Java应用程序中引入Kafka Streams库，并在应用程序代码中使用Kafka Streams的API 进行流处理。

  3. KSQL：是一个用于SQL流处理的引擎，可以将Kafka作为数据源进行SQL查询和流处理。
    支持类SQL语法的查询和流处理操作，可以进行流的过滤、连接、聚合等操作。
    还支持流的窗口操作和时间运算。
    部署方式：是在Kafka集群中安装和配置KSQL服务，然后通过命令行或Web界面对Kafka进行SQL查询和流处理。

  4. Confluent Schema Registry：是一个用于数据格式和模式管理的中央注册表，用于支持数据在不同系统之间的交换和兼容。
    提供了对数据格式和模式的管理和版本控制，支持常见的数据格式和编码方式，例如JSON、Avro等。
    部署方式：与Kafka集群一起部署，可以使用Docker容器、Kubernetes等方式进行部署，也可以在多个Kafka集群之间共享Schema Registry服务。

  5. Kafka Manager：是一个用于管理Kafka集群的Web界面工具，可以用于监控和管理Kafka集群的状态、Topic、分区等信息。
    提供了丰富的界面和功能，例如Topic的创建和删除、消费者组的管理、分区的重分配等操作。
    部署方式：将Kafka Manager作为单独的应用程序进行安装和部署，并配置Kafka Manager连接到Kafka集群。

  6. Kafka MirrorMaker：是 Kafka 集群之间数据复制的工具。它可以将一个 Kafka 集群中的主题或分区复制到另一个Kafka 集群中。Kafka MirrorMaker 主要特点是异步属性（不会阻塞生产者），可以在多个集群之间进行数据复制，可容错性强。
    部署方式：下载 Kafka 压缩包，解压后修改 MirrorMaker 的配置文件，启动 MirrorMaker 实例。

  1. 学习Kafka实战

根据实际需求，进行Kafka实际应用的开发和部署，例如使用Kafka进行日志收集、事件驱动架构、数据传输、流式处理等。在Kafka实战学习过程中，针对实际问题进行解决和优化，深入了解Kafka在实际应用中的使用。

  1. 日志收集

使用 Kafka 进行日志收集，可以将不同应用系统产生的日志集中到一个 Kafka 集群中，然后通过消费者消费这些日志数据，进行分析和处理。

初步步骤是:

  • 将 KfkClient 引入 pom.xml 文件中，并设置对应版本。
  • 在 java 代码中，使用 Producer 发送消息到 Kafka 集群中。

示例代码如下：

props.put("bootstrap.servers", "localhost:9092"); //指定 Kafka 服务链接
props.put("acks", "all"); // 指定所有 follower 副本都接收到消息的确认标准
props.put("retries", 0); 
props.put("batch.size", 16384);
props.put("linger.ms", 1); 
props.put("buffer.memory", 33554432);
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

Producer<String, String> producer = new KafkaProducer<>(props);

// 发送数据 for (int i = 0; i < 100; i++)  
producer.send(new ProducerRecord<String, String>("test", Integer.toString(i), Integer.toString(i)));

producer.close();
  1. 事件驱动架构

事件驱动架构是指使用事件来组织和同步系统之间的交互。Kafka 提供了一个分布式的事件驱动平台，可以用来构建实时的流处理应用程序。

步骤是：

  • 使用 Kafka Connect 将事件数据从原始应用程序捕获，并将其发送到 Kafka 集群中。
  • 将 Kafka Streams 应用程序部署到集群中，并通过消费者 API 读取和处理事件数据。

示例代码如下：

// 创建 streams 链接到 kafka 集群 
KafkaStreams streams = new KafkaStreams(builder.build(), props);

// 启动 streams 
streams.start();
  1. 数据传输

使用 Kafka 进行数据传输，可以将数据从一个应用程序传输到另一个应用程序。

使用步骤如下：

  • 创建 Kafka 生产者配置。
  • 创建 Kafka 生产者，并使用它将消息发送到 Kafka 队列。
  • 在接收端使用 Kafka 消费者从 Kafka 队列读取消息。

示例代码如下：

props.put("bootstrap.servers", "localhost:9092");  // 指定 Kafka 服务链接
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

// 创建 Producer 实例 
Producer<String, String> producer = new KafkaProducer<>(props);

// 生产者发送消息 
ProducerRecord<String, String> record = new ProducerRecord<>("my-topic", "hello", "world"); producer.send(record);

// 创建 Kafka 消费者的配置 
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");  // 指定 Kafka 服务链接
props.put("group.id", "my-group");  
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

// 创建 Consumer 实例 
Consumer<String, String> consumer = new KafkaConsumer<>(props);

// 消费者订阅主题并接收消息
consumer.subscribe(Collections.singletonList("my-topic"));
ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100)); 
for (ConsumerRecord<String, String> record : records)
 { System.out.printf("offset = %d, key = %s, value = %s %n", record.offset(), record.key(), record.value()); }
  1. 流式处理
    在 Java 中使用 Kafka 进行流式处理，可以利用 Kafka Streams 库来实现。

Kafka Streams
是一个处理流式数据的库，它可以将原始数据流转换为处理后的输出流，并可以执行实时计算等操作。它适用于检测和分析数据流、进行实时数据处理和数据清洗等场景。

下面是在 Java 中使用 Kafka Streams 进行流式处理的步骤：

  1. 引入依赖

在项目的 pom.xml 文件中，添加 Kafka Streams 的依赖：

    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-streams</artifactId>
    <version>2.8.0</version> </dependency>
  1. 创建 KafkaStreams 实例

首先需要创建一个 KafkaStreams 实例来绑定输入和输出 Kafka
Topics，以及定义流式处理操作。可以通过流式处理器的构造方法来创建 KafkaStreams 实例，构造方法接收一个
KafkaStreams 配置对象和一个 Topology 对象。

Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "my-streams-app");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");

StreamsBuilder builder = new StreamsBuilder(); // 定义流处理拓扑结构
builder.stream("input-topic").mapValues(value -> value.toUpperCase()).to("output-topic");

KafkaStreams streams = new KafkaStreams(builder.build(), props);

在这个例子中，我们使用 StreamsBuilder 创建了一个流式拓扑结构，该结构将读取 “input-topic”
中的数据，把它们转换成大写，并将结果写入 “output-topic”。

  1. 启动流处理器

接下来，可以使用 start() 方法启动流处理器。

java streams.start();

当流处理器启动时，它就会开始读取输入 Kafka Topic 中的数据，并根据配置的拓扑结构将其转换成输出流。可以通过流处理器持续地处理实时的数据流，并将其输出到输出 Kafka Topic 中。

  1. 关闭流处理器

可以使用 close() 方法关闭流处理器：

java streams.close();

  1. 深入学习Kafka源码

对于Kafka的源码进行深入学习，掌握Kafka的内部实现机制和运行原理，进一步优化Kafka的运行效率和队列处理能力。

总之，学习Kafka需要掌握Kafka的基础概念、API、工具和生态系统，深入理解Kafka的应用场景和实战开发过程，同时学习Kafka的源码可以加深对Kafka运行机制的理解。

六、Kafka的内部实现机制和运行原理

  1. 数据存储

Kafka 的消息存储是基于磁盘的，数据被存储在消息日志中。每个主题包含一个或多个分区，每个分区都包含多个日志段。每个日志段限制一个固定大小（默认 1GB），并包含当前分区接受的消息集合。新消息会被追加到当前日志段的尾部。

  1. 数据传输

Kafka 采用发布/订阅的模型，即生产者将数据发布到 Kafka Topic 中，消费者则订阅需要的 Topic。生产者将消息发送到 Kafka 集群中的 Broker 上，Broker 将消息持久化到磁盘中，然后将消息分发到订阅该 Topic 的消费者。

  1. 消息处理

Kafka 的消息处理器在设计上是可扩展的，支持在多个不同的应用程序之间共享数据。Kafka 支持流式处理，可以将原始数据流转换为处理后的输出流，并可以执行实时计算等操作。Kafka 还通过消费者组的概念来支持并发处理，将无序的消息分配到不同的消费者组中，使得每个组相互之间可以并行处理消息。

  1. 重平衡处理

Kafka 中的重平衡是指消费者组中新增、删除或修改消费者时所进行的一系列操作。当出现此类修改时，Kafka 会自动启动重平衡过程，以确保消费者可以正确地消费消息。在重平衡过程中，Kafka 会将每一分区重新分配到消费者实例之间。在重平衡时，需要考虑到数据的顺序性和处理顺序，以确保数据的正确性和一致性。

  1. 高可用性

为了增强 Kafka 的高可用性，Kafka 设计了多机器的架构，将主题的多个分区复制到多个 Broker 上。在这个复制过程中，Kafka 采用分区ISR(有效副本集)概念保证分区数据的可靠性，并在副本出现异常时，自动进行数据迁移和副本恢复操作。

综上所述， Kafka 的消息架构设计上采用了分布式存储和消费者模型，支持可扩展的横向扩展和高效的数据处理。这些优势使得 Kafka 成为了一个强大的分布式消息系统和流处理框架。

第一节：kafka golang sarama初体验
cui_win的专栏
02-20 659
关于Kafka的开发库，以Java的居多，Golang语言的开发库，主要推荐的是sarama项目地址：这个项目之前地址是https://github.com/Shopify/sarama 通过源地址也可以访问本节，我们简单通过golang语言，操作sarama.NewClient对象，查询了kafka集群的topic列表，brokers列表，控制器ID。希望大家对sarama有了初步认识。
go之kafka库sarama的使用
专注于Python编程技术的分享与交流，致力于帮助开发者提升编程技能，解决实际问题，探索Python的无限可能。
10-26 2772
saram是一个使用纯go语言编写的kafka库。
Golang中如何正确的使用sarama包操作Kafka？
xmcy001122的专栏
08-10 3863
背景 在一些业务系统中，模块之间通过引入Kafka解藕，拿IM举例（图来源）： 用户A给B发送消息，msg_gateway收到消息后，投递消息到Kafka后就给A返回发送成功。这个时候，其实还没有持久化到mysql中，虽然最终会保持一致性。所以，试想如果Kafka丢消息了，是不是就出大问题了？A认为给B发送消息成功了，但是在服务器内部消息丢失了B并没有收到。 所以，在使用Kafka的时候，有一些业务对消息丢失问题非常的关注。 同样，常见的问题还有： 重复消费的问题。 乱序的问题。 下面我们来一起看一下
go语言并发实战——日志收集系统(三) 利用sarama包连接KafKa实现消息的生产与消费
qq_73924465的博客
04-17 2287
由于1.19版本后添加了ztcd压缩算法，需要用到cgo，这里我们为了方便考虑选择下载。不过这个不能实现直接的消费，后续我们会对这个进行补充，这里制作介绍。今天我们所时机的内容需要用到go语言的第三方包。了,但是博主在做的时候发现，这样会直接清除掉。命令来安装第三方包，我们要使用/，所以这里我们不能直接使用。其实这是已经可以使用命令。等待命令运行完毕，打开。这时候再打开终端输入。
Kafka(Go)教程(六)---sarama 客户端 producer 源码分析
探索云原生
09-20 1891
来自：指月 https://www.lixueduan.com 原文：https://www.lixueduan.com/post/kafka/06-sarama-producer/ 本文主要通过源码分析了 Kafka Go sarama 客户端生产者的实现原理，包括消息分发流程，消息打包处理，以及最终发送到 Kafka 等具体步骤，最后通过分析总结出的常见性能优化手段。 本文基于 sarama v1.29.1 1. 概述 Kafka 系列相关代码见 Github 具体流程如下图： Sarama
go语言操作kafka
qq_35857939的博客
10-14 618
sarama Go语言中连接kafka使用第三方库: github.com/Shopify/sarama。 下载及安装 go get github.com/Shopify/sarama {{% panel status=“notice” title=“注意事项” %}} sarama v1.20之后的版本加入了zstd压缩算法，需要用到cgo，在Windows平台编译时会提示类似如下错误： g...
kafka知识点
01-07
1.什么是kafka？ 开放性问题 Kafka是一个分布式的流处理平台，一般用来缓存数据。kafka主要是作为一个分布式的、可分区的、具有副本数的日志，具有服务系性、高容错性、访问速度快、分布式等特性； 具有高水平扩展，...
一文详解kafka知识点
最新发布
三日沐水
11-19 1784
传统定义：kafka是一个分布式的基于发布/订阅模式的消息队列（Message Queue），主要应用于大数据实时处理领域。发布/订阅：消息的发布者不会将消息直接发生给特定的订阅者。而是将发布的消息分为不同的类别，订阅者只接收感兴趣的消息。新定义：kafka是一个开源的分布式事件流平台（Event Streaming Platform），被数千家公司用于高性能数据管道、流分析、数据集成和关键任务。
Kafka知识点（基础+进阶+高阶）
03-17
**Kafka基础知识** Apache Kafka是一种分布式流处理平台，由LinkedIn开发并在2011年开源，后来成为Apache软件基金会的顶级项目。Kafka的核心概念包括生产者、消费者、主题和分区。 1. **生产者**: 生产者是数据的...
全网最全最通俗易懂的Kafka知识点汇总，入门到精通，完全学会
weixin_51702416的博客
08-30 8087
Apache Kafka是一个分布式发布 - 订阅消息系统和一个强大的队列, 可以处理大量的数据, 并使您能够将消息从一个端点传递到另一个端点. Kafka适合离线和在线消息消费. Kafka消息保留在磁盘上, 并在群集内复制以防止数据丢失. Kafka构建在ZooKeeper同步服务之上. 它与Apache Storm 和Spark非常好地集成, 用于实时流式数据分析.Kafka 依赖于日志顺序写, 因此支持消息回溯和支撑高性能读写依赖 Zookeeper架构​。...
kafka 知识点脑图.png
04-08
知识图示
Go-Go-consumergroup采用golang编写的kafkaconsumer库
08-14
Go-consumergroup：采用golang编写的kafka consumer库
golang kafka sarama 消费者组
01-20
之前用kafka，没在网上找到关于 sarama消费者组的代码。后来才在源码里面找到例子，现在稍微修改了下代码，记录一下。 package main import ( context github.com/Shopify/sarama log github.com/sirupsen/logrus os os/signal sync syscall time ) type Kafka struct { brokers []string topics []string //OffsetNewest int64 = -1 //OffsetO
golang kafka Shopify/sarama 消费者重置新增分区偏移量并进行重新消费
Enjun97的博客
03-14 2326
在重平衡回调方法中使用redis的无序集合储存当前主题、当前消费者组下的全部分区信息，然后在根据当前消费者会话去和上一代的全部分区信息进行差集对比，对比的结果就是新增的分区。得到新增的分区后将这些分区的偏移量重置为0即重头开始消费，当前存在重复消费的情况，需要你的业务逻辑上做好幂等性。最后再将这些差集新增分区ID更新至redis存储的当前主题、当前消费者组下的全部分区信息内形成了一个闭环，即使一个消费者组下有多个消费者进程也不会出现数据覆盖更新等问题，因为如果存在差集新增分区只会将更新差集分区ID。
golang kafka客户端 sarama，segmentio/kafka-go ，confluent-kafka-go，franz-go比较
王仁一的博客
05-30 1890
golang kafka客户端 sarama，segmentio/kafka-go ，confluent-kafka-go，franz-go哪个更好
Kafka(Go)教程(八)---生产者压缩算法详解及源码分析
探索云原生
10-16 1083
来自：指月 https://www.lixueduan.com 原文：https://www.lixueduan.com/post/kafka/08-compression/ 本文主要分析了 Kafka 生产者压缩与解压逻辑以及注事事项点，最终通过 Go 客户端 sarama 演示了 压缩算法的具体使用，并通过源码分析了 Go 客户端 sarama 的具体实现。 Kakfa 相关代码见 Github 1. 概述 压缩（compression）它秉承了用时间去换空间的经典 trade-off 思想，具体
探秘Kafka世界：基于Sarama的高效工具与库
gitblog_00319的博客
09-11 1047
探秘Kafka世界：基于Sarama的高效工具与库 kafka Load-balancing, resuming Kafka consumer for go, backed by Zookeeper. 项目地址: https://...
Golang 使用 Sarama 消费 Kafka 集群消息 (2)
xiangyong_的博客
10-28 406
使用 Sarama 消费 Kafka 集群消息，除了ConsumerGroup方式外还可以使用Consumer方式。早期的Kafka版本只能用Consumer方式，特点是Consumer消费topic中所有的消息。N个Consumer消费同一个topic，相当于一个topic中的消息被消费了N遍。需要注意Consumer消费完成后需要自行维护offset，使用msg.Offset可以取到当前的offset。和，表示 topic 最老和最新的 offset。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值