Kafka入门_kafka教程

Kafka是最初由Linkedln开发的，基于发布与订阅的消息系统。它一般被称为”分布式提交日志”或者“分布式流平台”。Kafka的数据是按照一定的顺序持久化保存的，可以按需读取。此外，Kafka的数据分布在整个系统里，具备数据故障保护和性能伸缩能力。

Kafka的数据单元被称为“消息”，它相当于数据库里的一个“数据行”或一条“记录”。消息由字节数组组成。

Kafka的消息通过“主题”进行分类。主题好比数据库里的“表”。主题可以被分为若干个分区，一个分区就是一个提交日志。消息以追加的方式写入分区，然后以先入先出的顺序读取。要注意的是，由于一个主题分为几个分区，因此无法在整个主题范围内保证消息的顺序，但可以保证消息在单个分区内的顺序。

Kafka的客户端就是Kafka系统的用户，他们分为两种类型：生产者和消费者

消费者是消费者群组的一部分，也就是说，会有一个或者多个消费者共同读取一个主题。群组保证每个分区只能被一个消费者读取。如下图所示：

一个独立的Kafka服务器被称为broker。broker接收来自生产者的消息，为消息设置偏移量，并提交消息到磁盘保存。

下面是一个Kafka生产者和消费者的入门例子：

1.首先，我们从http://kafka.apache.org/downloads，下载Kafka的包，解压后进入Kafka的目录，通过以下命令启动Kafka服务端：./kafka-server-start.sh -daemon ./../config/server.properties

如果是通过Maven来管理的话，添加Kafka的依赖包：

   <dependency>
      <groupId>org.apache.kafka</groupId>
      <artifactId>kafka_2.12</artifactId>
      <version>0.10.2.1</version>
   </dependency>
1
2
3
4
5

2.下面通过生产者客户端，向Kafka服务端发送消息：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.util.Properties;
import java.util.concurrent.Future;

/**
 * Created by CvShrimp on 2018/1/9.
 */
public class Producer {
    public static void main(String[] args) {
        Properties kafkaProps = new Properties();
        // Kafka服务器IP地址加端口号，默认为9092
        kafkaProps.put("bootstrap.servers", "192.168.186.128:9092");
        // key的序列化类，这里选择字符串的StringSerializer
        kafkaProps.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // value的序列化类，这里选择字符串的StringSerializer
        kafkaProps.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // 第一个参数为主题名,第二个参数为key的值,第三个为value的值
        ProducerRecord<String, String> record =
                new ProducerRecord<String, String>("CustomerCountry", "Precision Products", "France");

        Producer producer = new KafkaProducer<String, String>(kafkaProps);
        try {
            Future future = producer.send(record);
            RecordMetadata recordMetadata = (RecordMetadata) future.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3.下面通过消费者客户端，从Kafka服务端获取刚才的数据：

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * Created by wukn on 2018/1/11.
 */
public class Consumer {
    public static void main(String[] args) {
        Properties kafkaProps = new Properties();
        kafkaProps.put("bootstrap.servers", "192.168.186.128:9092");
        kafkaProps.put("group.id", "CountryCounter");
        // key的反序列化类，这里选择字符串的StringDeserializer
        kafkaProps.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        // value的反序列化类，这里选择字符串的StringDeserializer
        kafkaProps.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(kafkaProps);
        // CustomerCountry为生产者刚才提交到Kafka服务器的主题名
        consumer.subscribe(Collections.singletonList("CustomerCountry"));

        Map<String, Integer> cusCountryMap = new HashMap<String, Integer>();
        try {
            while (true) {
                // 获取数据
                ConsumerRecords<String, String> records = consumer.poll(100);
                for (ConsumerRecord<String, String> record : records) {
                    int updatedCount = 1;
                    if (cusCountryMap.containsKey(record.value())) {
                        updatedCount = cusCountryMap.get(record.value()) + 1;
                    }
                    cusCountryMap.put(record.value(), updatedCount);

                    System.out.println(record.value());
                    consumer.commitAsync();
                }
            }
        } catch (Exception e) {

        } finally {
            try {
                consumer.commitSync();
            } finally {
                consumer.close();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55