Kafka同步提交和异步提交

转载

数据解码者 2024-12-27 07:39:57

文章标签 Kafka同步提交和异步提交大数据 kafka 消息队列数据 文章分类 架构后端开发

文章目录

前言
1.定义
2.Kafka基本架构
3.Kafka命令行操作
4.Kafka工作流程
5.topic的存储架构
6.index文件和log文件详解
7.分区
8.数据的可靠性（副本）
9.ISR
10.ack应答机制
11.故障处理
12.实现Exactly Once
13.Kafka消费者方式
14.offset的维护
15.Kafka高速读写数据
16.Zookeeper在Kafka中的作用
17.选举流程
18.KafkaProducerApi原理
19.Producer API
20.Consumer API
21.数据漏消费和重复消费分析
22.自定义存储offset
23.自定义拦截器
24.拦截器案例
25.Flume对接Kafka
26.Kafka监控
总结

前言

本文分享本菜鸟的Kafka学习笔记，Kafka作为现在比较火热的消息队列，学习Kafka还是相当有意义的。有任何问题都可以与本菜鸟讨论、学习。一起学习，一起进步。
本菜鸟QQ：599903582
笨鸟先飞，熟能生巧。
比心心~

提示：以下是本篇文章正文内容，下面案例可供参考

1.定义

Kafka是一个分布式的基于发布/订阅模式的消息队列,主要应用于数据实时处理领域.

消息队列的两种模式:

点对点模式:(一对一,消费者主动拉取数据,消息收到后消息清除)
发布/订阅模式:(一对多,消费者消费数据之后不会清除消息)

每个partition对应一个consumer.

2.Kafka基本架构

Kafka同步提交和异步提交_大数据

Producer:消息生产者
Consumer:消息消费者
Consumer Group:消费者组,有多个consumer组成
Broker:一台服务器就是一个broker.
Topic:理解为一个队列,一个队列可以分为多个partition.
Replica:副本,故障时该节点上的partition数据不丢失,且Kafka依然能够继续工作.分为一个leader和若干follower
Leader:每个分区多个副本汇总的’主’,生产者发送数据的对象,以及消费者消费数据源的对象都是Leader.
Follower:每个分区多个副本中的’从’,实时从leader中同步数据,保持和Leader数据的同步,
注意：Leader故障时,某个Follwer会成为新的Leader.

3.Kafka命令行操作

查看当前服务器中的所有topic
bin/kafka-topics.sh --zookeeper hadoop102:2181 --list

创建topic
bin/kafka-topics.sh --zookeeper hadoop102:2181 --create --replication-factor 3 --partitions 1 --topic first
--topic 定义 topic名
--replication-factor  定义副本数
--partitions  定义分区数

启动kafka:
    编写脚本文件:kkstart.sh
 #!/bin/bash
for i in hadoop102 hadoop103 hadoop104
do
        echo "================           $i             ================"
        ssh $i 'source /etc/profile && /opt/module/kafka/bin/kafka-server-start.sh -daemon /opt/module/kafka/config/server.properties'
done



删除topic
    bin/kafka-topics.sh  --zookeeper hadoop102:2181 --delete --topic first
需要server.properties中设置delete.topic.enable=true否则只是标记删除。

发送消息:
    bin/kafka-console-producer.sh --broker-list hadoop102:9092 --topic first
    
消费消息:
    bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --from-beginning --topic first
    
    bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --from-beginning --topic first

查看某个Topic的详情
    bin/kafka-topics.sh --zookeeper hadoop102:2181 --describe --topic first

修改分区数:
    bin/kafka-topics.sh --zookeeper hadoop102:2181 --alter --topic first --partitions 6

4.Kafka工作流程

Kafka同步提交和异步提交_大数据_02

Kafka中信息是以topic进行分类的,生产者生产消息,消费者消费消息,都是面向topic的。

topic是逻辑上的概念,而partition是物理上的概念,每个partition对应一个log文件,该文件中存储的就是producer生产的数据.Producer生产的数据会被不断追加到该log文件末端,且每条数据都有自己的offset.消费者组中的每一个消费者,都会实时记录自己消费到哪个offset,一旦出错恢复,从上次的位置继续消费。

5.topic的存储架构

Kafka同步提交和异步提交_Kafka同步提交和异步提交_03

.index .log文件命名规则 : topic名称 + 分区序号
.index 文件存储大量的索引信息,文件中的元数据指向对应数据文件中的message的物理偏移地址
.log 文件存储大量的数据,(被序列化过的数据)

6.index文件和log文件详解

Kafka同步提交和异步提交_消息队列_04

offset与文件名进行比较,若是offset > 0 且 offset < 6,则在0000000000.index文件中进行 offset - 0,得到offset与第一个message的偏移量,然后通过偏移量找到.index文件中的元数据,然后根据元数据找到.log文件中的message文件;

7.分区

原因：1.方便在集群中拓展 2.可以提高并发

分区方式：需要将Producer发送的数据封装成一个ProducerRecord对象,然后再进行分区。

Kafka同步提交和异步提交_Kafka同步提交和异步提交_05

指明partition时,直接就用指定的partition分区. (容易造成人为的数据倾斜)
指明key,未知名partition,根据key的hash值与topic的partition数进行区域得到partition值.
没有指定partition和key,默认的第一次调用随机生成一个整数(后面每次调用在这个整数上自增),将这个值与topic可用的partition总数取余得到partition值,也就是常说的round-robin算法.

分区分配策略：

round robin:(顺序消费，按顺序每个消费者依次取一个)
range(): 分区数/consumer数 = 整数 …余数前几个分区放整数+ 1个，后面的放整数个;

8.数据的可靠性（副本）

Kafka同步提交和异步提交_kafka_06

Kafka采用第二种措施，在所有Follower同步完成，在发送ack。

9.ISR

Leader维护了一个动态的in-sync replica set (ISR)，意为和leader保持同步follower集合。当ISR中的follower完成数据的同步之后，leader就会给producer发送ack。如果follower长时间未向leader同步数据，则该follower将被踢出ISR，该时间阈值由replica.lag.time.max.ms参数设定。Leader发生故障之后，就会从ISR中选举新的leader。

10.ack应答机制

ack三个级别：

0 ： producer不等待broker的ack
1 ： producer等待broker的ack,partition的leader落盘成功后返回ack
-1 ： producer等待broker的ack,partition的leader和follower全部落盘才返回ack；如果在follower同步完成后,broker发送ack之前,leader故障,那么会造成数据重复.

11.故障处理

Kafka同步提交和异步提交_数据_07

1.Follower故障

follower发生故障后会被临时踢出ISR，待该follower恢复后，follower会读取本地磁盘记录的上次的HW，并将log文件高于HW的部分截取掉，从HW开始向leader进行同步。等该follower的LEO大于等于该Partition的HW，即follower追上leader之后，就可以重新加入ISR了。

2.Leader故障
leader发生故障之后，会从ISR中选出一个新的leader，之后，为保证多个副本之间的数据一致性，其余的follower会先将各自的log文件高于HW的部分截掉，然后从新的leader同步数据。

注意：这只能保证副本之间的数据一致性，并不能保证数据不丢失或者不重复。

12.实现Exactly Once

幂等性机制
使用时,只需将enable.idempotence属性设置为true，kafka自动将acks属性设为-1，并将retries属性设为Integer.MAX_VALUE

13.Kafka消费者方式

consumer采用pull(拉)模式从broker中读取数据

push(推)模式很难适应消费速率不同的消费者,因为消息发送速率有broker决定的.
pull模式的不足之处,如果kafka没有数据,消费者可能会陷入循环中,一直返回空数据.

14.offset的维护

Kafka 0.9版本之前，consumer默认将offset保存在Zookeeper中，从0.9版本开始，consumer默认将offset保存在Kafka一个内置的topic中，该topic为__consumer_offsets。

15.Kafka高速读写数据

顺序写磁盘
零复制计数

16.Zookeeper在Kafka中的作用

Kafka集群中有一个broker会被选举为Controller，负责管理集群broker的上下线，所有topic的分区副本分配和leader选举等工作。
Controller的管理工作都是依赖于Zookeeper的。

17.选举流程

Kafka同步提交和异步提交_Kafka同步提交和异步提交_08

Kafka同步提交和异步提交_消息队列_09

18.KafkaProducerApi原理

Kafka同步提交和异步提交_Kafka同步提交和异步提交_10

Kafka的producer发送消息采用的是异步发送的方式.

main线程
Sender线程

线程共享变量 RecordAccumulator;

main线程将消息发送到RecordAccumulator,Sender线程不断从RecordAccumulator中拉去信息发送到Kafka broker.

相关参数:

batch.size:只有数据积累到batch.size之后,Sender才会发送数据
linger.ms:如果数据迟迟没有达到batch.size,sender等待linger.time之后就会发送数据

19.Producer API

需要用到的类：

KafkaProducer:创建一个生产者对象,用来发送数据
ProducerConfig:获取所需的一系列配置参数
ProducerRecord:每条数据都要封装成一个ProducerRecord对象

//异步发送 API

public class CustomProducer {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者的应答机制,
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        //重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG,1);
        //设置传输批次的大小
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        //设置缓冲区的大小
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        //设置k-v的序列化方式
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<String, String>("first","message"+i));
        }
        producer.close();
    }
}

带回调函数的API:
回调函数会在producer收到ack时调用,为异步调用,该方法有两个参数,分别是RecordMetadata和Exception,如果Exception为null,说明消息发送成功,如果不为空,说明发送失败;

//带回调函数的 API
// 异步
public class CustomProducer {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者的应答机制,
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        //重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG,1);
        //设置传输批次的大小
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        //设置缓冲区的大小
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        //设置k-v的序列化方式
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<String, String>("first", "message" + i), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if(e == null){
                        System.out.println("success->" + recordMetadata.offset());
                    }else {
                        e.printStackTrace();
                    }
                }
            });
        }
        producer.close();
    }
}

同步发送API:
同步的意思就是,一条消息发送之后,会堵塞当前线程,直至返回ack

由于send方法返回的是一个Future对象,根据Futrue对象的特点,我们也可以实现同步发送的效果,只需在调用Future对象的get方法即可;

public class CustomProducer {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者的应答机制,
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        //重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG,1);
        //设置传输批次的大小
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        //设置缓冲区的大小
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        //设置k-v的序列化方式
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<String, String>("first", "message" + i)).get();
        }
        producer.close();
    }
}

20.Consumer API

Consumer消费数据时的可靠性是很容易保证的,因为数据在Kafka重视持久化的,故不用担心数据丢失问题.
由于consumer在消费过程中可能会出现断电宕机等故障,consumer回复后,需要从故障钱的位置继续消费,所以consumer需要实时记录自己消费到哪个offset,以便故障回复后继续消费.
所以offset的维护是Consumer消费数据是必须考虑的问题.

需要用到的类:

KafkaConsumer:需要创建一个消费者对象,用来消费对象
ConsumerConfig:获取所需的一系列系统配置参数
ConsumerRecord:每条数据都要封装成一个ConsumerRecord对象

自动提交offset的相关参数:
enable.auto.commit:是否开启自动提交offset功能
auto.commit.intervals.ms:自动提交offset 的时间间隔

//自动提交offset

public class CustomConsumer {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者组名
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //开启自动提交offset
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
        //设置自动上传的时间间隔
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        //设置Consumer中的反序列化方式
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //生成消费者对象
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String,String>(properties);
        //订阅topic
        consumer.subscribe(Arrays.asList("first"));
        while (true){
            //设置间隔时间,间隔一段时间进行一次拉取数据,获得ConsumerRecords对象
            ConsumerRecords<String, String> records = consumer.poll(100);
            //遍历records,进行消费
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record.offset() + "," + record.key() + "," + record.value());
            }
        }
    }
}

手动提交offset 的两种方法 :commitSnync(同步提交) commitAsync(异步提交)

相同点:都会把本次poll的一批数据最高的偏移量提交;
不同点: commitSync阻塞当前线程,一直到提交成功,并且会自动失败重试
commitAsync没有失败重试机制,故有可能提交失败.

//同步拉取

public class CustomConsumer {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者组名
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //开启自动提交offset
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");
        //设置自动上传的时间间隔
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        //设置Consumer中的反序列化方式
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //生成消费者对象
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String,String>(properties);
        //订阅topic
        consumer.subscribe(Arrays.asList("first"));
        while (true){
            // 设置间隔时间,间隔一段时间进行一次拉取数据,获得ConsumerRecords对象
            ConsumerRecords<String, String> records = consumer.poll(100);
            // 遍历records,进行消费
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record.offset() + "," + record.key() + "," + record.value());
            }
            // 同步提交,当前线程会阻塞直到offset提交成功
            consumer.commitSync();
        }
    }
}

//异步拉取

public class CustomConsumer {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者组名
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //开启自动提交offset
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");
        //设置自动上传的时间间隔
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        //设置Consumer中的反序列化方式
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //生成消费者对象
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String,String>(properties);
        //订阅topic
        consumer.subscribe(Arrays.asList("first"));
        while (true){
            //设置间隔时间,间隔一段时间进行一次拉取数据,获得ConsumerRecords对象
            ConsumerRecords<String, String> records = consumer.poll(100);
            //遍历records,进行消费
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record.offset() + "," + record.key() + "," + record.value());
            }
            //异步拉取
            consumer.commitAsync(new OffsetCommitCallback() {
                public void onComplete(Map<TopicPartition, OffsetAndMetadata> offsets, Exception e) {
                    if( e != null){
                        System.out.println("Commit failed for " + offsets);
                    }
                }
            });
        }
    }
}

21.数据漏消费和重复消费分析

无论是同步提交还是异步提交,都有可能会造成数据的漏消费或者重复消费.
先提交offset后消费的,有可能造成数据的楼消费; 而先消费后提交offset,有可能会造成数据重复消费.

22.自定义存储offset

当有新的消费者加入消费者组,已有的消费者退出消费者组或者所订阅的主题的分区发生变化,就会触发到分区的重新分配,重新分配的过程叫做Rebalance.
因此消费者要首先获取到自己被重新分配到的分区,并且定位到每个分区最近提交的offset 位置继续消费.
要实现自定义存储offset,需要借助ConsumerRebalanceListener.

// 自定义存储offset

public class CustomConsumer {
    // 用于存储offset
    private static Map<TopicPartition,Long> currentOffset = new HashMap<TopicPartition, Long>();

    public static void main(String[] args) {
        Properties properties = new Properties();
        //设置集群的映射地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        //设置消费者组名
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //开启自动提交offset
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");
        //设置自动上传的时间间隔
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        //设置Consumer中的反序列化方式
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //生成消费者对象
        final KafkaConsumer<String, String> consumer = new KafkaConsumer<String,String>(properties);
        //订阅topic
        consumer.subscribe(Arrays.asList("first"), new ConsumerRebalanceListener() {
            //该方法会在Rebalance之前调用
            public void onPartitionsRevoked(Collection<TopicPartition> collection) {
                commitOffset(currentOffset);
            }
            //该方法会在Rebalance之后调用
            public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
                currentOffset.clear();
                for (TopicPartition partition : partitions) {
                    consumer.seek(partition,getOffset(partition)); //定位到最近提交的offset位置继续消费
                }
            }
        });
        while (true){
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record.offset() + "," + record.key() + "," + record.value());
                currentOffset.put(new TopicPartition(record.topic(),record.partition()),record.offset())
            }
            commitOffset(currentOffset);
        }
    }
    // 获取某分区的最新offset
    private static long getOffset(TopicPartition partition) {
        return 0;
    }

    // 提交该消费者所有分区的offset
    private static void commitOffset(Map<TopicPartition, Long> currentOffset) {

    }

}

23.自定义拦截器

用于实现clients端的定制化控制逻辑.
对于producer而言,interceptor使得用户在消息发送前以及producer回调逻辑前有机会对消息做一些定制化需求.

实现的接口是:org.apache.kafka.clients.producer.ProducerInterceptor

定义的方法:

configure(configs):获取配置信息和初始化数据时调用

onSend(ProducerRecord):该方法封装进KafkaProducer.send方法中，即它运行在用户主线程中。Producer确保在消息被序列化以及计算分区前调用该方法。用户可以在该方法中对消息做任何操作，但最好保证不要修改消息所属的topic和分区，否则会影响目标分区的计算。

onAsknowledgement(RecordMetadata,Exception): 该方法会在消息从RecordAccumulator成功发送到Kafka Broker之后，或者在发送过程中失败时调用。并且通常都是在producer回调逻辑触发之前。onAcknowledgement运行在producer的IO线程中，因此不要在该方法中放入很重的逻辑，否则会拖慢producer的消息发送效率。

close():关闭interceptor，主要用于执行一些资源清理工作
如前所述，interceptor可能被运行在多个线程中，因此在具体实现时用户需要自行确保线程安全。另外倘若指定了多个interceptor，则producer将按照指定顺序调用它们，并仅仅是捕获每个interceptor可能抛出的异常记录到错误日志中而非在向上传递。这在使用过程中要特别留意。

24.拦截器案例

实现一个简单的双interceptor组成的拦截链。第一个interceptor会在消息发送前将时间戳信息加到消息value的最前部；第二个interceptor会在消息发送后更新成功发送消息数或失败发送消息数。

public class TimeStampPrependerInterceptor implements ProducerInterceptor<String, String> {
    @Override
    public void configure(Map<String, ?> configs) {

    }

    @Override
    public ProducerRecord onSend(ProducerRecord record) {
        return new ProducerRecord(
                record.topic(), record.partition(), record.timestamp(), record.key(), System.currentTimeMillis() + "," + record.value().toString());
    }

    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {

    }

    @Override
    public void close() {
    }
}

public class CounterInterceptor implements ProducerInterceptor<String, String> {

    private int errorCounter = 0;
    private int successCounter = 0;

    @Override
    public void configure(Map<String, ?> configs) {
    }

    @Override
    public ProducerRecord<String, String> onSend(ProducerRecord<String, String> record) {
        return record;
    }

    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
        if (exception == null) {
            successCounter++;
        } else {
            errorCounter++;
        }
    }

    @Override
    public void close() {
        // 保存结果
        System.out.println("Successful sent: " + successCounter);
        System.out.println("Failed sent: " + errorCounter);
    }
}

Properties props = new Properties();
props.put(...);
// 构建拦截链
List<String> interceptors = new ArrayList<>();
interceptors.add("huxi.test.producer.TimeStampPrependerInterceptor"); // interceptor 1
interceptors.add("huxi.test.producer.CounterInterceptor"); // interceptor 2
props.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, interceptors);
...
 
String topic = "test-topic";
Producer<String, String> producer = new KafkaProducer<>(props);
for (int i = 0; i < 10; i++) {
    ProducerRecord<String, String> record = new ProducerRecord<>(topic, "message" + i);
    producer.send(record).get();
}
 
// 一定要关闭producer，这样才会调用interceptor的close方法
producer.close();

25.Flume对接Kafka

# define
a1.sources = r1
a1.sinks = k1
a1.channels = c1

# source
a1.sources.r1.type = exec
a1.sources.r1.command = tail -F -c +0 /opt/module/datas/flume.log
a1.sources.r1.shell = /bin/bash -c

# sink
a1.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.k1.kafka.bootstrap.servers = hadoop102:9092,hadoop103:9092,hadoop104:9092
a1.sinks.k1.kafka.topic = first
a1.sinks.k1.kafka.flumeBatchSize = 20
a1.sinks.k1.kafka.producer.acks = 1
a1.sinks.k1.kafka.producer.linger.ms = 1

# channel
a1.channels.c1.type = memory
a1.channels.c1.capacity = 1000
a1.channels.c1.transactionCapacity = 100

# bind
a1.sources.r1.channels = c1
a1.sinks.k1.channel = c1

26.Kafka监控

1.Kafka Monitor
    https://github.com/linkedin/kafka-monitor/tree/0.11.x
2.Kafka Manager
    https://github.com/didi/kafka-manager

总结

提示：这里对文章进行总结：
本文分享了本菜鸟的Kafka学习笔记，内容有点多，查看时最好根据目录查看自己想要查询的部分。Kafka作为大数据组件中一个非常重要的消息队列，应该是每个大数据员工的必备技能。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：throttlestop调节风扇

下一篇：mes课程是什么

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯