kafka生产者

已于 2024-03-13 21:18:58 修改
阅读量809 收藏 24
点赞数 19
分类专栏： 消息队列 文章标签： kafka
于 2024-03-12 22:16:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43924419/article/details/136664822
版权

kafka生产者

  1. 生产者消息发送原理

    在消息发送的过程中，涉及到了两个线程——main线程和Sender线程。在main线程中创建了一个双端队列
RecordAccumulator。main线程将消息发送给RecordAccumulator，Sender线程不断从RecordAccumulator
中拉取消息发送到Kafka Broker。

    在这里插入图片描述

  2. 生产者参数列表

    参数名称												描述
bootstrap.servers	生产者连接集群所需的broker地址清单。例如192.168.233.26:9092，可以设置1个或者多个，中间用逗号隔					开。注意这里并非需要所有的broker地址，因为生产者从给定的broker里查找到其他broker信息。
key.serializer和value.serializer	指定发送消息的key和value的序列化类型。一定要写全类名。
buffer.memory		RecordAccumulator缓冲区总大小，默认32m。
batch.size			缓冲区一批数据最大值，默认16k。适当增加该值，可以提高吞吐量，但是如果该值设置太大，会导致数据传输延迟					增加。
linger.ms			如果数据迟迟未达到batch.size，sender等待linger.time之后就会发送数据。单位ms，默认值是0ms，表示没					有延迟。生产环境建议该值大小为5-100ms之间。
acks				0：生产者发送过来的数据，不需要等数据落盘应答。
					1：生产者发送过来的数据，Leader收到数据后应答。
					-1（all）：生产者发送过来的数据，Leader+和isr队列里面的所有节点收齐数据后应答。
					默认值是-1，-1和all是等价的。
max.in.flight.requests.per.connection	允许最多没有返回ack的次数，默认为5，开启幂等性要保证该值是 1-5的数字。
retries				当消息发送出现错误的时候，系统会重发消息。retries表示重试次数。默认是int最大值，2147483647。
					如果设置了重试，还想保证消息的有序性，需要设置
					MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION=1否则在重试此失败消息的时候，其他的消息可能发送成功了。
retry.backoff.ms	两次重试之间的时间间隔，默认是100ms。
enable.idempotence	是否开启幂等性，默认true，开启幂等性。
compression.type	生产者发送的所有数据的压缩方式。默认是none，也就是不压缩。 
					支持压缩类型：none、gzip、snappy、lz4和zstd。

    1. 普通异步发送

      在这里插入图片描述

1）需求：创建Kafka生产者，采用异步的方式发送到Kafka Broker
2）代码编写
	1）创建工程kafka
	2）导入依赖
     <dependency>
          <groupId>org.apache.kafka</groupId>
          <artifactId>kafka-clients</artifactId>
          <version>3.0.0</version>
     </dependency>
3）创建包名：com.lpy.kafka.producer
4）编写不带回调函数的API代码	
	public class CustomProducer {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建kafka生产者的配置对象
        Properties properties = new Properties();
        
        // 2. 给kafka配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.233.26:9092");
        
        // key,value序列化（必须）：key.serializer，value.serializer
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        // 3. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 4. 调用send方法,发送消息
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("first","lpy " + i));
        }

        // 5. 关闭资源
        kafkaProducer.close();
    }
} 
5）测试：
	①在192.168.233.26上开启Kafka消费者
		bin/kafka-console-consumer.sh --bootstrap-server 192.168.233.26:9092 --topic first
	②在IDEA中执行代码，观察192.168.233.26控制台中是否接收到消息。
		bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first

        lpy 0
        lpy 1
        lpy 2
        lpy 3
        lpy 4

  1. 带回调函数的异步发送

    在这里插入图片描述

1：回调函数会在producer收到ack时调用，为异步调用，该方法有两个参数，分别是元数据信息（RecordMetadata）和异常信息					（Exception），如果Exception为null，说明消息发送成功，如果Exception不为null，说明消息发送失败
		注意：消息发送失败会自动重试，不需要我们在回调函数中手动重试
2：代码
	public class CustomProducerCallback {

    public static void main(String[] args) throws InterruptedException {

        // 1. 创建kafka生产者的配置对象
        Properties properties = new Properties();

        // 2. 给kafka配置对象添加配置信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.233.26:9092");

        // key,value序列化（必须）：key.serializer，value.serializer
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        // 3. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 4. 调用send方法,发送消息
        for (int i = 0; i < 5; i++) {

            // 添加回调
            kafkaProducer.send(new ProducerRecord<>("first", "lpy " + i), new Callback() {

                // 该方法在Producer收到ack时调用，为异步调用
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {

                    if (exception == null) {
                        // 没有异常,输出信息到控制台
                        System.out.println("主题：" + metadata.topic() + "->"  + "分区：" + metadata.partition());
                    } else {
                        // 出现异常打印
                        exception.printStackTrace();
                    }
                }
            });

            // 延迟一会会看到数据发往不同分区
            Thread.sleep(2);
        }

        // 5. 关闭资源
        kafkaProducer.close();
    }
}
3:测试：
	①在192.168.233.26上开启Kafka消费者。
		bin/kafka-console-consumer.sh --bootstrap-server 192.168.233.26:9092 --topic first
	②在IDEA中执行代码，观察 192.168.233.26控制台中是否接收到消息
        bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first

    	lpy 0
    	lpy 1
    	lpy 2
    	lpy 3
    	lpy 4
    ③在IDEA控制台观察回调信息。
    	主题：first->分区：0
        主题：first->分区：0
        主题：first->分区：1
        主题：first->分区：1
        主题：first->分区：1
  1. 同步发送API

在这里插入图片描述

只需在异步发送的基础上，再调用一下get()方法即可
public class CustomProducerSync {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        // 1. 创建kafka生产者的配置对象
        Properties properties = new Properties();

        // 2. 给kafka配置对象添加配置信息
   properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.233.26:9092");

        // key,value序列化（必须）：key.serializer，value.serializer
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        // 3. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 4. 调用send方法,发送消息
        for (int i = 0; i < 10; i++) {

            // 异步发送 默认
//            kafkaProducer.send(new ProducerRecord<>("first","kafka" + i));
            // 同步发送
            kafkaProducer.send(new ProducerRecord<>("first","kafka" + i)).get();

        }

        // 5. 关闭资源
        kafkaProducer.close();
    }
}
测试：
①在192.168.233.26上开启Kafka消费者。
	bin/kafka-console-consumer.sh --bootstrap-server 192.168.233.26:9092 --topic first
②在IDEA中执行代码，观察192.168.233.26控制台中是否接收到消息
	bin/kafka-console-consumer.sh --bootstrap-server 192.168.233.26:9092 --topic first

    kafka 0
    kafka 1
    kafka 2
    kafka 3
    kafka 4

  1. 生产者分区

    1：便于合理使用存储资源：每个partition在一个broker上存储，可以把海量的数据按照分区切割成一块
	一块数据存储在多台broker上，合理控制分区的任务，可以实现负载均衡的效果
2：提高并行度：生产者可以以分区为单位发送数据，消费者可以以分区为单位进行消费数据

  2. 生产者发送消息的分区策略

    1）默认的分区器 DefaultPartitioner
	1：public ProducerRecord(String topic,Integer partition,K key, V value){}
		指明partition的情况下，直接将指明的值作为partition值，例如partition=0，所有的数据会写入分区0
	2：public ProducerRecord(String topic,K key, V value){}
		没有指明partition值但有key的情况下，将key的hash值与topic的partition数进行取余得到partition值，
		例如：key1的hash值为5，key2的hash值为6，topic的partition数=2，那么key1对应的value1写入1号分区，
		key2对应的value2写入0号分区。
	3：既没有partition值又没有key值的情况下，kafka采用sticky partition(粘性分区器)，会随机选择一个分区，
		并尽可能一直使用这个分区，待带分区的batch已满或者已完成，kafka在随机一个分区进行使用（和上一次的分区不同）。
		例如：第一次随机选择0号分区，等0号分区当前批次满了（默认16K）或者linger.ms设置的时间到了，kafka在随机一
		个分区进行使用（如果是0会继续随机）
2) 案例
	1：将数据发往指定partition的情况下，例如，将所有数据发往分区1中
	public class CustomProducerCallbackPartitions {

    public static void main(String[] args) {

        // 1. 创建kafka生产者的配置对象
        Properties properties = new Properties();

        // 2. 给kafka配置对象添加配置信息
      properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.233.26:9092");

        // key,value序列化（必须）：key.serializer，value.serializer
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        for (int i = 0; i < 5; i++) {
            // 指定数据发送到1号分区，key为空（IDEA中ctrl + p查看参数）
            kafkaProducer.send(new ProducerRecord<>("first", 1,"","kafka " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception e) {
                    if (e == null){
                        System.out.println("主题：" + metadata.topic() + "->"  + "分区：" + metadata.partition()
                        );
                    }else {
                        e.printStackTrace();
                    }
                }
            });
        }

        kafkaProducer.close();
    }
}
		测试：
	①在192.168.233.26上开启Kafka消费者
		bin/kafka-console-consumer.sh --bootstrap-server 1192.168.233.26:9092 --topic first
	②在IDEA中执行代码，观察192.168.233.26控制台中是否接收到消息。
		bin/kafka-console-consumer.sh --bootstrap-server 192.168.233.26:9092 --topic first
		kafka 0
        kafka 1
        kafka 2
        kafka 3
        kafka 4
     ③在IDEA控制台观察回调信息
     	主题：first->分区：1
        主题：first->分区：1
        主题：first->分区：1
        主题：first->分区：1
        主题：first->分区：1
        
    2：没有指明partition值但有key的情况下，将key的hash值与topic的partition数进行取余得到partition值
    	public class CustomProducerCallback {

    public static void main(String[] args) {

        Properties properties = new Properties();

        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.233.26:9092");

        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        for (int i = 0; i < 5; i++) {
            // 依次指定key值为a,b,f ，数据key的hash值与3个分区求余，分别发往1、2、0
            kafkaProducer.send(new ProducerRecord<>("first", "a","kafka " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception e) {
                    if (e == null){
                        System.out.println("主题：" + metadata.topic() + "->" + "分区：" + 												metadata.partition()
                        );
                    }else {
                        e.printStackTrace();
                    }
                }
            });
        }

        kafkaProducer.close();
    }
}
    测试：
    ①key="a"时，在控制台查看结果。
    主题：first->分区：1
    主题：first->分区：1
    主题：first->分区：1
    主题：first->分区：1
    主题：first->分区：1
    ②key="b"时，在控制台查看结果。
    主题：first->分区：2
    主题：first->分区：2
    主题：first->分区：2
    主题：first->分区：2
    主题：first->分区：2
    ③key="f"时，在控制台查看结果。
    主题：first->分区：0
    主题：first->分区：0
    主题：first->分区：0
    主题：first->分区：0
    主题：first->分区：0

  3. 自定义分区器

    如果研发人员可以根据企业需求，自己重新实现分区器。
1）需求
例如我们实现一个分区器实现，发送过来的数据中如果包含kafka，就发往0号分区，不包含kafka，就发往1号分区
2）实现步骤
	（1）定义类实现Partitioner接口。
	（2）重写partition()方法。
    /**
     * 1. 实现接口Partitioner
     * 2. 实现3个方法:partition,close,configure
     * 3. 编写partition方法,返回分区号
     */
    public class MyPartitioner implements Partitioner {

    /**
     * 返回信息对应的分区
     * @param topic         主题
     * @param key           消息的key
     * @param keyBytes      消息的key序列化后的字节数组
     * @param value         消息的value
     * @param valueBytes    消息的value序列化后的字节数组
     * @param cluster       集群元数据可以查看分区信息
     * @return
     */
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, 		Cluster cluster) {

        // 获取消息
        String msgValue = value.toString();

        // 创建partition
        int partition;

        // 判断消息是否包含kafka
        if (msgValue.contains("kafka")){
            partition = 0;
        }else {
            partition = 1;
        }

        // 返回分区号
        return partition;
    }

    // 关闭资源
    @Override
    public void close() {

    }

    // 配置方法
    @Override
    public void configure(Map<String, ?> configs) {

   	 	}
	}
	
    （3）使用分区器的方法，在生产者的配置中添加分区器参数。
   
    public class CustomProducerCallbackPartitions {

        public static void main(String[] args) throws InterruptedException {

            Properties properties = new Properties();

            properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.178.233.26:9092");

            properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
            properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, 											StringSerializer.class.getName());

            // 添加自定义分区器
    properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"com.LPY.kafka.producer.MyPartitioner");

            KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

            for (int i = 0; i < 5; i++) {

                kafkaProducer.send(new ProducerRecord<>("first", "kafka" + i), new Callback() {
                    @Override
                    public void onCompletion(RecordMetadata metadata, Exception e) {
                        if (e == null){
                            System.out.println("主题：" + metadata.topic() + "->" + "分区：" + 											metadata.partition()
                            );
                        }else {
                            e.printStackTrace();
                        }
                    }
                });
            }

            kafkaProducer.close();
        }
    }
    （4）测试
    ①在hadoop102上开启Kafka消费者。
   	bin/kafka-console-consumer.sh --bootstrap-server 192.178.233.26:9092 --topic first
    ②在IDEA控制台观察回调信息。
    主题：first->分区：0
    主题：first->分区：0
    主题：first->分区：0
    主题：first->分区：0
	主题：first->分区：0

  4. 生产者如何提高吞吐量

    1：batch.size：批次大小，默认16K
  linger.ms：等待时间，修改为5-100ms
  compression.type：压缩snappy
  RecordAccumulator：缓冲区大小，修改为64m
  
  public class CustomProducerParameters {

    public static void main(String[] args) throws InterruptedException {

        // 1. 创建kafka生产者的配置对象
        Properties properties = new Properties();

        // 2. 给kafka配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.233.26:9092");
        
        // key,value序列化（必须）：key.serializer，value.serializer
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        // batch.size：批次大小，默认16K
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);

        // linger.ms：等待时间，默认0
        properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);

        // RecordAccumulator：缓冲区大小，默认32M：buffer.memory
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);

        // compression.type：压缩，默认none，可配置值gzip、snappy、lz4和zstd
		properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");

        // 3. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 4. 调用send方法,发送消息
        for (int i = 0; i < 5; i++) {

            kafkaProducer.send(new ProducerRecord<>("first","kafka " + i));

        }

        // 5. 关闭资源
        kafkaProducer.close();
    }
} 
    测试：
    ①在192.168.233.26上开启Kafka消费者。
        bin/kafka-console-consumer.sh --bootstrap-server 192.168.233.26:9092 --topic first
    ②在IDEA中执行代码，观察192.168.233.26控制台中是否接收到消息。
    	bin/kafka-console-consumer.sh --bootstrap-server 192.168.233.26:9092 --topic first

        kafka 0
        kafka 1
        kafka 2
        kafka 3
        kafka 4

  5. 数据可靠性

    1：ack应答原理
	acks:0 生产者发送过来的数据，不需要等数据落盘应答。   数据可靠性分析：丢数据
		 1：生产者发送过来数据，leader收到数据后应答。   数据可靠性分析：丢数据
		 	当leader应答完成之后，还没有开始同步副本，这个时候leader挂了，那么新的leader不会
		 	收到生产者发送的消息，因为生产者已经认为发送成功了，会丢失数据
		 -1：生产者发送过来的数据，leader和ISR队列里面的所有节点收到数据后应答
		 	 思考：当leader收到数据，所有的follower都开始同步数据，但是有一个follower，因为某种故障，迟迟不能与
		 	 leader进行同步，那么这个问题怎么解决？
		 	 leader维护了一个动态的in-sync replica set(ISR)，意为和leader保持同步的follower+leader集合，
		 	 （leader:0,isr:0,1,2)。
		 	 如果follower长时间未向leader发送通信请求或同步数据，则该follower将被踢出ISR，该时间
		 	 阈值由replica.lag.time.max.ms参数设定，默认30s，例如follower2超时，则(leader:0,ISR:0,1)
		 	 这样就不用等长期联系不上或者已经故障的节点。
	数据可靠性分析：如果分区副本设置为1，或者ISR里应答的最小副本数量min.insync.replica默认为1，和ack=1的效果是一样的
				  仍然有丢失的风险(leader:0,ISR:0).
	数据完全可靠条件 = ack级别设为-1 + 分区副本大于等于2 + ISR中应答的最小副本数量大于等与2
	可靠性总结：
		acks=0,生产者发送过来数据就不管了，可靠性差，效率高
		acks=1,生产者发送过来的数据leader应答，可靠性中等，效率中等
		acks=-1,生产者发送过来数据leader和ISR队列中所有的follower应答，可靠性高，效率低
		在生产环境中，acks=0很少使用，acks=1一般用于传输普通日志，允许丢失个别数据，acks=-1.一般用于
		传输和钱相关的数据，对可靠性要求比较高的场景
2：数据重复分析：
	acks=-1，生产者发送过来的数据，leader和ISR队列中所有的节点收到数据后应答
	如果leader和follower都收到数据了，但是此时leader发出应答时挂掉了，那么生产者会根据配置的重试次数，
	进行重试，次数发生数据重复
	public class CustomProducerAck {

    public static void main(String[] args) throws InterruptedException {

        // 1. 创建kafka生产者的配置对象
        Properties properties = new Properties();

        // 2. 给kafka配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.233.26:9092");
        
        // key,value序列化（必须）：key.serializer，value.serializer
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        // 设置acks
        properties.put(ProducerConfig.ACKS_CONFIG, "all");

        // 重试次数retries，默认是int最大值，2147483647
        properties.put(ProducerConfig.RETRIES_CONFIG, 3);

        // 3. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 4. 调用send方法,发送消息
        for (int i = 0; i < 5; i++) {

            kafkaProducer.send(new ProducerRecord<>("first","kafka " + i));

        }

        // 5. 关闭资源
        kafkaProducer.close();
    }
}

  6. 数据去重

    1：至少一次：ack级别设置为-1 + 分区副本大于等于2 + ISR中应答的最小副本数大于等于2
2：最多一次：ack级别设置为0
总结：至少一次可以保证数据不丢失，但是不能保证数据不重复
	 最多一次可以保证数据不重复，但是不能保证数据不丢失
	 精确一次：对于一些非常重要的消息，比如和钱相关的数据，要求数据既不能重复也不能丢失，kafka引入和一项重大特性，
	 幂等性和事务

  7. 幂等性

    1：幂等性原理：
	幂等性就是指producer不论向broker发送多少次重复请求，broker都只会持久化一条，保证了不重复，
	精确一次 = 幂等性 + 至少一次（ack = -1 + 分区副本>=2 + ISR最小副本数量>=2）。
	重复数据的判断标准：具有<PID,Partition,SeqNumber>相同主键的消息提交时，broker只会持久化一条，
	其中PID是kafak每次重启都会分配一个新的，partition表示分区号，Sequence Number是单调自增的。
	所以幂等性只能保证的是在单个分区内单会话内不重复
2：如何使用幂等性
	开启参数enable.idempotence 默认为true，false关闭

  8. 生产者事务

    1）Kafka事务介绍
	Kafka同时引入了事务的特性，为了实现跨分区跨会话的事务，需要引入一个全局唯一的Transaction ID，并将Producer获得的PID和Transaction ID绑定。这样当Producer重启后就可以通过正在进行的Transaction ID获得原来的PID。
	为了管理Transaction，Kafka引入了一个新的组件Transaction Coordinator。Producer就是通过和Transaction Coordinator交互获得Transaction ID对应的任务状态。Transaction Coordinator还负责将事务所有写入Kafka的一个内部Topic，这样即使整个服务重启，由于事务状态得到保存，进行中的事务状态可以得到恢复，从而继续进行。
	注意：提前开启幂等性!!!

  9. 数据有序

    单分区内，有序，但是有条件，

    多分区，分区与分区间无序

  10. 数据乱序

    1：kafka在1.x版本之前保证数据单分区有序，条件如下：
	max.in.flight.requests.per.connection=1 不需要考虑是否开启幂等性
2：kafka在1.x及以后版本保证数据单分区有序，条件如下：
	1：未开启幂等性
		max.in.flight.requests.per.connection需要设置为1
	2：开启幂等性
		max.in.flight.requests.per.connection需要设置小于等于5
		原因说明：因为kafka1.x以后，启用幂等后，kafka服务端会缓存producer发来的最近5个request的元数据，
			    故无论如何，都可以保证最近5个request的数据都是有序的
			    InFlightRequests,默认每个broker最多缓存5个请求
			    如果开启了幂等性且缓存的请求个数小于5个，会在服务端重新排序
莫得等待
关注
  • 19
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kafka 生产者
01-20
【Kafka 生产者详解】 Kafka 生产者是 Kafka 集群中负责将数据发布到主题的应用程序组件。在 Kafka 中，生产者通过创建 `ProducerRecord` 对象来构造消息，该对象包含了目标主题、消息内容以及可选的键和分区信息。...
kafka-producer:kafka生产者
04-30
【Kafka生产者】是Apache Kafka中的一个关键组件，它负责将消息生产到主题（topics）中。在本文中，我们将深入探讨KafkaProducer在Java环境下的实现，特别是在SpringBoot 1.5版本中，使用JDK 1.8和Kafka 0.10.0.0...
Kafka 生产者
逆流者的博客
03-13 2883
生产者消息发送流程 发送原理 在消息发送的过程中，涉及到了两个线程——main 线程和 Sender 线程。在 main 线程中创建了一个双端队列 RecordAccumulator。main 线程将消息发送给 RecordAccumulator，Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka Broker。 batch.size：只有数据积累到batch.size之后，sender才会发送数据。默认16k ； linger.ms：如果数据迟迟未达到batch.
Kafka生产者分区
热门推荐
01-15 4万+
生产环境中，我们往往需要更加自由的分区需求，我们可以自定义分区器。需求：在上面的根据key分区案例中，我们发现与我们知道的hash分区结果不同。那么我们就实现一个。3．实现步骤：① 定义类，实现Partitioner接口② 重写partition()方法代码实现：/*** 1. 实现接口Partitioner* 2. 实现3个方法:partition,close,configure* 3. 编写partition方法,返回分区号/*** 分区方法。
查询Kafka生产者是否连接到Kafka服务
最新发布
weixin_44976692的博客
06-22 5万+
java领域优质创作者🌐。
Kafka 生产者详解
程序员cxuan的个人主页
11-14 4400
上一篇文章我们主要介绍了什么是 Kafka，Kafka 的基本概念是什么，Kafka 单机和集群版的搭建，以及对基本的配置文件进行了大致的介绍，还对 Kafka 的几个主要角色进行了描述，我们知道，不管是把 Kafka 用作消息队列、消息总线还是数据存储平台来使用，最终是绕不过消息这个词的，这也是 Kafka 最最核心的内容，Kafka 的消息从哪里来？到哪里去？都干什么了？别着急，一步一步来，先...
Kafka生产者详解
mxk4869的博客
07-11 1921
Kafka生产者详解
kafka生产者消费者举例
hac1322的博客
05-11 1275
Kafka是一款分布式流处理平台，它被设计用于高吞吐量、持久性、分布式的数据流处理。Kafka 简介Kafka 是一个高吞吐、分布式、基于发布订阅的消息系统。Kafka 具有高吞吐量、低延迟、可扩展性、持久性、可靠性、容错性、高并发等特性。Kafka 应用场景日志收集：公司可以使用 Kafka 收集各种服务的日志，然后通过 Kafka 统一接口服务的方式将这些日志开放给各种消费者，例如 Hadoop、Hbase、Solr 等。消息系统：Kafka 可以解耦生产者和消费者，缓存消息等。用户活动跟踪。
Kafka生产者之分区
G823909的博客
11-26 1896
如果研发人员可以根据企业需求，自己重新实现分区器；/*** 1. 实现接口 Partitioner* 2. 实现 3 个方法:partition,close,configure* 3. 编写 partition 方法,返回分区号/*** 返回信息对应的分区* @param topic 主题* @param key 消息的 key* @param keyBytes 消息的 key 序列化后的字节数组* @param value 消息的 value。
kafka生产者和消费者
qq_70085330的博客
06-18 1917
Kafka生产者和消费者
Kafka生产者原理与优化
wdquan19851029的专栏
04-14 2667
Kafka生产者生产消息，基本上包括下面几个部分： 线程：多个线程可以操作同一个kafkaProducer去生产消息，并且可以给多个不同的topic生产消息 kafkaProducer: kafka消息生产者，具体对应kafka的一个java类，里面包含了partitioner分区器（根据具体消息的key去选择发送到哪个分区，如果没有key则轮询选择分区）；accumulator累加器(针对缓冲区进行操作，缓存产生的消息，缓冲区大小可以根据业务调优-优化)，还有双向队列dq用来缓存消息（缓冲区中），dq
Kafka 生产者及消费者详解
mengxianglong123的博客
10-06 2885
一、Kafka 生产者 1.1 分区策略 1）分区的原因 （1）方便在集群中扩展，每个Partition可以通过调整以适应它所在的机器，而一个topic又可以有多个Partition组成，因此整个集群就可以适应任意大小的数据了； （2）可以提高并发，因为可以以Partition为单位读写了。 2）分区的原则 我们需要将producer发送的数据封装成一个ProducerRecord对象。 （1）指明 partition 的情况下，直接将指明的值直接作为 partiton 值； （2）没有指明 partit
Java实现Kafka生产者消费者代码实例
08-19
主要介绍了Java实现Kafka生产者消费者代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
kafka生产者源码
09-25
kafka生产者流程图，源码分析，（png）
kafka生产者连接池
05-12
为了优化性能和提高效率，开发人员常常会利用连接池技术来管理Kafka生产者的连接。本文将深入探讨"Kafka生产者连接池"的概念、实现原理以及它如何提升系统性能。 Kafka生产者连接池是一种资源复用机制，它允许多个...
kafka生产者-实例参数配置.md
07-24
kafka生产者参数配置使用于各种编程语言重要参数已标明kafka生产者参数配置使用于各种编程语言重要参数已标明
kettle整合kafka生产者消费者插件
06-12
kettle7.1版本整合kafka，kafka插件包含生产者、消费者。直接在kettle安装目录plugins下创建steps目录，并解压下载文件到kettle/plugins/steps目录。具体可查看我博文。
springboot集成kafka实战项目，kafka生产者、消费者、创建topic，指定消费分区
01-04
在本项目中，我们将深入探讨如何使用Spring Boot与Kafka进行集成，实现一个实战项目，包括Kafka的生产者、消费者以及如何创建Topic，并且特别关注指定消费分区这一高级特性。Kafka是一款高吞吐量的分布式消息系统，...
kafka生产者消费者Demo
12-21
在这个“kafka生产者消费者Demo”中，我们将深入理解Kafka的基本概念、生产和消费过程，以及如何配置和运行示例代码。 首先，Kafka是一个高吞吐量、分布式的发布/订阅消息系统，最初由LinkedIn开发，后来成为了...
kafka生产者消费者
12-01
以下是Kafka生产者和消费者的介绍和演示： 1. Kafka生产者 Kafka生产者将消息发布到主题中。以下是一个简单的Python示例，演示如何使用Kafka生产者API将消息发布到主题中： ```python from kafka import ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值