kafka的原理

生产-消费流程：

数据从生产-消费-提交offset过程，分以下几个阶段来进行。

生产者：

生产者是一个向kafkaCluster 发布记录的客户端，生产者是线程安全的，跨线程共享单个生产者实践通常比具有多个实例更快。

必要条件：

 生产者要进行生产数据到kafkaCluster中，必要条件有以下三个：

1.地址

bootstrap.servers=node01:9092

2.序列化 key.serializer=org.apache.kafka.common.serialization.StringSerializer value.serializer=org.apache.kafka.common.serialization.StringSerializer

3.主题（topic）: 需要制定具体的某个topic（order）即可。

生产者（Producer） 写数据：
写数据流程图：

流程描述：

总体流程：

1.  Producer连接任意活着的Broker，请求指定Topic，Partion的Leader元数据信息，然后直接与对应的Broker直接连接，发布数据。
2. 开放分区接口（生产者数据分发策略）

         2.1.用户可以指定分区函数，是的消息可以根据Key，发送到指定Partition中

         2.2 Kafka在数据生产的时候，有一个数据分发策略，默认的情况使用DefaultPartitioner.class类，这个类中定义数据分发的策略

         2.3 如果是用户指定了partition ，生产就不会调用DefaultPartitioner.partition()方法

         2.4 当用户指定key，使用hash算法，如果key一直不变，同一个key算出来的hash值是个固定值，如果是固定值，这种hash 取模就没有意义

         Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions

         2.5 当用即没有指定partition也没有key

         2.6 数据分发策略的时候，可以指定数据发往哪个partition。当ProducerRecord 的构造参数中有partition 的时候，就可以发送到对应partition上。

 

生产者数据分发策略：

生产者数据分发策略有如下四种：（总的来说就是调用一个方法，参数不同而已）

//可根据主题和内容发送
public ProducerRecord(String topic, V value)
//根据主题，key、内容发送
public ProducerRecord(String topic, K key, V value)
//根据主题、分区、key、内容发送
public ProducerRecord(String topic, Integer partition, K key, V value)
//根据主题、分区、时间戳、key，内容发送
public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V value)

a. 可根据主题和内容发送：

   

Producer<String, String> producer = new KafkaProducer<String, String>(props);
//可根据主题和内容发送
producer.send(new ProducerRecord<String, String>("my-topic","具体的数据"));

b. 根据主题 、 key 、 内容发送：

Producer<String, String> producer = new KafkaProducer<String, String>(props);
//可根据主题、key、内容发送
producer.send(new  ProducerRecord<String,  String>("my-topic","key","具体的数据"));

c. 根据主题 . 分区  key 内容发送

Producer<String, String> producer = new KafkaProducer<String, String>(props);
//可根据主题、分区、key、内容发送
producer.send(new  ProducerRecord<String,  String>("my-topic",1,"key","具体的数据"));

d. 根据主题  分区  时间戳  key   内容发送：

Producer<String, String> producer = new KafkaProducer<String, String>(props);
//可根据主题、分区、时间戳、key、内容发送
producer.send(new  ProducerRecord<String,  String>("my-topic",1,12L,"key","具体的数据"));

消费者：
 

消费者是一个从kafkaCluster 中消费数据的一个客户端，该客户端还可以处理kafka broker 中故障问题，并且可以适应在集群内的迁移的topic分区，该客户端还允许消费者

组使用消费者来进行负载均衡。

消费者维持一个TCP 长的连接来获取数据，使用后未能正常关闭这些消费者问题就会出现，因此消费者不是线程安全的。

必要条件：

消费者要从kafkaCluster 进行消费数据，必要条件有以下四个：

1.地址
bootstrap.servers=node01:9092

2.序列化

key.serializer=org.apache.kafka.common.serialization.StringSerializer value.serializer=org.apache.kafka.common.serialization.StringSerializer

3.主题（topic） 需要制定具体的某个topic （order）即可

4.消费组 group.id=test

消费者代码--自动提交offset值：

/**
* 消费订单数据--- javaben.tojson
*/
public class OrderConsumer {
    public static void main(String[] args) {
// 1\连接集群
Properties props = new Properties(); props.put("bootstrap.servers", "hadoop-01:9092"); props.put("group.id", "test");

//以下两行代码 ---消费者自动提交offset值 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");
KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>
(props);
//		 2、发送数据 发送数据需要，订阅下要消费的topic。	order kafkaConsumer.subscribe(Arrays.asList("order")); while (true) {
ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(100);// jdk queue offer插入、poll获取元素。 blockingqueue put插入原生， take获取元素
for (ConsumerRecord<String, String> record : consumerRecords) { System.out.println("消费的数据为：" + record.value());
            }
        }
    }
}

消费者代码--手动提交offset

如果Consumer 在获取数据后，需要加入处理，数据完毕后才确认offset ，需求程序来控制offset的确认？关闭自动提交确认选项

props.put("enable.auto.commit",  "false");

手动提交offset

  kafkaConsumer.commitSync();

完整代码：

Properties props = new Properties(); 
props.put("bootstrap.servers", "localhost:9092"); 
props.put("group.id", "test");
//关闭自动提交确认选项
props.put("enable.auto.commit", "false"); 
props.put("key.deserializer",
"org.apache.kafka.common.serialization.StringDeserializer"); 
props.put("value.deserializer",
"org.apache.kafka.common.serialization.StringDeserializer"); 
KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props); consumer.subscribe(Arrays.asList("foo",  "bar"));
final int minBatchSize = 200;
List<ConsumerRecord<String, String>> buffer = new ArrayList<>(); 
while (true) {
ConsumerRecords<String, String> records = consumer.poll(100);
 for (ConsumerRecord<String, String> record : records) {
buffer.add(record);
}
if (buffer.size() >= minBatchSize) { insertIntoDb(buffer);
// 手动提交offset值
consumer.commitSync(); 
buffer.clear();
    }
}

消费者代码--完成处理每个分区中的记录后提交偏移量：

上面的示例使用commitSync将所有已接收的记录标记为已提交。 在某些情况下，您可能希望通过明确指定偏移量 来更好地控制已提交的记录。    在下面的示例中，我们在完成处理每个分区中的记录后提交偏移量。

try {
while(running) {
ConsumerRecords<String, String> records = consumer.poll(Long.MAX_VALUE); 
for (TopicPartition partition : records.partitions()) {
List<ConsumerRecord<String, String>> partitionRecords = records.records(partition);
for (ConsumerRecord<String, String> record : partitionRecords) { System.out.println(record.offset() + ": " + record.value());
}
long lastOffset = partitionRecords.get(partitionRecords.size() -1).offset();
consumer.commitSync(Collections.singletonMap(partition, new OffsetAndMetadata(lastOffset + 1)));
        }
    }
} finally { consumer.close();}

 

注意事项：

提交的偏移量应始终是应用程序将读取的下一条消息的偏移量。 因此，在调用commitSync（偏移量）时，应该 在最后处理的消息的偏移量中添加一个

消费者代码-使用消费者消费指定分区的数据：

1.如果进程正在维护与该分区关联的某种本地状态（如本地磁盘上的键值存储），那么它应该只获取它在磁盘上维护的分区的记录

2.如果进程本身具有高可用性，并且如果失败则将重新启动，（可能使用YARN，Mesos,或者AWS工具等集群管理框架，或作为流处理框架的一部分）。这种情况下Kafka不需要检测故障

并重新分配分区，因为消耗过程将在另一台机器上重新启动

 Properties props = new Properties(); props.put("bootstrap.servers","localhost:9092"); props.put("group.id","test"); 
        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");
         KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        //consumer.subscribe(Arrays.asList("foo",  "bar"));

           //手动指定消费指定分区的数据---start 
        String topic = "foo";
        TopicPartition partition0 = new TopicPartition(topic, 0);
        TopicPartition partition1 = new TopicPartition(topic, 1); consumer.assign(Arrays.asList(partition0,partition1));
    //手动指定消费指定分区的数据---end
    while(true)
    {
        ConsumerRecords<String, String> records = consumer.poll(100);
        for (ConsumerRecord<String, String> record : records)
            System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
    }

注意事项： 

1.要使用此模式，您只需要使用的分区的完整列表调用assign(Collection) , 而不是使用subscribe 订阅主题

2.主题与分区订阅只能二选一