KafKa常用JavaApi10道例题（送答案）

最新推荐文章于 2023-04-29 09:39:07 发布
最新推荐文章于 2023-04-29 09:39:07 发布
阅读量253 收藏 2
点赞数
分类专栏： kafkaAPI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CZXY18ji/article/details/105173374
版权

以下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
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
KafkaJavaApi操作:练习题
写的不好之处,请指教
03-31 4728
练习题(一): 题目: 在kafka集群中创建student主题 副本为2个，分区为3个 生产者设置： 设置key的序列化为 org.apache.kafka.common.serialization. StringSerializer 设置value的序列化为org.apache.kafka.common.serialization.StringSerializer 其他都是默认设置 消费者设...
查漏补缺：备战2021年java后端Kafka高频面试题(含答案解析)
VX13308414401的博客
06-10 279
前言 Apache Kafka的受欢迎程度很高，Kafka拥有充足的就业机会和职业前景。此外，在这个时代拥有kafka知识是一条快速增长的道路 而且无论是作为面试官，还是应聘者，我都接触过很多Kafka面试题。而在最近面试了很多候选人，发现写了熟悉Kafka，但是对于Kafka相关的知识却是只知道大概用处，简单搭建和使用。我想说，虽然我们是SRE（可靠性工程师），但不论你是业务层的SRE还是基础设施层的SRE，我们都需要对业务方的使用场景有足够理解，或者对我们要提供的服务有足够的了解才行，这样你才能整体的保
Kafka Training topic 一
最慢的步伐不是跬步，而是徘徊；最快的脚步不是冲刺，而是坚持
03-31 6900
pom <dependencies> <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients --> <dependency> <groupId>org.apache.kafka</grou...
Kafka（5）——JavaAPI十道练习题
一个有趣的人，咱们处处看！
03-24 1335
以下kafka集群的节点分别是node01,node02,node03 习题一： 在kafka集群中创建student主题 副本为2个，分区为3个 生产者设置： 设置key的序列化为 org.apache.kafka.common.serialization. StringSerializer 设置value的序列化为org.apache.kafka.common.serializatio...
kafka中的命令行操作以及分区副本问题
mo
07-14 705
关于命令行操作(注：进行命令行操作之前的话务必将zookeeper全部开启) 1.查看当前kafka中现存的所有主题的名字 bin/kafka-topics.sh --zookeeper hadoop102:2181 --list [root@hadoop102 kafka]# bin/kafka-topics.sh --zookeeper hadoop102:2181 --list demo1 demo2 2.查看某个topic的详情，这里我查看的是demo2这个主题的详情 bin/kafka-t
kafka操作命令-主题管理
Dobyi的博客
04-22 5303
kafka操作命令-主题管理
Flink+Kafka的JavaAPI应用
05-30
此案例使用的是IDEA开发工具，项目...使用JavaAPI操作Flink的流处理，Flink从Kafka中获取数据，执行处理后再执行输出。 根据（《Flink入门与实战》徐葳著）教材最后的综合案例改变，适合没有学习不会使用Flume的人使用
2、java调用kafka api
最新发布
05-29
在Java中调用Apache Kafka API是一项关键任务，特别是在构建分布式数据处理系统时。Apache Kafka是一个高性能、可扩展的消息队列（MQ），它提供实时的数据流处理能力。在Java应用程序中集成Kafka API可以让开发者...
KafkaDemo:kafka Java API
05-18
#Kafka Java API案例Producer可选配置，如果不配置，则使用默认的partitioner根据key值value映射到指定的Parition props.put("partitioner.class", "kafka.demo.PartitionerDemo");ConsumerString key=(String)obj; ...
Java API方式调用Kafka各种协议的方法
08-29
Java API方式调用Kafka各种协议的方法 Java API方式调用Kafka各种协议的方法是指使用Java语言编写的应用程序调用Kafka的协议来实现各种功能，例如发送消息、获取消息、提交位移、创建topic等。Kafka自己实现了一套...
Kafka使用Java客户端进行访问的示例代码
08-29
Kafka 使用 Java 客户端进行访问的示例代码 Kafka 是一种流行的分布式消息队列系统，广泛应用于大数据实时处理、日志聚合、消息队列等领域。Java 是一种广泛使用的编程语言，很多开发者使用 Java 进行 Kafka 的开发...
【2021最新版】Kafka面试题总结（25道题含答案解析）
热门推荐
程序媛小琬的博客
05-11 5万+
文章目录1、Kafka是什么？2、partition的数据文件（offffset，MessageSize，data）3、数据文件分段 segment（顺序读写、分段命令、二分查找）4、负载均衡（partition会均衡分布到不同broker上）5、批量发送6、压缩（GZIP或Snappy）7、消费者设计8、Consumer Group9、如何获取topic主题的列表10、生产者和消费者的命令行是什么？11、consumer是推还是拉？12、讲讲kafka维护消费状态跟踪的方法13、讲一下主从同步。14、为什
2023年java面试题之kafka（5道）
sinat_26552841的博客
02-10 756
我们可以认为⼀个group是⼀个"订阅"者,⼀个Topic中的每个partions,只会被⼀个"订阅者"中的⼀个consumer消费,不过⼀个consumer可以消费多个partitions中的消息。--kafka使⽤场景,对于⼀些常规的消息系统,kafka是个不错的选择;partitons/replication和容错,可以使kafka具有良好的扩展性和性能优势.不过到⽬前为⽌,我们应该很清楚认识到,kafka并没有提供JMS中的"事务性""消息传输担保(消息确认机制)""消息分组"等企业级特性;
KafkaJavaApi操作:练习题(一)
03-19 3358
题目 在kafka集群中创建student主题 副本为2个，分区为3个 生产者设置： 设置key的序列化为 org.apache.kafka.common.serialization. StringSerializer 设置value的序列化为org.apache.kafka.common.serialization.StringSerializer 其他都是默认设置 消费者设置： 消费者组id...
50道Kafka面试题和解析（转载）
aoqincun5147的博客
09-12 255
转载：https://zhuanlan.zhihu.com/p/78912551 前言 Apache Kafka的受欢迎程度很高，Kafka拥有充足的就业机会和职业前景。此外，在这个时代拥有kafka知识是一条快速增长的道路。所以，在这篇文章中，我们收集了Apache Kafka面试中常见的问题，并提供了答案。因此，如果您希望参加Apache Kafka面试，这是一份不错的指南。这将...
Java面试题kafka
2301_77783312的博客
04-29 144
用于处理海量的日志有很大关系，哈哈哈，人家本来最开始就不是为了作为消息队列滴，谁知道后面误打误撞在消息队列领域占据了一席之地。自动提交的话会有一个问题，试想一下，当消费者刚拿到这个消息准备进行真正消费的时候，突然挂掉了，消息实际上并没有被消费，但是。是，细心的朋友一定会发现，这样会带来消息被重新消费的问题。我们在使用消息队列的过程中经常有业务场景需要严格保证消息的消费顺序，比如我们同时发了。是真正保存消息的地方，我们发送的消息都被放在了这里。消息队列：发布和订阅消息流，这个功能类似于消息队列，这也。
Kafka面试题，附带答案
weixin_46016315的博客
04-07 2979
1.什么是kafka？？ 答： kafka是分布式 · 订阅消息系统，最初由LinkedIn公司开发的，后来被Apache公司收购。kafka是一个分布式、可划分的、冗余备份机制的持久性的日志服务，主要用于流数据 2.为什么要使用kafka？？ 答：a.多个生产者 b.多个消费者 c.基于磁盘的数据存储 d.伸缩性 e.高性能 3.Kafka为什么要使用消息队列？？ 答：A.缓冲和消峰：例：上游突...
Kafka学习(3)-----消费者
zh328271057的博客
05-30 1347
思维导图： 引言 这篇文章的主要内容是介绍Kafka消费者的一般的使用流程以及比较特殊的操作，所以本文共分为以下两个部分： 基本流程 ： 主要包括创建实例，消息订阅，消息消费，位移提交，消费控制等内容。 其他处理 ： 主要是一些其他的处理，例如指定位移消费，消费者拦截器等操作。 一.基本流程 Kafka消费者的基本流程一般来说都是必要的。也代表着消费者的基本使用逻辑。...
kafka笔记（四）：消费者-消费方式/消费者工作流程/消费者API/分区分配及平衡/手动、自动提交offset
qq_55906442的博客
09-22 1635
（1）pull（拉）模式：consumer采用从broker中主动拉取数据。Kafka采用了这种方式。（2）push（推）模式：Kafka没有采用这种方式，因为由broker决定消息发送速率，很难适应所有消费者的消费速率。例如推送的速度是50m/s，Consumer1、Consumer2就来不及处理消息。pull模式不足之处是，如果Kafka没有数据，消费者可能会陷入循环中，一直返回空数据。
Java Kafka常用API
04-03
1. Kafka Producer API：用于将消息发送到Kafka集群。 2. Kafka Consumer API：用于从Kafka集群中读取消息。 3. Kafka Streams API：用于处理和分析流数据。 4. Kafka Connect API：用于构建和运行可插拔的连接器，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值