Kafka Training topic 一

其他 2020-04-08 10:44:47 阅读次数: 0

pom


    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams</artifactId>
            <version>1.0.0</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

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

Priducer 代码

package Producer;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

/**
 * Created by 一个蔡狗 on 2020/3/19.   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消费掉，打印输出到控制台
 */
public class Priducer_01 {


    public static void main(String[] args) {

        //编写 生产数据程序
        Properties props = new Properties();
        props.put("bootstrap.servers", "node001: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");



        //2.  实例一个 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(props);

        for (int i = 0; i < 100; i++) {
            //3.   模拟生产者，请写出代码向student主题中生产数据0-99
            ProducerRecord producerRecord = new ProducerRecord("student"," "+i);
            kafkaProducer.send(producerRecord);



        }

    }




}

Consumer 代码
package Consumer;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.Properties;

/**
 * Created by 一个蔡狗 on 2020/3/19.    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消费掉，打印输出到控制台
 */
public class Consumer_01 {


    public static void main(String[] args) {

        Properties props = new Properties();
        props.put("bootstrap.servers", "node001:9092,node002:9092,node003:9092");
        props.put("group.id", "test");

//以下两行代码 ---消费者自动提交offset值
        props.put("enable.auto.commit", "true");
        props.put("auto.commit.interval.ms",  "1000");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");



        //  设置 消费者 对象
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);

        // 设置读取的  topic
        kafkaConsumer.subscribe(Arrays.asList("student"));


        // 模拟消费者，请写出代码把student主题中的数据0-99消费掉，打印输出到控制台  循环遍历
        while (true){
            //拉取数据  并 输出
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(1000);

            for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                //一条数据
                System.out.println("数据为：  "+consumerRecord.value() );
            }



        }

    }
}

 

 

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

Priducer代码
package Producer;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

/**
 * Created by 一个蔡狗 on 2020/3/20.     2
 *
 * 在kafka集群中创建teacher主题 副本为2个，分区为3个
 生产者设置：
 消息确认机制 为             all
 重试次数          为        2
 批量处理消息字节数 为    16384
 设置缓冲区大小 为         33554432
 设置每条数据生产延迟         1 ms
 设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
 设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
 数据分发策略为默认轮询方式


 模拟生产者，请写出代码向teacher主题中生产数据   bigdata0   -      bigdata99
 */
public class Priducer_02 {

    public static void main(String[] args) {


        //编写 生产数据程序
        //1、配置kafka集群环境（设置）
        Properties props = new Properties();
        //kafka服务器地址
        props.put("bootstrap.servers", "node001: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");


        //2.  实例一个 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(props);

        for (int i = 0; i < 100; i++) {
            //3.   模拟生产者，请写出代码向teacher主题中生产数据bigdata0-bigdata99    数据分发策略为默认轮询方式
            ProducerRecord producerRecord = new ProducerRecord("teacher","bigdata"+i);
            kafkaProducer.send(producerRecord);



        }

    }





}

Consumer 代码

package Consumer;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.Properties;

/**
 * Created by 一个蔡狗 on 2020/3/20.          2
 * 2、消费者设置：
 消费者组                    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   消费掉 ，打印输出到控制台
 *
 */
public class Consumer_02 {


    public static void main(String[] args) {


        //1、添加哦配置文件
        Properties props = new Properties();
        //指定kafka服务器
        props.put("bootstrap.servers", "node001:9092,node002:9092,node003:9092");
        //消费组
        props.put("group.id", "test");
        //以下两行代码 ---消费者自动提交offset值
        props.put("enable.auto.commit", "true");

        //自动提交的周期
        props.put("auto.commit.interval.ms",  "1000");

        //      设置 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
        props.put("auto.offset.earliest","true");


        //kafka   key 和value的反序列化
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");


        //2、实例消费者对象
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);

        //3、设置读取的topic
        kafkaConsumer.subscribe(Arrays.asList("teacher"));


        //循环遍历
        while (true){
            //4、拉取数据，并输出
            //获取到所有的数据
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(1000);
            //遍历所有数据，获得到一条
            for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                //一条数据
                System.out.println("数据是  "+consumerRecord.value());
            }

        }

    }

}

 

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

 

Priducer 代码
package Producer;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

/**
 * Created by 一个蔡狗 on 2020/3/20.
 *
 *
 *在kafka集群中创建title主题 副本为2个，分区为3个
 生产者设置：
 消息确认机制 为   all
 重试次数 为   1
 批量处理消息字节数 为   16384
 设置缓冲区大小 为   33554432
 设置每条数据生产延迟   1  ms
 设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
 设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
 数据分发策略为指定数据    key为   title  ,分发到同一个分区中

 模拟生产者，请写出代码向title主题中生产数据   kafka0  -  kafka99


 */
public class Priducer_03 {



    public static void main(String[] args) {


        //编写 生产数据程序
        //1、配置kafka集群环境（设置）
        Properties props = new Properties();
        //kafka服务器地址
        props.put("bootstrap.servers", "node001:9092");
        //消息确认机制
        props.put("acks", "all");
        //重试机制
        props.put("retries", 1);
        //批量发送的大小
        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");


        //2.  实例一个 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(props);

        for (int i = 0; i < 100; i++) {
            //3.   模拟生产者，请写出代码向teacher主题中生产数据bigdata0-bigdata99    数据分发策略为默认轮询方式
            ProducerRecord producerRecord = new ProducerRecord("order","title","kafka"+i);
            kafkaProducer.send(producerRecord);



        }

    }








}

Consumer 代码

package Consumer;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.Properties;

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


 模拟消费者，请写出代码把  title  主题中的数据  kafka0  -  kafka99  消费掉 ，打印输出到控制台
 */
public class Consumer_03 {

    public static void main(String[] args) {


        //1、添加哦配置文件
        Properties props = new Properties();
        //指定kafka服务器
        props.put("bootstrap.servers", "node001:9092,node002:9092,node003:9092");
        //消费组
        props.put("group.id", "test");
        //以下两行代码 ---消费者自动提交offset值
        props.put("enable.auto.commit", "true");

        //自动提交的周期
        props.put("auto.commit.interval.ms",  "1000");

        //      设置 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
        props.put("auto.offset.latest","true");


        //kafka   key 和value的反序列化
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");


        //2、实例消费者对象
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);

        //3、设置读取的topic
        kafkaConsumer.subscribe(Arrays.asList("title"));


        //循环遍历
        while (true){
            //4、拉取数据，并输出
            //获取到所有的数据
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(1000);
            //遍历所有数据，获得到一条
            for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                //一条数据
                System.out.println("数据是  "+consumerRecord.value());
            }

        }

    }




}

 

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

Priducer 代码

package Producer;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

/**
 * Created by 一个蔡狗 on 2020/3/20.
 *
 *
 * 在kafka集群中创建title主题 副本为2个，分区为3个
 生产者设置：
 消息确认机制 为all
 重试次数 为2
 批量处理消息字节数 为16384
 设置缓冲区大小 为 33554432
 设置每条数据生产延迟1ms
 设置key的序列化为org.apache.kafka.common.serialization.StringSerializer
 设置value的序列化为org.apache.kafka.common.serialization.StringSerializer
 数据分发策略为指定分区2，把数据发送到指定的分区中

 模拟生产者，请写出代码向  title 主题中生产数据test0-test99

 */
public class Priducer_04 {
    public static void main(String[] args) {


        //编写 生产数据程序
        //1、配置kafka集群环境（设置）
        Properties props = new Properties();
        //kafka服务器地址
        props.put("bootstrap.servers", "node001: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");


        //2.  实例一个 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(props);

        for (int i = 0; i < 100; i++) {
            //3.   模拟生产者，请写出代码向teacher主题中生产数据bigdata0-bigdata99    数据分发策略为默认轮询方式
            ProducerRecord producerRecord = new ProducerRecord("title",2,"","test"+i);
            kafkaProducer.send(producerRecord);


        }

    }




}

Consumer 代码

package Consumer;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.Properties;

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


 模拟消费者，请写出代码把title主题中的数据   test0   -test99消费掉 ，打印输出到控制台
 */
public class Consumer_04 {

    public static void main(String[] args) {


        //1、添加哦配置文件
        Properties props = new Properties();
        //指定kafka服务器
        props.put("bootstrap.servers", "node001:9092,node002:9092,node003:9092");
        //消费组
        props.put("group.id", "test");
        //以下两行代码 ---消费者自动提交offset值
        props.put("enable.auto.commit", "true");

        //自动提交的周期
        props.put("auto.commit.interval.ms",  "1000");

        //      设置 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
        props.put("auto.offset.none","true");


        //kafka   key 和value的反序列化
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");


        //2、实例消费者对象
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);

        //3、设置读取的topic
        kafkaConsumer.subscribe(Arrays.asList("title"));


        //循环遍历
        while (true){
            //4、拉取数据，并输出
            //获取到所有的数据
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(1000);
            //遍历所有数据，获得到一条
            for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                //一条数据
                System.out.println("数据是  "+consumerRecord.value());
            }

        }

    }





}

 

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

 

Priducer 代码

package Producer;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

/**
 * Created by 一个蔡狗 on 2020/3/20.
 *
 *
 在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中



 模拟生产者，请写出代码向order主题中生产数据0-299
 */
public class Priducer_05 {
    public static void main(String[] args) {


        //编写 生产数据程序
        //1、配置kafka集群环境（设置）
        Properties props = new Properties();
        //kafka服务器地址
        props.put("bootstrap.servers", "node001:9092");
        //消息确认机制
        props.put("acks", "all");
        //重试机制
        props.put("retries", 1);
        //批量发送的大小
        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");

        //自定义分区
          props.put("partitioner.class", "Producer.Priducer_05_Partitione");


        //2.  实例一个 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(props);

        for (int i = 0; i < 300; i++) {
            //3.   模拟生产者，请写出代码向teacher主题中生产数据bigdata0-bigdata99    数据分发策略为默认轮询方式
            ProducerRecord producerRecord = new ProducerRecord("order",""+i);
            kafkaProducer.send(producerRecord);


        }

    }




}

Partitioner 代码
package Producer;

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;

import java.util.Map;

/**
 * Created by 一个蔡狗 on 2020/3/20.
 */
public class Priducer_05_Partitione  implements Partitioner {

    @Override
    public int partition(String s, Object o, byte[] bytes, Object o1, byte[] bytes1, Cluster cluster) {

          /*
编写自定义分区代码

 数据分发策略为自定义，请把生产的数据100以内的数据分发到分区0中，100-200以内的数据分发到分区1中，200-300内的数据分发到分区2中

 */

          //将 value   转为  Integer    在进行 int  判断
        String s1 = o1.toString();
        Integer number =Integer.getInteger(s1);
        if (number<100){
            return 0;
        }else if (number<200 &  number>= 100){
            return 1;
        }else if (number<300 &  number>= 200){
            return 2;
        }else {
            return 0;
        }
    }

    @Override
    public void close() {

    }

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

    }
}

 

Consumer 代码

package Consumer;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.Properties;

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


 模拟消费者，请写出代码把order主题中的数据 0-299  消费掉 ，打印输出到控制台
 */
public class Consumer_05 {


    public static void main(String[] args) {


        //1、添加哦配置文件
        Properties props = new Properties();
        //指定kafka服务器
        props.put("bootstrap.servers", "node001:9092,node002:9092,node003:9092");
        //消费组
        props.put("group.id", "test");
        //以下两行代码 ---消费者自动提交offset值
        props.put("enable.auto.commit", "true");

        //自动提交的周期
        props.put("auto.commit.interval.ms",  "1000");

        //      设置 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
        props.put("auto.offset.earliest","true");


        //kafka   key 和value的反序列化
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");


        //2、实例消费者对象
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);

        //3、设置读取的topic
        kafkaConsumer.subscribe(Arrays.asList("order"));


        //循环遍历
        while (true){
            //4、拉取数据，并输出
            //获取到所有的数据
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(1000);
            //遍历所有数据，获得到一条
            for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                //一条数据
                System.out.println("数据是  "+consumerRecord.value());
            }

        }

    }


}

//  Knowledge

* auto.offset.reset

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


 props.put("auto.offset.reset","earliest");

 props.put("auto.offset.reset","latest");

 props.put("auto.offset.reset","none");

 

神说要有光，于是就有了我
发布了218 篇原创文章 · 获赞 291 · 访问量 29万+
私信 关注

猜你喜欢

转载自blog.csdn.net/bbvjx1314/article/details/105216806
今日推荐
NetBSD 禁止提交由 AI 生成的代码
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
周排行
女程序员是这样被恶搞的
B/S 和 C/S 的优缺点
vector一直申请会怎样？
座头鲸识别比赛(Humpback Whale Identification)总结
Linux高性能服务器编程——I/O复用 select
Mysql连接数据库（当包使用）
通过URI获取的文件路径为null的解决方法
1022-Primes on Interval(素数筛选+二分查找) ZCMU
Python出现： TypeError: expected string or buffer
bzoj2434: [Noi2011]阿狸的打字机 ac自动机+树状数组
每日归档
更多
2024-05-18(4)
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022