练习题(一):

题目:

在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消费掉，打印输出到控制台

代码

Producer：

public class ProducerT {

    public static void main(String[] args) {

        /* 1、连接集群，通过配置文件的方式
         * 2、发送数据-topic:order，value
         */
        //配置Kafka集群
        Properties props = new Properties();
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        props.put("acks", "all");
        props.put("retries", 0);
        props.put("batch.size", 16384);
        props.put("linger.ms", 1);
        props.put("buffer.memory", 33554432);
        props.put("key.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String, String> KafkaProducer = new KafkaProducer<String, String>(props);

        for (int i = 0; i < 100; i++) {
            ProducerRecord producerRecord = new ProducerRecord("student", ""+i);
            KafkaProducer.send(producerRecord);
        }
        KafkaProducer.close();
    }

Consumer：

public class Consumer {
    public static void main(String[] args) {

        //1、添加配置
        Properties props = new Properties();
        //指定kafka服务器
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        //消费组
        props.put("group.id", "test");
        //以下两行代码 ---消费者自动提交offset值
        props.put("enable.auto.commit", "true");
        //自动提交的周期
        props.put("auto.commit.interval.ms",  "1000");
        //设置key value的序列化
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<>(props);
        kafkaConsumer.subscribe(Arrays.asList("student"));
        while (true){
            ConsumerRecords<String, String> poll = kafkaConsumer.poll(1000);
            for (ConsumerRecord<String, String> consumerRecord : poll) {
                String value = consumerRecord.value();
                System.out.println("消费的数据:"+value);
            }
        }
    }
}

练习题(二):

题目:

在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消费掉，打印输出到控制台

代码:

Producer：

public class Producer {
    public static void main(String[] args) {
        //1、配置kafka集群
        Properties props = new Properties();

        //kafka服务器地址
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        //消息确认机制
        props.put("acks", "all");
        //重试机制
        props.put("retries", 2);
        //批量发送的大小
        props.put("batch.size", 16384);
        //消息延迟
        props.put("linger.ms", 1);
        //批量的缓冲区大小
        props.put("buffer.memory", 33554432);
        //kafka数据中key  value的序列化
        props.put("key.serializer","org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer","org.apache.kafka.common.serialization.StringSerializer");
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(props);
        for (int i = 0; i < 100; i++) {
            ProducerRecord record = new ProducerRecord("teacher", "BigData"+i);
            kafkaProducer.send(record);
        }
        kafkaProducer.close();
    }
}

Consumer:

public class Consumer {
    public static void main(String[] args) {

        //1、添加配置
        Properties props = new Properties();
        //指定kafka服务器
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        //消费组
        props.put("group.id", "test");
        //以下两行代码 ---消费者自动提交offset值
        props.put("enable.auto.commit", "true");
        //自动提交的周期
        props.put("auto.commit.interval.ms",  "1000");
        //设置分区下已有提交的offset
        props.put("auto.offset.reset","earliest");
        //设置key value的序列化
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        //2、实例Consumer
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);
        kafkaConsumer.subscribe(Arrays.asList("teacher"));
        while (true){
            ConsumerRecords<String, String> poll = kafkaConsumer.poll(100);
            for (ConsumerRecord<String, String> consumerRecord : poll) {
                System.out.println("Teacher消息队列中的数据:----->"+consumerRecord.value());
            }
        }
    }
}

练习题(三):

题目:

在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消费掉，打印输出到控制台

代码:

Producer:

public class Producer {
    public static void main(String[] args) {
        //1、配置kafka集群
        Properties props = new Properties();

        //kafka服务器地址
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        //消息确认机制
        props.put("acks", "all");
        //重试机制
        props.put("retries", 0);
        //批量发送的大小
        props.put("batch.size", 16384);
        //消息延迟
        props.put("linger.ms", 1);
        //批量的缓冲区大小
        props.put("buffer.memory", 33554432);
        //kafka数据中key  value的序列化
        props.put("key.serializer","org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer","org.apache.kafka.common.serialization.StringSerializer");
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(props);
        for (int i = 0; i < 100; i++) {
            ProducerRecord record = new ProducerRecord("title", "title", "KaFka" + i);
            kafkaProducer.send(record);
        }
        kafkaProducer.close();
    }
}

Consumer：

public class Consumer {
    public static void main(String[] args) {
        //1、添加配置
        Properties props = new Properties();
        //指定kafka服务器
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        //消费组
        props.put("group.id", "test");
        //以下两行代码 ---消费者自动提交offset值
        props.put("enable.auto.commit", "true");
        //设置offset提交
        props.put("auto.offset.reset","latest");
        //自动提交的周期
        props.put("auto.commit.interval.ms",  "1000");
        //设置key value的序列化
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);
            kafkaConsumer.subscribe(Arrays.asList("title"));
        while (true){
            ConsumerRecords<String, String> poll = kafkaConsumer.poll(100);
            for (ConsumerRecord<String, String> consumerRecord : poll) {
                System.out.println(consumerRecord.value());
            }
        }
    }
}

练习题(四):

题目:

在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消费掉，打印输出到控制台

代码:

Producer:

public class Producer {
    public static void main(String[] args) {
        //1、配置kafka集群
        Properties props = new Properties();

        //kafka服务器地址
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        //消息确认机制
        props.put("acks", "all");
        //重试机制
        props.put("retries", 0);
        //批量发送的大小
        props.put("batch.size", 16384);
        //消息延迟
        props.put("linger.ms", 1);
        //批量的缓冲区大小
        props.put("buffer.memory", 33554432);

        //kafka数据中key  value的序列化
        props.put("key.serializer","org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer","org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(props);
        for (int i = 0; i < 100; i++) {
            ProducerRecord record = new ProducerRecord("title",2,"keys", "Test" + i);
            kafkaProducer.send(record);

        }
        kafkaProducer.close();
    }
}

Consumer：

public class Consumer {
    public static void main(String[] args) {
        //1、添加配置
        Properties props = new Properties();
        //指定kafka服务器
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        //消费组
        props.put("group.id", "test");
        //以下两行代码 ---消费者自动提交offset值
        props.put("enable.auto.commit", "true");
        //设置offset提交
        props.put("auto.offset.reset","latest");
        //自动提交的周期
        props.put("auto.commit.interval.ms",  "1000");
        //设置key value的序列化
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);
        kafkaConsumer.subscribe(Arrays.asList("title"));
        while (true){
            ConsumerRecords<String, String> poll = kafkaConsumer.poll(100);
            for (ConsumerRecord<String, String> consumerRecord : poll) {
                System.out.println("消费的数据:"+consumerRecord.value()+"所属的分区:"+consumerRecord.partition());
            }
        }

    }
}

练习题(五):

题目:

在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消费掉，打印输出到控制台

代码

Producer:

public class Producer {
    public static void main(String[] args) {
        //1、配置kafka集群
        Properties props = new Properties();

        //kafka服务器地址
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        //消息确认机制
        props.put("acks", "all");
        //重试机制
        props.put("retries",2);
        //批量发送的大小
        props.put("batch.size", 16384);
        //消息延迟
        props.put("linger.ms", 1);
        //设置自定义分区
        props.put("partitioner.class","com.czxy.kafka05.ProducerPartition");
        //批量的缓冲区大小
        props.put("buffer.memory", 33554432);
        //kafka数据中key  value的序列化
        props.put("key.serializer","org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer","org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(props);
        for (int i = 0; i <=300; i++) {
            ProducerRecord record = new ProducerRecord("order", "" + i);
            kafkaProducer.send(record);
        }
        kafkaProducer.close();
    }
}

Consumer：

public class Consumer {
    public static void main(String[] args) {
        //1、添加配置
        Properties props = new Properties();
        //指定kafka服务器
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        //消费组
        props.put("group.id", "test");
        //以下两行代码 ---消费者自动提交offset值
        props.put("enable.auto.commit", "true");
        //设置offset提交
        props.put("auto.offset.reset","latest");
        //自动提交的周期
        props.put("auto.commit.interval.ms",  "1000");
        props.put("auto.offset.reset","earliest");
        //设置key value的序列化
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<>(props);
        kafkaConsumer.subscribe(Arrays.asList("order"));
        while (true){
            ConsumerRecords<String, String> poll = kafkaConsumer.poll(100);
            for (ConsumerRecord<String, String> consumerRecord : poll) {
                System.out.println("消费的数据--->"+consumerRecord.value()+"---所属的分区---->"+consumerRecord.partition());
            }
        }


    }
}

ProducerPartition：


public class ProducerPartition implements Partitioner {
    @Override
    public int partition(String s, Object o, byte[] bytes, Object o1, byte[] bytes1, Cluster cluster) {
        int value=Integer.parseInt(o1.toString());
            if (value>200){
            return 2;
            }else if (value>100&&value<=200){
                return 1;
            }else{
                return 0;
            }
    }

    @Override
    public void close() {

    }

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

    }
}

尹少博客

发布了104 篇原创文章 · 获赞 154 · 访问量 7万+

私信关注

KafkaJavaApi操作:练习题

练习题(一):

题目:

代码

练习题(二):

题目:

代码:

练习题(三):

题目:

代码:

练习题(四):

题目:

代码:

练习题(五):

题目:

代码

猜你喜欢