自学kafka部分知识点汇总

最新推荐文章于 2023-05-12 17:06:24 发布

李白星河

最新推荐文章于 2023-05-12 17:06:24 发布

阅读量541

点赞数

分类专栏： kafka 大数据文章标签： kafka

本文链接：https://blog.csdn.net/CZXY18ji/article/details/105208227

版权

大数据同时被 2 个专栏收录

7 篇文章 0 订阅

订阅专栏

kafka

4 篇文章 0 订阅

订阅专栏

（Kafka阶段）
简答题：

1、Kafka生态系统四大角色，生产者(Producer)、kafka集群(Broker)、消费者(Consumer)、zookeeper
2、每个消费者都必须属于一个消费组，一个组内的消费者可以多个。
3、一个Topic可以有1到多个多个分区（Partition）
4、一个分区可以有1到多个segment。
5、每个segment可以有由一个log和一个index组成。
6、被复制的分区叫做主副本（Leader）,复制出来的叫做从副本（Follower）
7、生产者只往主副本写数据，消费者只在主副本拉取数据。
8、从副本只做数据备份，不做数据读写。
【红色字体表示隐藏知识点】
9、一个分区内的一条数据，只能被一个消费组内的一个消费者消费。
10、消费者的最大并发度由topic的分区数量决定
11、分区副本的数量必须小于等于broker的数量
12、一个topic内的多个分区，每个分区只是所有数据的一部分。所有分区的数据累加到一起是这个topic的全部数据。
13、zookeeper中记录了broker的id 、消费者消费数据的offset,消费者与partition的对应关系（ConsumerA—> Partition-0, ConsumerB—> Partition-1）

1、什么是kafka

是一个分布式，分区的，多副本的，多订阅者的消息发布订阅系统。

2、kafka的使用场景

应用耦合、异步处理、限流削峰、消息驱动的系统

3、 kafka优缺点

优点：可靠性强（分布式-分区-副本）、扩展性强（可伸缩）、性能高（数据读写）、耐用性强（数据持久化）、时效性强。
缺点：由于是批量发送，数据并非真正的实时。
仅支持同一分区内消息有序，无法实现全局消息有序；
有可能消息重复消费；
依赖zookeeper进行元数据管理。

4、Kafka架构（流程）

生产者、kafka集群、消费者、zookeeper

5、Kafka架构（API）

生产者、消费者、StreamAPI、ConnectAPI

6、Topic内部有哪些组成？

每个Topic包含一个或者多个Partition，一个partition当中存在多个segment文件段，每个segment分为两部分，.log文件和.index文件。

7、分区和消费组内的消费者之间的关系有哪些情况？

Partition = 消费任务的并发度=刚刚好，每个任务读取一个partition数据
Partition > 消费任务的并发度=有部分消费任务读取多个分区的数据
Partition < 消费任务的并发度=有部分消费任务空闲(可以创建多于分区的消费者数量)

8、分区数、消费者与读取效率之间的关系

分区数越多，同一时间可以有越多的消费者来进行消费，消费数据的速度就会越快，提高消费的性能

9、副本数与broker之间的关系

数据副本（包含本身）数一般情况下小于等于broker的个数

10、什么是主/从副本

被复制的分区叫做主副本（Leader）,复制出来的叫做从副本（Follower）

11 、主/从复本的作用是什么

主副本负责数据的读写。
从副本只做数据备份，不做数据读写。

12、 Lsr是什么？

ISR是一组与leaders完全同步的消息副本（包括leaders本身）。

13、生产者生产数据到kafka集群，数据到分区的方式

a)没有指定分区编号，没有指定key,时采用轮询方式存户数据
b)没有指定分区编号，指定key时，数据分发策略为对key求取hash值，这个值与分区数量取余，于数就是分区编号。
c)指定分区编号，所有数据输入到指定的分区内
d)自定义分区

14、 Consumer消费数据的流程

1、首先Consumer连接指定的Topic partition所在leader broker，使用折半/二分查找，先确定数据所在的segment。
2、确定在哪个segment后，使用确定的segment内的index文件找到数据具体的位置采用pull方式从kafkalogs中获取消息。

15、Kafka中的数据删除机制是什么？

1、时间：默认存储168小时（一周）
2、数据的大小：默认 -1 （不删除），可以自行设置。

16、Kafka如何保证数据不丢失

1、生产者如何保证数据不丢失？？通过ack 机制确保数据不丢失。
2、kafka集群如何保证数据不丢失？？通过数据副本保证数据不丢失。
3、消费者如何保证数据不丢失？？通过维护数据的offset 保证数据不丢失。

17、Kafka高性能的原因有哪里？

顺序读写、分区、批量发送、数据压缩

18、Kafka高效查询数据的有哪些原因

1、Kafka把topic中一个parition大文件分成多个小文件段，通过多个小文件段，就容易定期清除或删除已经消费完文件，减少磁盘占用。
2、通过索引信息可以快速定位message和确定response的最大大小。
3、通过index元数据全部映射到memory，可以避免segment file的IO磁盘操作。
4、通过索引文件稀疏存储，可以大幅降低index文件元数据占用空间大小。

19、如何从Kafka得到准确的信息(不是重读数据)?

在数据生产过程中避免重复。
在数据消耗期间避免重复。

20、Kafka的设计是什么样的呢？

Kafka将消息以topic为单位进行归纳将向Kafka topic发布消息的程序成为producers. 将预订topics并消费消息的程序成为consumer. Kafka以集群的方式运行，可以由一个或多个服务组成，每个服务叫做一个broker. producers通过网络将消息发送到Kafka集群，集群向消费者提供消息

21、数据传输的事物定义有哪三种？

1、最多一次:消息不会被重复发送，最多被传输一次，但也有可能一次不传输
可能会造成数据丢失。
3、最少一次: 消息不会被漏发送，最少被传输一次，但也有可能被重复传输.
可能会造成数据的重复消费。
3、精确的一次（Exactly once）: 不会漏传输也不会重复传输,每个消息都传输被一次而且仅仅被传输一次，这是大家所期望的

22、Kafka判断一个节点是否还活着有哪些条件？

1、节点必须可以维护和ZooKeeper的连接，Zookeeper通过心跳机制检查每个节点的连接
2、如果节点是个follower,他必须能及时的同步leader的写操作，延时不能太久

23、Kafka 与传统消息系统之间有哪些区别？

1、Kafka 持久化日志：这些日志可以被重复读取和无限期保留
2、Kafka 是一个分布式系统：它以集群的方式运行，可以灵活伸缩，在内部通过复制数据提升容错能力和高可用性
3、Kafka 支持实时的流式处理

24、Kafka创建Topic时将分区放置到不同的Broker的策略是什么？

前提：副本因子不能大于 Broker 的个数；
第一个分区（编号为0）的第一个副本放置位置是随机从 brokerList 选择的；
其他分区的第一个副本放置位置相对于第0个分区依次往后移。
例如：有5个 Broker，5个分区，假设第一个分区放在第四个 Broker 上，那么第二个分区将会放在第五个 Broker 上；第三个分区将会放在第一个 Broker 上；第四个分区将会放在第二个 Broker 上，第五个分区将会放在第三个 Broker 上；

25、Kafka新建的分区会在哪个目录下创建

若 log.dirs 参数只配置了一个目录，那么分配到各个 Broker 上的分区将在这个目录下创建文件夹用于存放数据。
若 log.dirs 参数配置了多个目录，那么 Kafka 会在含有分区目录总数最少的文件夹中创建新的分区目录，分区目录名为 Topic名+分区ID。注意（不是磁盘使用量最少的目录）

26、partition的数据如何保存到硬盘

topic中的多个partition以文件夹的形式保存到broker，每个分区序号从0递增，且消息有序 Partition文件下有多个segment（xxx.index，xxx.log） segment 文件里的大小和配置文件大小一致可以根据要求修改默认为1g 如果大小大于1g时，会滚动一个新的segment并且以上一个segment最后一条消息的偏移量命名

27、kafka的ack机制

request.required.acks有三个值 0 1 -1
0:生产者不会等待broker的ack，这个延迟最低但是存储的保证最弱当server挂掉的时候就会丢数据
1：服务端会等待ack值 leader副本确认接收到消息后发送ack但是如果leader挂掉后他不确保是否复制完成新leader也会导致数据丢失
-1：同样在1的基础上服务端会等所有的follower的副本受到数据后才会受到leader发出的ack，这样数据不会丢失

28、Kafka的消费者如何消费数据

消费者每次消费数据的时候，消费者都会记录消费的物理偏移量（offset）的位置等到下次消费时，他会接着上次位置继续消费。同时也可以按照指定的offset进行重新消费。

29、如何使kafka集群内的数据是有序的？

只创建一个分区。（但是实际这样会存在性能问题，具体业务具体分析后确认。）

30、Zookeeper汇总保留了哪些数据？

1、消费者提交的偏移量。
2、分区和消费者的所有者关
3、broker id

说明：leader检测、分布式同步、配置管理、识别新节点何时离开或连接、集群、节点实时状态

31、kafka consumer 什么情况会触发再平衡reblance?

1、一旦消费者加入或退出消费组，导致消费组成员列表发生变化，消费组中的所有消费者都要执行再平衡。
2、订阅主题分区发生变化，所有消费者也都要再平衡。

32、描述下kafka consumer 再平衡步骤?

1、关闭数据拉取线程，清空队列和消息流，提交偏移量；
2、释放分区所有权，删除zk中分区和消费者的所有者关系；
3、将所有分区重新分配给每个消费者，每个消费者都会分到不同分区；
4、将分区对应的消费者所有关系写入ZK，记录分区的所有权信息；
5、重启消费者拉取线程管理器，管理每个分区的拉取线程。

33手动提交offset有什么好处？？

使更新offset更及时，避免因offset更新不及时导致重复消费数据的问题。

34、为什么kafka中的数据需要定期删除或合并？

Kafka只用于做数据的临时存储、临时缓冲，不是永久存储（永久性存储使用HDFS）。

KafkaJavaAPI
课后练习10题

以下kafka集群的节点分别是node01,node02,node03

1、在kafka集群中创建student主题副本为2个，分区为3个

生产者设置：
设置key的序列化为  org.apache.kafka.common.serialization. StringSerializer
设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
其他都是默认设置
消费者设置：
消费者组id为test
设置key的序列化为org.apache.kafka.common.serialization. StringDeserializer
设置value的序列化为org.apache.kafka.common.serialization. StringDeserializer
其他都是默认设置
模拟生产者，请写出代码向student主题中生产数据0-99
模拟消费者，请写出代码把student主题中的数据0-99消费掉，打印输出到控制台


private static final String TOPIC="student";
    private static final String BROKER_LIST="node01:9092,node02:9092,node03:9092";
    //实例化生产者对象
    private static KafkaProducer<String,String> producer = null;
   // 实例化消费者对象
    private static KafkaConsumer<String,String> kafkaConsumer = null;

    /**
     * 生产者设置：
     */
     static{
         Properties configs = initConfig();
         producer = new KafkaProducer<String, String>(configs);
     }
    private static Properties initConfig(){
        Properties props= new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        return props;
    }
    /**
     *  消费者设置：
      */
    static {
        Properties properties = initConfig1();
        kafkaConsumer = new KafkaConsumer<String, String>(properties);
        kafkaConsumer.subscribe(Arrays.asList(TOPIC));
    }

    private static Properties initConfig1(){
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        //消费组id
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //序列化信息
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        return properties;
    }
    /*
    生产者代码
     */
    @Test
    public void Producer(){
        //bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 2 --partitions 3 --topic student
//        模拟生产者
        try {
            for (int i = 0; i <100; i++) {
                //当没有指定分区号和key时使用轮训策略存储数据
                ProducerRecord producerRecord = new ProducerRecord(TOPIC,""+i);
                producer.send(producerRecord);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            producer.close();
        }
    }
    @Test
    public void consumer(){
        // 模拟消费者
        try {
            while (true){
                //拉取数据，并输出
                //获取所有数据
                ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(1000);
                //遍历所有数据
                for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                    //获取一条数据内的信息
                    try {
                        System.out.println("数据是"+consumerRecord.value()+"偏移量是"+consumerRecord.offset());
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            kafkaConsumer.close();
        }

    }

2、在kafka集群中创建teacher主题副本为2个，分区为3个

生产者设置：
消息确认机制 为all
重试次数 为2
批量处理消息字节数 为16384
设置缓冲区大小 为 33554432
设置每条数据生产延迟1ms
设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
数据分发策略为默认轮询方式

消费者设置：
消费者组id为test
设置自动提交偏移量
设置自动提交偏移量的时间间隔
设置 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费

auto.offset.reset

//earliest: 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
//latest: 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据
//none : topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常

设置key的序列化为org.apache.kafka.common.serialization. StringDeserializer
设置value的序列化为org.apache.kafka.common.serialization. StringDeserializer

模拟生产者，请写出代码向teacher主题中生产数据bigdata0-bigdata99
模拟消费者，请写出代码把teacher主题中的数据bigdata0-bigdata99消费掉 ，打印输出到控制台

private static final String TOPIC="teacher";
    private static final String BROKER_LIST="node01:9092,node02:9092,node03:9092";
    //实例化生产者对象
    private static KafkaProducer<String,String> producer = null;
    // 实例化消费者对象
    private static KafkaConsumer<String,String> kafkaConsumer = null;

    /*
     * 	生产者设置：
     */
    static{
        Properties configs = initConfig();
        producer = new KafkaProducer<String, String>(configs);
    }
    private static Properties initConfig(){
        Properties props= new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        props.put(ProducerConfig.ACKS_CONFIG,"all");
        props.put(ProducerConfig.RETRIES_CONFIG,2);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        props.put(ProducerConfig.LINGER_MS_CONFIG,1);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        return props;
    }
    /**
     * 	消费者设置：
     */
    static {
        Properties properties = initConfig1();
        kafkaConsumer = new KafkaConsumer<String, String>(properties);
        kafkaConsumer.subscribe(Arrays.asList(TOPIC));
    }

    private static Properties initConfig1(){
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        properties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        return properties;
    }
    /*
    生产者代码
     */
    @Test
    public void Producer(){
        //bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 2 --partitions 3 --topic teacher
//        模拟生产者
        try {
            for (int i = 0; i <100; i++) {
                //当没有指定分区号和key时使用轮训策略存储数据
                ProducerRecord producerRecord = new ProducerRecord(TOPIC,"bigdata"+i);
                producer.send(producerRecord);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            producer.close();
        }
    }
    @Test
    public void consumer(){
        // 模拟消费者
        try {
            while (true){
                //拉取数据，并输出
                //获取所有数据
                ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(1000);
                //遍历所有数据
                for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                    //获取一条数据内的信息
                    try {
                        System.out.println("数据是"+consumerRecord.value()+"偏移量是"+consumerRecord.offset());
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            kafkaConsumer.close();
        }

    }

3、在kafka集群中创建title主题副本为2个，分区为3个

生产者设置：
消息确认机制 为all
重试次数 为1
批量处理消息字节数 为16384
设置缓冲区大小 为 33554432
设置每条数据生产延迟1ms
设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
数据分发策略为指定数据key为title,分发到同一个分区中

消费者设置：
消费者组id为test
设置自动提交偏移量
设置自动提交偏移量的时间间隔
设置 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据
设置key的序列化为org.apache.kafka.common.serialization. StringDeserializer
设置value的序列化为org.apache.kafka.common.serialization. StringDeserializer

模拟生产者，请写出代码向title主题中生产数据kafka0-kafka99
模拟消费者，请写出代码把title主题中的数据kafka0-kafka99消费掉 ，打印输出到控制台

private static final String TOPIC="title";
    private static final String BROKER_LIST="node01:9092,node02:9092,node03:9092";
    //实例化生产者对象
    private static KafkaProducer<String,String> producer = null;
    // 实例化消费者对象
    private static KafkaConsumer<String,String> kafkaConsumer = null;

    /*
     *
     * 生产者设置：
     *消息确认机制 为all
     *重试次数 为1
     *批量处理消息字节数 为16384
     *设置缓冲区大小 为 33554432
     *设置每条数据生产延迟1ms
     *设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
     *设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
     *数据分发策略为指定数据key为title,分发到同一个分区中
     */
    static{
        Properties configs = initConfig();
        producer = new KafkaProducer<String, String>(configs);
    }
    private static Properties initConfig(){
        Properties props= new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        props.put(ProducerConfig.ACKS_CONFIG,"all");
        props.put(ProducerConfig.RETRIES_CONFIG,1);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        props.put(ProducerConfig.LINGER_MS_CONFIG,1);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        return props;
    }
    /**
     * 	消费者组id为test
     * 	设置自动提交偏移量
     * 	设置自动提交偏移量的时间间隔
     * 	设置 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据
     * 	设置key的序列化为org.apache.kafka.common.serialization. StringDeserializer
     * 	设置value的序列化为org.apache.kafka.common.serialization. StringDeserializer
     */
    static {
        Properties properties = initConfig1();
        kafkaConsumer = new KafkaConsumer<String, String>(properties);
        kafkaConsumer.subscribe(Arrays.asList(TOPIC));
    }

    private static Properties initConfig1(){
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        properties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        return properties;
    }
    /*
    生产者代码
     */
    @Test
    public void Producer(){
//        1、在kafka集群中创建teacher主题 副本为2个，分区为3个
        //bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 2 --partitions 3 --topic teacher
//                其他都是默认设置
//        模拟生产者，请写出代码向student主题中生产数据bigdata0-bigdata99
        //2、通过实例发送数据到kafka集群
        try {
            for (int i = 0; i <100; i++) {
                //数据分发策略为指定数据key为title,分发到同一个分区中
                ProducerRecord producerRecord = new ProducerRecord(TOPIC,"title","kafka"+i);
                producer.send(producerRecord);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            producer.close();
        }
    }
    @Test
    public void consumer(){
        // 模拟消费者，请写出代码把student主题中的数据0-99消费掉，打印输出到控制台
        try {
            while (true){
                //拉取数据，并输出
                //获取所有数据
                ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(1000);
                //遍历所有数据
                for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                    //获取一条数据内的信息
                    try {
                        System.out.println("数据是"+consumerRecord.value()+"偏移量是"+consumerRecord.offset());
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            kafkaConsumer.close();
        }

    }

4、在kafka集群中创建title主题副本为2个，分区为3个

生产者设置：
消息确认机制 为all
重试次数 为2
批量处理消息字节数 为16384
设置缓冲区大小 为 33554432
设置每条数据生产延迟1ms
设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
数据分发策略为指定分区2，把数据发送到指定的分区中

消费者设置：
消费者组id为test
设置自动提交偏移量
设置自动提交偏移量的时间间隔
设置 topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常
设置key的序列化为org.apache.kafka.common.serialization. StringDeserializer
设置value的序列化为org.apache.kafka.common.serialization. StringDeserializer

模拟生产者，请写出代码向title主题中生产数据test0-test99
模拟消费者，请写出代码把title主题中的数据test0-test99消费掉 ，打印输出到控制台

private static final String TOPIC="kafka";
    private static final String BROKER_LIST="node01:9092,node02:9092,node03:9092";
    //实例化生产者对象
    private static KafkaProducer<String,String> producer = null;
    // 实例化消费者对象
    private static KafkaConsumer<String,String> kafkaConsumer = null;

    /*
     *	消息确认机制 为all
	 * 重试次数 为2
	 * 批量处理消息字节数 为16384
	 * 设置缓冲区大小 为 33554432
	 * 设置每条数据生产延迟1ms
	 * 设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
	 * 设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
	 * 数据分发策略为指定分区2，把数据发送到指定的分区中
     */
    static{
        Properties configs = initConfig();
        producer = new KafkaProducer<String, String>(configs);
    }
    private static Properties initConfig(){
        Properties props= new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        props.put(ProducerConfig.ACKS_CONFIG,"all");
        props.put(ProducerConfig.RETRIES_CONFIG,2);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        props.put(ProducerConfig.LINGER_MS_CONFIG,1);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        return props;
    }
    /**
     * 	消费者设置：
     * 	消费者组id为test
     * 	设置自动提交偏移量
     * 	设置自动提交偏移量的时间间隔
     * 	设置 topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常
     * 	设置key的序列化为org.apache.kafka.common.serialization. StringDeserializer
     * 	设置value的序列化为org.apache.kafka.common.serialization. StringDeserializer
     */
    static {
        Properties properties = initConfig1();
        kafkaConsumer = new KafkaConsumer<String, String>(properties);
        TopicPartition topicPartition = new TopicPartition(TOPIC,2);
        kafkaConsumer.assign(Arrays.asList(topicPartition));
        //！！！！！！！Caused by: java.lang.IllegalStateException: Subscription to topics, partitions and pattern are mutually exclusive
        //从异常信息可以看出订阅的主题和分区模式有冲突
//        kafkaConsumer.subscribe(Arrays.asList(TOPIC));
    }

    private static Properties initConfig1(){
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        properties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        return properties;
    }
    /*
    生产者代码
     */
    @Test
    public void Producer(){
//        1、在kafka集群中创建teacher主题 副本为2个，分区为3个
        //bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 2 --partitions 3 --topic teacher
//                其他都是默认设置
//        模拟生产者，请写出代码向student主题中生产数据bigdata0-bigdata99
        //2、通过实例发送数据到kafka集群
        try {
            for (int i = 0; i <100; i++) {
                //数据分发策略为指定数据key为title,分发到同一个分区中
                ProducerRecord producerRecord = new ProducerRecord(TOPIC,"kafka"+i);
                producer.send(producerRecord);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            producer.close();
        }
    }
    @Test
    public void consumer(){
        // 模拟消费者，请写出代码把student主题中的数据0-99消费掉，打印输出到控制台
        try {
            while (true){
                //拉取数据，并输出
                //获取所有数据
                ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(100);
                //获取每个分区
                Set<TopicPartition> partitions = consumerRecords.partitions();
                //遍历每个分区
                for (TopicPartition partition : partitions) {
                    //获取分区的数据的载体
                    List<ConsumerRecord<String, String>> records = consumerRecords.records(partition);
                    //获取每个数据
                    for (ConsumerRecord<String, String> record : records) {
                        System.out.println(record.value()+  "    "+record.partition());
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            kafkaConsumer.close();
        }

    }

5、在kafka集群中创建order主题副本为2个，分区为3个

生产者设置：
消息确认机制 为all
重试次数 为1
批量处理消息字节数 为16384
设置缓冲区大小 为 33554432
设置每条数据生产延迟1ms
设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
数据分发策略为自定义，请把生产的数据100以内的数据分发到分区0中，100-200以内的数据分发到分区1中，200-300内的数据分发到分区2中

消费者设置：
消费者组id为test
设置自动提交偏移量
设置自动提交偏移量的时间间隔
设置当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
设置key的序列化为org.apache.kafka.common.serialization. StringDeserializer
设置value的序列化为org.apache.kafka.common.serialization. StringDeserializer

模拟生产者，请写出代码向title主题中生产数据0-299
模拟消费者，请写出代码把title主题中的数据0-299消费掉 ，打印输出到控制台


private static final String TOPIC="order";
    private static final String BROKER_LIST="node01:9092,node02:9092,node03:9092";
    //实例化生产者对象
    private static KafkaProducer<String,String> producer = null;
    // 实例化消费者对象
    private static KafkaConsumer<String,String> kafkaConsumer = null;

    /*
     *生产者设置：
	 *消息确认机制 为all
	 *重试次数 为1
	 *批量处理消息字节数 为16384
	 *设置缓冲区大小 为 33554432
	 *设置每条数据生产延迟1ms
	 *设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
	 *设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
	 *数据分发策略为自定义，请把生产的数据100以内的数据分发到分区0中，100-200以内的数据分发到分区1中，200-300内的数据分发到分区2中
     */
    static{
        Properties configs = initConfig();
        producer = new KafkaProducer<String, String>(configs);
    }
    private static Properties initConfig(){
        Properties props= new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        props.put(ProducerConfig.ACKS_CONFIG,"all");
        props.put(ProducerConfig.RETRIES_CONFIG,1);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        props.put(ProducerConfig.LINGER_MS_CONFIG,1);
        props.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"com.czxy.homework.ProducerPartition");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        return props;
    }
    /**
     * 	消费者设置：
     * 	消费者组id为test
     * 	设置自动提交偏移量
     * 	设置自动提交偏移量的时间间隔
     * 	设置当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
     * 	设置key的序列化为org.apache.kafka.common.serialization. StringDeserializer
     * 	设置value的序列化为org.apache.kafka.common.serialization. StringDeserializer
     */
    static {
        Properties properties = initConfig1();
        kafkaConsumer = new KafkaConsumer<String, String>(properties);
//        kafkaConsumer.assign(Arrays.asList(topicPartition1,topicPartition2));
        //！！！！！！！Caused by: java.lang.IllegalStateException: Subscription to topics, partitions and pattern are mutually exclusive
        //从异常信息可以看出订阅的主题和分区模式有冲突
        kafkaConsumer.subscribe(Arrays.asList(TOPIC));
    }

    private static Properties initConfig1(){
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        properties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        return properties;
    }
    /*
    生产者代码
     */
    @Test
    public void Producer(){

//        1、在kafka集群中创建teacher主题 副本为2个，分区为3个
        //bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 2 --partitions 3 --topic order
//                其他都是默认设置
//        模拟生产者，请写出代码向student主题中生产数据bigdata0-bigdata99
        //2、通过实例发送数据到kafka集群
        //        模拟生产者，请写出代码向title主题中生产数据0-299
        try {
            for (int i = 0; i <300; i++) {
                //数据分发策略为指定数据key为title,分发到同一个分区中
                ProducerRecord producerRecord = new ProducerRecord(TOPIC,""+i,""+i);
                producer.send(producerRecord);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            producer.close();
        }
    }
    @Test
    public void consumer(){
        // 模拟消费者，请写出代码把title主题中的数据0-299消费掉 ，打印输出到控制台
        try {
            while (true){
                //拉取数据，并输出
                //获取所有数据
                ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(100);
                //获取每个分区
                Set<TopicPartition> partitions = consumerRecords.partitions();
                //遍历每个分区
                for (TopicPartition partition : partitions) {
                    //获取分区的数据的载体
                    List<ConsumerRecord<String, String>> records = consumerRecords.records(partition);
                    //获取每个数据
                    for (ConsumerRecord<String, String> record : records) {
                        System.out.println(record.value()+  "    "+record.partition());
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            kafkaConsumer.close();
        }

    }

/*
实现自定义分区
 */
public class ProducerPartition implements Partitioner {
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {

        /*
        自己编写分区原则
         */
        int partition = 0;
        int index = Integer.parseInt(new String(keyBytes));
        if(index<100){
            partition = 0;
        }else if(index<200){
            partition = 1;
        }else{
            partition = 2;
        }
        return partition;

    }

    @Override
    public void close() {

    }

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

    }
}

6、在kafka集群中创建18BD-10主题副本为2个，分区为3个

生产者设置：
消息确认机制 为all
重试次数 为2
批量处理消息字节数 为16384
设置缓冲区大小 为 33554432
设置每条数据生产延迟1ms
设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
数据分发策略为指定分区2，把数据发送到指定的分区中

消费者设置：
消费者组id为test
设置自动提交偏移量
设置自动提交偏移量的时间间隔
设置 topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常
设置key的反序列化为org.apache.kafka.common.serialization.StringDeserializer
设置value的反序列化为org.apache.kafka.common.serialization.StringDeserializer
消费指定分区2中的数据

模拟生产者，请写出代码向18BD-10主题中生产数据test0-test99
模拟消费者，请写出代码把18BD-10主题中的2号分区的数据消费掉 ，打印输出到控制台

private static final String TOPIC="18BD-10";
    private static final String BROKER_LIST="node01:9092,node02:9092,node03:9092";
    //实例化生产者对象
    private static KafkaProducer<String,String> producer = null;
    // 实例化消费者对象
    private static KafkaConsumer<String,String> kafkaConsumer = null;

    /*
     *	生产者设置：
	 * 消息确认机制 为all
	 * 重试次数 为2
	 * 批量处理消息字节数 为16384
	 * 设置缓冲区大小 为 33554432
	 * 设置每条数据生产延迟1ms
	 * 设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
	 * 设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
	 * 数据分发策略为指定分区2，把数据发送到指定的分区中
     */
    static{
        Properties configs = initConfig();
        producer = new KafkaProducer<String, String>(configs);
    }
    private static Properties initConfig(){
        Properties props= new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        props.put(ProducerConfig.ACKS_CONFIG,"all");
        props.put(ProducerConfig.RETRIES_CONFIG,2);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        props.put(ProducerConfig.LINGER_MS_CONFIG,1);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        return props;
    }
    /**
     * 	消费者设置：
     * 	消费者组id为test
     * 	设置自动提交偏移量
     * 	设置自动提交偏移量的时间间隔
     * 	设置 topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常
     * 	设置key的反序列化为org.apache.kafka.common.serialization.StringDeserializer
     * 	设置value的反序列化为org.apache.kafka.common.serialization.StringDeserializer
     * 	消费指定分区2中的数据
     */
    static {
        Properties properties = initConfig1();
        kafkaConsumer = new KafkaConsumer<String, String>(properties);
        TopicPartition topicPartition = new TopicPartition(TOPIC,2);
        kafkaConsumer.assign(Arrays.asList(topicPartition));
        //！！！！！！！Caused by: java.lang.IllegalStateException: Subscription to topics, partitions and pattern are mutually exclusive
        //从异常信息可以看出订阅的主题和分区模式有冲突
//        kafkaConsumer.subscribe(Arrays.asList(TOPIC));
    }

    private static Properties initConfig1(){
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        properties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        return properties;
    }
    /*
    生产者代码
     */
    @Test
    public void Producer(){
//        1、在kafka集群中创建teacher主题 副本为2个，分区为3个
        //bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 2 --partitions 3 --topic teacher
//                其他都是默认设置
//        模拟生产者，请写出代码向18BD-10主题中生产数据test0-test99
        //2、通过实例发送数据到kafka集群
        try {
            for (int i = 0; i <100; i++) {
                //数据分发策略为指定数据key为title,分发到同一个分区中
                ProducerRecord producerRecord = new ProducerRecord(TOPIC,""+i,"test"+i);
                producer.send(producerRecord);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            producer.close();
        }
    }
    @Test
    public void consumer(){
        // 模拟消费者，请写出代码把18BD-10主题中的2号分区的数据消费掉 ，打印输出到控制台
        try {
            while (true){
                //拉取数据，并输出
                //获取所有数据
                ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(100);
                //获取每个分区
                Set<TopicPartition> partitions = consumerRecords.partitions();
                //遍历每个分区
                for (TopicPartition partition : partitions) {
                    //获取分区的数据的载体
                    List<ConsumerRecord<String, String>> records = consumerRecords.records(partition);
                    //获取每个数据
                    for (ConsumerRecord<String, String> record : records) {
                        System.out.println(record.value()+  "    "+record.partition());
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            kafkaConsumer.close();
        }

    }

7、在kafka集群中创建18BD-20主题副本为2个，分区为3个

生产者设置：
消息确认机制 为all
重试次数 为1
批量处理消息字节数 为16384
设置缓冲区大小 为 33554432
设置每条数据生产延迟1ms
设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
数据分发策略为轮询方式发送到每个分区中
手动提交每条数据

消费者设置：
消费者组id为test
设置手动提交偏移量
设置key的反序列化为org.apache.kafka.common.serialization.StringDeserializer
设置value的反序列化为org.apache.kafka.common.serialization.StringDeserializer

模拟生产者，请写出代码向18BD-20主题中生产数据test0-test99
模拟消费者，请写出代码把18BD-20主题中的2号分区的数据消费掉 ，打印输出到控制台

 private static final String TOPIC="18BD-20";
    private static final String BROKER_LIST="node01:9092,node02:9092,node03:9092";
    //实例化生产者对象
    private static KafkaProducer<String,String> producer = null;
    // 实例化消费者对象
    private static KafkaConsumer<String,String> kafkaConsumer = null;

    /**
     *
     * 生产者设置：
	 * 消息确认机制 为all
	 * 重试次数 为1
	 * 批量处理消息字节数 为16384
	 * 设置缓冲区大小 为 33554432
	 * 设置每条数据生产延迟1ms
	 * 设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
	 * 设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
	 * 数据分发策略为轮询方式发送到每个分区中
	 * 手动提交每条数据
     */
    static{
        Properties configs = initConfig();
        producer = new KafkaProducer<String, String>(configs);
    }
    private static Properties initConfig(){
        Properties props= new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        props.put(ProducerConfig.ACKS_CONFIG,"all");
        props.put(ProducerConfig.RETRIES_CONFIG,1);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        props.put(ProducerConfig.LINGER_MS_CONFIG,1);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        return props;
    }
    /**
     * 		消费者组id为test
     * 	设置手动提交偏移量
     * 	设置key的反序列化为org.apache.kafka.common.serialization.StringDeserializer
     * 	设置value的反序列化为org.apache.kafka.common.serialization.StringDeserializer
     */
    static {
        Properties properties = initConfig1();
        kafkaConsumer = new KafkaConsumer<String, String>(properties);
        TopicPartition topicPartition = new TopicPartition(TOPIC,2);
        kafkaConsumer.assign(Arrays.asList(topicPartition));
//        kafkaConsumer.subscribe(Arrays.asList(TOPIC));
    }

    private static Properties initConfig1(){
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        return properties;
    }
    /*
    生产者代码
     */
    @Test
    public void Producer(){
//        1、在kafka集群中创建18BD-20主题 副本为2个，分区为3个
        //bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 2 --partitions 3 --topic 18BD-20
//                其他都是默认设置
//        模拟生产者，请写出代码向18BD-20主题中生产数据test0-test99
        //2、通过实例发送数据到kafka集群
        try {
            for (int i = 0; i <100; i++) {
                //当没有指定分区号和key时使用轮训（轮训分区）策略存储数据
                ProducerRecord producerRecord = new ProducerRecord(TOPIC,"test"+i);
                producer.send(producerRecord);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            producer.close();
        }
    }
    @Test
    public void consumer(){
        // 模拟消费者，请写出代码把18BD-20主题中的2号分区的数据消费掉 ，打印输出到控制台
        try {
            while (true){
                //拉取数据，并输出
                //获取所有数据
                ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(100);
                //获取每个分区
                Set<TopicPartition> partitions = consumerRecords.partitions();
                //遍历每个分区
                for (TopicPartition partition : partitions) {
                    //获取分区的数据的载体
                    List<ConsumerRecord<String, String>> records = consumerRecords.records(partition);
                    //获取每个数据
                    for (ConsumerRecord<String, String> record : records) {
                        System.out.println(record.value()+  "    "+record.partition());
                    }
                }
                kafkaConsumer.commitSync();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            kafkaConsumer.close();
        }

    }

8、在kafka集群中创建18BD-30主题副本为2个，分区为3个

生产者设置：
消息确认机制 为all
重试次数 为1
批量处理消息字节数 为16384
设置缓冲区大小 为 33554432
设置每条数据生产延迟1ms
设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
数据分发策略为轮询方式发送到每个分区中

消费者设置：
消费者组id为test
设置手动提交偏移量
设置key的反序列化为org.apache.kafka.common.serialization.StringDeserializer
设置value的反序列化为org.apache.kafka.common.serialization.StringDeserializer
依次消费完每个分区之后手动提交offset


模拟生产者，请写出代码向18BD-30主题中生产数据test0-test99
模拟消费者，请写出代码把18BD-30主题中的2号分区的数据消费掉 ，打印输出到控制台

private static final String TOPIC="18BD-30";
    private static final String BROKER_LIST="node01:9092,node02:9092,node03:9092";
    //实例化生产者对象
    private static KafkaProducer<String,String> producer = null;
    // 实例化消费者对象
    private static KafkaConsumer<String,String> kafkaConsumer = null;

    /**
     *
     * 生产者设置：
	 * 消息确认机制 为all
	 * 重试次数 为1
	 * 批量处理消息字节数 为16384
	 * 设置缓冲区大小 为 33554432
	 * 设置每条数据生产延迟1ms
	 * 设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
	 * 设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
	 * 数据分发策略为轮询方式发送到每个分区中
	 * 手动提交每条数据
     */
    static{
        Properties configs = initConfig();
        producer = new KafkaProducer<String, String>(configs);
    }
    private static Properties initConfig(){
        Properties props= new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        props.put(ProducerConfig.ACKS_CONFIG,"all");
        props.put(ProducerConfig.RETRIES_CONFIG,1);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        props.put(ProducerConfig.LINGER_MS_CONFIG,1);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        return props;
    }
    /**
     * 		消费者组id为test
     * 	设置手动提交偏移量
     * 	设置key的反序列化为org.apache.kafka.common.serialization.StringDeserializer
     * 	设置value的反序列化为org.apache.kafka.common.serialization.StringDeserializer
     */
    static {
        Properties properties = initConfig1();
        kafkaConsumer = new KafkaConsumer<String, String>(properties);
        TopicPartition topicPartition = new TopicPartition(TOPIC,2);
        kafkaConsumer.assign(Arrays.asList(topicPartition));
//        kafkaConsumer.subscribe(Arrays.asList(TOPIC));
    }

    private static Properties initConfig1(){
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        return properties;
    }
    /*
    生产者代码
     */
    @Test
    public void Producer(){
//        1、在kafka集群中创建18BD-30主题 副本为2个，分区为3个
        //bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 2 --partitions 3 --topic 18BD-30
//                其他都是默认设置
//        模拟生产者，请写出代码向18BD-30主题中生产数据test0-test99
        //2、通过实例发送数据到kafka集群
        try {
            for (int i = 0; i <100; i++) {
                //当没有指定分区号和key时使用轮训（轮训分区）策略存储数据
                ProducerRecord producerRecord = new ProducerRecord(TOPIC,"test"+i);
                producer.send(producerRecord);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            producer.close();
        }
    }
    @Test
    public void consumer(){
        // 模拟消费者，请写出代码把18BD-30主题中的2号分区的数据消费掉 ，打印输出到控制台
        try {
            while (true){
                //拉取数据，并输出
                //获取所有数据
                ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(100);
                //获取每个分区
                Set<TopicPartition> partitions = consumerRecords.partitions();
                //遍历每个分区
                for (TopicPartition partition : partitions) {
                    //获取分区的数据的载体
                    List<ConsumerRecord<String, String>> records = consumerRecords.records(partition);
                    //获取每个数据
                    for (ConsumerRecord<String, String> record : records) {
                        System.out.println(record.value()+  "    "+record.partition());
                    }
                }
                kafkaConsumer.commitSync();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            kafkaConsumer.close();
        }

    }

9、在kafka集群中创建18BD-40主题副本为2个，分区为3个

生产者设置：
消息确认机制 为all
重试次数 为1
批量处理消息字节数 为16384
设置缓冲区大小 为 33554432
设置每条数据生产延迟1ms
设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
数据分发策略为轮询方式发送到每个分区中

消费者设置：
消费者组id为test
设置自动提交偏移量
设置当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
设置key的反序列化为org.apache.kafka.common.serialization.StringDeserializer
设置value的反序列化为org.apache.kafka.common.serialization.StringDeserializer
消费指定分区0和分区2中的数据

模拟生产者，请写出代码向18BD-40主题中生产数据test0-test99
模拟消费者，请写出代码把18BD-40主题中的0和2号分区的数据消费掉 ，打印输出到控制台

 private static final String TOPIC="18BD-40";
    private static final String BROKER_LIST="node01:9092,node02:9092,node03:9092";
    //实例化生产者对象
    private static KafkaProducer<String,String> producer = null;
    // 实例化消费者对象
    private static KafkaConsumer<String,String> kafkaConsumer = null;

    /**
     *
     * 	生产者设置：
     * 	消息确认机制 为all
     * 	重试次数 为1
     * 	批量处理消息字节数 为16384
     * 	设置缓冲区大小 为 33554432
     * 	设置每条数据生产延迟1ms
     * 	设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
     * 	设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
     * 	数据分发策略为轮询方式发送到每个分区中
     */
    static{
        Properties configs = initConfig();
        producer = new KafkaProducer<String, String>(configs);
    }
    private static Properties initConfig(){
        Properties props= new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        props.put(ProducerConfig.ACKS_CONFIG,"all");
        props.put(ProducerConfig.RETRIES_CONFIG,1);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        props.put(ProducerConfig.LINGER_MS_CONFIG,1);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        return props;
    }
    /**
     * 		消费者设置：
     * 	消费者组id为test
     * 	设置自动提交偏移量
     * 	设置当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
     * 	设置key的反序列化为org.apache.kafka.common.serialization.StringDeserializer
     * 	设置value的反序列化为org.apache.kafka.common.serialization.StringDeserializer
     * 	消费指定分区0和分区2中的数据
     */
    static {
        Properties properties = initConfig1();
        kafkaConsumer = new KafkaConsumer<String, String>(properties);
        TopicPartition topicPartition = new TopicPartition(TOPIC,0);
        TopicPartition topicPartition1 = new TopicPartition(TOPIC,2);
        kafkaConsumer.assign(Arrays.asList(topicPartition,topicPartition1));
//        kafkaConsumer.subscribe(Arrays.asList(TOPIC));
    }

    private static Properties initConfig1(){
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
        properties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        return properties;
    }
    /*
    生产者代码
     */
    @Test
    public void Producer(){
//        1、在kafka集群中创建18BD-40主题 副本为2个，分区为3个
        //bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 2 --partitions 3 --topic 18BD-40
//                其他都是默认设置
//        模拟生产者，请写出代码向18BD-40主题中生产数据test0-test99
        //2、通过实例发送数据到kafka集群
        try {
            for (int i = 0; i <100; i++) {
                //当没有指定分区号和key时使用轮训（轮训分区）策略存储数据
                ProducerRecord producerRecord = new ProducerRecord(TOPIC,"test"+i);
                producer.send(producerRecord);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            producer.close();
        }
    }
    @Test
    public void consumer(){
        // 模拟消费者，请写出代码把18BD-40主题中的0和2号分区的数据消费掉 ，打印输出到控制台
        try {
            while (true){
                //拉取数据，并输出
                //获取所有数据
                ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(100);
                //获取每个分区
                Set<TopicPartition> partitions = consumerRecords.partitions();
                //遍历每个分区
                for (TopicPartition partition : partitions) {
                    //获取分区的数据的载体
                    List<ConsumerRecord<String, String>> records = consumerRecords.records(partition);
                    //获取每个数据
                    for (ConsumerRecord<String, String> record : records) {
                        System.out.println(record.value()+  "    "+record.partition());
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            kafkaConsumer.close();
        }

    }

10、在kafka集群中创建18BD-50主题副本为2个，分区为3个

生产者设置：
消息确认机制 为all
重试次数 为1
批量处理消息字节数 为16384
设置缓冲区大小 为 33554432
设置每条数据生产延迟1ms
设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
数据分发策略为轮询方式发送到每个分区中

消费者设置：
消费者组id为test
设置自动提交偏移量
设置当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
设置key的反序列化为org.apache.kafka.common.serialization.StringDeserializer
设置value的反序列化为org.apache.kafka.common.serialization.StringDeserializer
消费指定分区0和分区2中的数据，并且设置消费0分区的数据offerset值从0开始，消费2分区的数据offerset值从10开始

模拟生产者，请写出代码向18BD-50主题中生产数据test0-test99
模拟消费者，请写出代码把18BD-50主题中的0和2号分区的数据消费掉 ，打印输出到控制台

private static final String TOPIC="18BD-50";
    private static final String BROKER_LIST="node01:9092,node02:9092,node03:9092";
    //实例化生产者对象
    private static KafkaProducer<String,String> producer = null;
    // 实例化消费者对象
    private static KafkaConsumer<String,String> kafkaConsumer = null;

    /**
     *
     * 		生产者设置：
     * 	消息确认机制 为all
     * 	重试次数 为1
     * 	批量处理消息字节数 为16384
     * 	设置缓冲区大小 为 33554432
     * 	设置每条数据生产延迟1ms
     * 	设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
     * 	设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
     * 	数据分发策略为轮询方式发送到每个分区中
     */
    static{
        Properties configs = initConfig();
        producer = new KafkaProducer<String, String>(configs);
    }
    private static Properties initConfig(){
        Properties props= new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        props.put(ProducerConfig.ACKS_CONFIG,"all");
        props.put(ProducerConfig.RETRIES_CONFIG,1);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        props.put(ProducerConfig.LINGER_MS_CONFIG,1);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        return props;
    }
    /**
     * 		消费者设置：
     * 	消费者组id为test
     * 	设置自动提交偏移量
     * 	设置当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
     * 	设置key的反序列化为org.apache.kafka.common.serialization.StringDeserializer
     * 	设置value的反序列化为org.apache.kafka.common.serialization.StringDeserializer
     * 	消费指定分区0和分区2中的数据，并且设置消费0分区的数据offerset值从0开始，消费2分区的数据offerset值从10开始
     */
    static {
        Properties properties = initConfig1();
        kafkaConsumer = new KafkaConsumer<String, String>(properties);
        TopicPartition topicPartition = new TopicPartition(TOPIC,0);
        TopicPartition topicPartition1 = new TopicPartition(TOPIC,2);
        kafkaConsumer.assign(Arrays.asList(topicPartition,topicPartition1));
        //，并且设置消费0分区的数据offerset值从0开始
        kafkaConsumer.seek(new TopicPartition(TOPIC,0),0);
        //消费2分区的数据offerset值从10开始
        kafkaConsumer.seek(new TopicPartition(TOPIC,2),10);
//        kafkaConsumer.subscribe(Arrays.asList(TOPIC));
    }

    private static Properties initConfig1(){
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
        properties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        return properties;
    }
    /*
    生产者代码
     */
    @Test
    public void Producer(){
//        1、在kafka集群中创建18BD-50主题 副本为2个，分区为3个
        //bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 2 --partitions 3 --topic 18BD-50
//                其他都是默认设置
//        模拟生产者，请写出代码向18BD-50主题中生产数据test0-test99
        //2、通过实例发送数据到kafka集群
        try {
            for (int i = 0; i <100; i++) {
                //当没有指定分区号和key时使用轮训（轮训分区）策略存储数据
                ProducerRecord producerRecord = new ProducerRecord(TOPIC,"test"+i);
                producer.send(producerRecord);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            producer.close();
        }
    }
    @Test
    public void consumer(){
        // 模拟消费者，请写出代码把18BD-50主题中的0和2号分区的数据消费掉 ，打印输出到控制台
        try {
            while (true){
                //拉取数据，并输出
                //获取所有数据
                ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(100);
                //获取每个分区
                Set<TopicPartition> partitions = consumerRecords.partitions();
                //遍历每个分区
                for (TopicPartition partition : partitions) {
                    //获取分区的数据的载体
                    List<ConsumerRecord<String, String>> records = consumerRecords.records(partition);
                    //获取每个数据
                    for (ConsumerRecord<String, String> record : records) {
                        System.out.println(record.value()+  "    "+record.partition());
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            kafkaConsumer.close();
        }

    }

李白星河

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
自学kafka部分知识点汇总

（Kafka阶段）简答题：1、Kafka生态系统四大角色，生产者(Producer)、kafka集群(Broker)、消费者(Consumer)、zookeeper2、每个消费者都必须属于一个消费组，一个组内的消费者可以多个。3、一个Topic可以有1到多个多个分区（Partition）4、一个分区可以有1到多个segment。5、每个segment可以有由一个log和一个index组...
复制链接

扫一扫