kafka：大规模实时数据流的必选

Apache Kafka：分布式流媒体平台

Apache Kafka是一个强大的分布式流媒体平台，用于处理实时数据流。它是一个高吞吐量、可扩展和持久的消息系统，广泛应用于日志处理、事件驱动的应用程序、监控和大数据分析等领域。

在本文中，我们将深入了解Apache Kafka的基本概念，并演示如何使用Kafka建立一个简单的消息生产者和消费者。

简介

Kafka 是一个分布式流媒体平台和消息代理，最初由LinkedIn开发并开源。它设计用于高吞吐量，可扩展性，持久性以及容错性。Kafka 主要用于处理实时数据流，广泛应用于各种领域，包括日志收集、事件处理、监控、报警、数据管道和流分析等。

以下是 Kafka 的一些关键概念和特点：

消息传递系统：Kafka 可以看作是一个高度可配置的分布式发布-订阅消息系统，它允许生产者将消息发布到主题（topic），然后允许消费者订阅这些主题并处理消息。

主题（Topic）：主题是消息的类别或数据流的逻辑通道。生产者将消息发布到特定主题，而消费者订阅这些主题以接收消息。每个主题可以有多个分区，以实现消息的并行处理和负载均衡。

分区（Partition）：每个主题可以分为多个分区，分区是 Kafka 中数据的基本单元。每个分区可以在不同的服务器上进行副本备份，以提高可用性和容错性。分区还允许消息并行处理，使 Kafka 能够处理大量数据并保持高吞吐量。

生产者（Producer）：生产者负责将消息发布到 Kafka 主题。生产者可以是任何应用程序或系统，它们生成数据并将其发送到 Kafka 集群。

消费者（Consumer）：消费者从 Kafka 主题中订阅消息并处理它们。消费者可以以不同的消费组（Consumer Group）形式进行组织，以实现负载均衡和横向扩展。

消息存储：Kafka 使用持久性存储来存储消息，以确保消息的持久性和可恢复性。消息通常在磁盘上保留一段时间，以供消费者检索。

**分布式和容错性：**Kafka 是分布式的，可以在多个服务器上运行，支持水平扩展。它具有容错性，能够处理服务器故障而不丢失数据。

流数据处理：Kafka 提供了流数据处理功能，允许开发人员构建复杂的数据流处理应用程序，例如实时分析、转换和复杂事件处理。

Kafka 的高吞吐量、可扩展性、持久性和容错性使其成为处理大规模实时数据流的理想选择。它在大数据、日志处理和实时监控等领域广泛应用，并且具有强大的生态系统，包括各种客户端库和工具，以帮助用户更轻松地集成 Kafka 到其应用程序和数据流处理流程中。

ZooKeeper 和 Kafka 之间的关系：

领导者选举： Kafka 使用 ZooKeeper 来实现代理节点（broker）的领导者选举，确保在分布式环境中只有一个代理节点能够写入和读取数据。

协调服务： ZooKeeper 可以用于管理 Kafka 集群的配置信息，例如主题和分区的元数据以及分区的分配。

监控和通知： Kafka 可以将集群的健康状态和元数据信息注册到 ZooKeeper，以供其他监控工具和应用程序使用。

Kafka基本概念

主题（Topic）

Kafka消息以主题（Topic）为单位进行分类。主题是数据流的逻辑通道，生产者将消息发布到主题，而消费者则订阅主题以接收消息。

分区（Partition）

每个主题可以分为多个分区，分区是Kafka中的数据分割单元。分区允许消息的并行处理和负载均衡，并且分区可以在多个服务器上进行副本备份以提高可用性。

生产者（Producer）

生产者是负责将消息发布到Kafka主题的组件。它们可以是应用程序、服务或系统，生成数据并将其发送到Kafka集群。

消费者（Consumer）

消费者从Kafka主题中订阅消息并进行处理。消费者可以组织成不同的消费组，以实现负载均衡和横向扩展。

环境准备

zookeeper环境

下载安装->考虑到是基于windows的环境
进入到bin目录后，

zkServer.sh start
zkServer.sh status
zkServer.sh stop


zkCli.cmd -server localhost:2181

可以基于log日志去判断是否开启，开启之后

开启kafka

 bin/windows/kafka-server-start.bat config/server.properties

kafka主题订阅

kafka-console-consumer.bat --topic quickstart-events --from-beginning --bootstrap-server localhost:9092

生产和消费

kafka-console-producer.bat --topic quickstart-events --bootstrap-server localhost:9092

kafka-console-consumer.bat --topic quickstart-events --from-beginning --bootstrap-server localhost:9092

查询分组和主题

kafka-topics.bat --list --bootstrap-server localhost:9092

kafka-consumer-groups.bat --list --bootstrap-server localhost:9092

Kafka示例

让我们通过一个简单的示例来演示Kafka的基本用法。首先，确保你已经安装了Kafka并启动了Kafka服务。

创建一个主题

我们将首先创建一个名为my-topic的Kafka主题：

bin/kafka-topics.sh --create --topic my-topic --partitions 3 --replication-factor 1 --bootstrap-server localhost:9092

这将创建一个具有3个分区的主题，副本因子为1。

基于java整合kafka

     <!-- Kafka -->
     <dependency>
         <groupId>org.apache.kafka</groupId>
         <artifactId>kafka-clients</artifactId>
         <version>3.5.0</version>
     </dependency>

     <dependency>
         <groupId>org.apache.kafka</groupId>
         <artifactId>kafka-streams</artifactId>
         <version>3.5.0</version>
     </dependency>

     <dependency>
         <groupId>org.apache.kafka</groupId>
         <artifactId>kafka-streams-scala_2.13</artifactId>
         <version>3.5.0</version>
     </dependency>

生产者

接下来，让我们创建一个Kafka生产者，发送一些消息到my-topic主题：

import org.apache.kafka.clients.producer.*;

public class KafkaProducerExample {
    public static void main(String[] args) {
        String bootstrapServers = "localhost:9092";
        String topic = "my-topic";

        Properties props = new Properties();
        props.put("bootstrap.servers", bootstrapServers);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());// 指定键的反序列化器
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); // 指定值的反序列化器

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

        producer.send(new ProducerRecord<>(topic, "key", "Hello, Kafka!"));
        producer.close();
    }
}

这个生产者将一条消息发送到my-topic主题。

消费者

最后，我们创建一个Kafka消费者来接收并处理这些消息：

import org.apache.kafka.clients.consumer.*;
import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        String bootstrapServers = "localhost:9092";
        String groupId = "my-group";
        String topic = "my-topic";

        Properties props = new Properties();
        props.put("bootstrap.servers", bootstrapServers);
        props.put("group.id", groupId);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());// 指定键的反序列化器
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); // 指定值的反序列化器

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Collections.singletonList(topic));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("Received message: key=%s, value=%s%n", record.key(), record.value());
            }
        }
    }
}

这个消费者将订阅my-topic主题，并打印接收到的消息。

基于springboot整合kafka

步骤1：添加依赖

首先，在您的Spring Boot项目的pom.xml文件中添加Spring Kafka依赖：

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>

步骤2：配置Kafka连接信息

在application.properties或application.yml中配置Kafka的连接信息，例如：

spring.kafka.bootstrap-servers=127.0.0.1:9092

您还可以配置其他Kafka相关属性，如序列化器、反序列化器等。

步骤3：创建Kafka生产者

创建一个Kafka生产者类，用于发送消息到Kafka主题：

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class KafkaProducer {

    private final KafkaTemplate<String, String> kafkaTemplate;

    public KafkaProducer(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

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

步骤4：创建Kafka消费者

创建一个Kafka消费者类，用于从Kafka主题接收消息：

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

@Service
public class KafkaConsumer {

    @KafkaListener(topics = "your-topic-name")
    public void receiveMessage(String message) {
        // 处理接收到的消息
    }
}

步骤5：发送和接收消息

在您的服务或控制器中，使用KafkaProducer来发送消息，然后KafkaConsumer会监听并接收消息。

@RestController
@RequestMapping("/kafka")
public class KafkaController {

    private final KafkaProducer kafkaProducer;
	@Autowired
	private KafkaTemplate template;

    @Autowired
    public KafkaController(KafkaProducer kafkaProducer) {
        this.kafkaProducer = kafkaProducer;
    }

    @PostMapping("/send")
    public ResponseEntity<String> sendMessage(@RequestParam String message) {
        kafkaProducer.sendMessage("your-topic-name", message);
        return ResponseEntity.ok("Message sent to Kafka topic");
    }

    @GetMapping("/sends/{input}")
    public ResponseEntity<String> sentToKafka(@PathVariable String input) {
        this.template.send("your-topic-name", input);
        return ResponseEntity.ok(input);
    }
}

结论

Apache Kafka是一个强大的流媒体平台，用于构建实时数据处理系统。通过主题、分区、生产者和消费者的组合，Kafka能够轻松处理大规模的数据流。这只是Kafka的入门，它还具有更多高级功能和配置选项，可满足各种实际应用的需求。