kafka如何同步数据 kafka 同步发送

一、生产者消息发送流程

1、发送原理      

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

2、生产者重要参数列表

---

二、Kafka生产者之异步发送

1、普通异步发送

1.1、需求：创建 Kafka 生产者，采用异步的方式发送到 Kafka Broker

 1)、代码编写

  在java的pom.xm中引入maven依赖

<dependency>
 <groupId>org.apache.kafka</groupId>
 <artifactId>kafka-clients</artifactId>
 <version>3.0.0</version>
 </dependency>

编写不带回调函数的 API 代码

package com.kafka.demo;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class CustomProducer {

    public static void main(String[] args) {

        //1、创建Properties配置信息对象
        Properties properties = new Properties();
        //2、配置kafka集群信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"conch01:9092,conch02:9092,conch03:9092");
        //3、指定key和value序列化的类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        //4、创建生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        //5、使用生产者发送数据
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<String, String>("first","test"+i));
        }
        //6、关闭资源
        kafkaProducer.close();
    }

}

注意：这里我们在主机的hosts里面配置主机名映射,因为使用ip地址，有可能消息发布出去

路径：C:\WINDOWS\system32\drivers\etc\hosts

2）、创建first主题

# 主题名称叫做topic,3个分区,副本数量是3 bin/kafka-topics.sh --bootstrap-server 192.168.56.20:9092 --create --partitions 3 --replication-factor 3 --topic first

3）、打开消费者，等待上面的生产者代码执行发送数据

bin/kafka-console-consumer.sh --bootstrap-server 192.168.56.20:9092,192.168.56.21:9092,192.168.56.22:9092 --topic first

 

4）、在 IDEA 中执行代码，观察 消费者控制台中是否接收到消息。

2、带回调函数的异步发送

        回调函数会在 producer 收到 ack 时调用，为异步调用，该方法有两个参数，分别是元数据信息（RecordMetadata）和异常信息（Exception），如果 Exception 为 null，说明消息发送成功，如果 Exception 不为 null，说明消息发送失败。

代码如下：

package com.kafka.demo;import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class CustomProducerCallback {

    public static void main(String[] args) {

        //1、创建Properties配置信息对象
        Properties properties = new Properties();
        //2、配置kafka集群信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"conch01:9092,conch02:9092,conch03:9092");
        //3、指定key和value序列化的类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        //

4、创建生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        //5、使用生产者发送数据
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<String, String>("first", "test测试回调" + i), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        // 没有异常,输出信息到控制台
                        System.out.println(" 主题： " + recordMetadata.topic() + "->" + "分区：" + recordMetadata.partition());
                    } else {
                        // 出现异常打印
                        e.printStackTrace();
                    }
                }
            });
        }
        //6、关闭资源
        kafkaProducer.close();
    }

}

注意：消息发送失败会自动重试，不需要我们在回调函数中手动重试。

在 IDEA 中执行代码，观察 消费者控制台中是否接收到消息。

我们看一下java控制台返回的数据：

---

三、kafka之同步发送 API

1、同步发送的流程如下

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

 完整代码如下：

package com.kafka.demo;import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;
import java.util.concurrent.ExecutionException;

public class CustomProducerSync {

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

        //1、创建Properties配置信息对象
        Properties properties = new Properties();
        //2、配置kafka集群信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"conch01:9092,conch02:9092,conch03:9092");
        //3、指定key和value序列化的类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        //4、创建生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        //5、使用生产者发送数据
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<String, String>("first", "test" + i)).get();
        }
        //6、关闭资源
        kafkaProducer.close();
    }

}

四、生产者分区的好处

1、 分区好处

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

1）默认的分区器 DefaultPartitioner
在 IDEA 中 ctrl +n，全局查找 DefaultPartitioner。

/**
* The default partitioning strategy:
* <ul>
* <li>If a partition is specified in the record, use it
* <li>If no partition is specified but a key is present choose a 
partition based on a hash of the key
* <li>If no partition or key is present choose the sticky 
partition that changes when the batch is full.
* 
* See KIP-480 for details about sticky partitioning.
*/

 2）案例一
将数据发往指定 partition 的情况下，例如，将所有数据发往分区 1 中。

完整代码如下：

package com.kafka.demo;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class CustomProducerPartition {

    public static void main(String[] args) {

        //1、创建Properties配置信息对象
        Properties properties = new Properties();
        //2、配置kafka集群信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"conch01:9092,conch02:9092,conch03:9092");
        //3、指定key和value序列化的类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        //4、创建生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        //5、使用生产者发送数据
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<String, String>("first",1,"","test测试指定分区没有key值" + i), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        // 没有异常,输出信息到控制台
                        System.out.println(" 主题： " + recordMetadata.topic() + "->" + "分区：" + recordMetadata.partition());
                    } else {
                        // 出现异常打印
                        e.printStackTrace();
                    }
                }
            });
        }
        //6、关闭资源
        kafkaProducer.close();
    }

}

 测试：在 conch01上开启 Kafka 消费者。

bin/kafka-console-consumer.sh --bootstrap-server 192.168.56.20:9092,192.168.56.21:9092,192.168.56.22:9092 --topic first

 3）案例二:
        没有指明 partition 值但有 key 的情况下，将 key 的 hash 值与 topic 的 partition 数进行取余得到 partition 值。

 

测试：
①key="a"时，在控制台查看结果。

②key="b"时，在控制台查看结果。

 

 ③key="f"时，在控制台查看结果。

3、自定义分区器

        研发人员可以根据企业需求，自己重新实现分区器。

1）需求
例如我们实现一个分区器实现，发送过来的数据中如果包含 atguigu，就发往 0 号分区，不包含 atguigu，就发往 1 号分区。

2）实现步骤
（1）定义类实现 Partitioner 接口。
（2）重写 partition()方法。

package com.kafka.demo;import org.apache.kafka.clients.producer.Partitioner;import org.apache.kafka.common.Cluster;

import java.util.Map;

/**
 * 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
     */
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        // 获取消息
        String msgValue = value.toString();
        // 创建 partition
        int partition;
        // 判断消息是否包含 atguigu
        if (msgValue.contains("atguigu")){
            partition = 0;
        }else {
            partition = 1;
        }
        // 返回分区号
        return partition;
    }

    /***
     * 关闭资源
     */
    public void close() {

    }

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

    }
}

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

4）测试
①在 conch01上开启 Kafka 消费者。 

bin/kafka-console-consumer.sh --bootstrap-server 192.168.56.20:9092,192.168.56.21:9092,192.168.56.22:9092 --topic first

 

②在 IDEA 控制台观察回调信息。

 

---

五、生产者如何提高吞吐量

package com.kafka.demo;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class CustomProducerParameter {

    public static void main(String[] args) {

        //1、创建Properties配置信息对象
        Properties properties = new Properties();
        //2、配置kafka集群信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"conch01:9092,conch02:9092,conch03:9092");
        //3、指定key和value序列化的类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        // 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");
        //4、创建生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        //5、使用生产者发送数据
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<String, String>("first", "test测试参数配置提高吞吐量" + i), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        // 没有异常,输出信息到控制台
                        System.out.println(" 主题： " + recordMetadata.topic() + "->" + "分区：" + recordMetadata.partition());
                    } else {
                        // 出现异常打印
                        e.printStackTrace();
                    }
                }
            });
        }
        //6、关闭资源
        kafkaProducer.close();
    }

}

 测试：
①在 conch01上开启 Kafka 消费者。

bin/kafka-console-consumer.sh --bootstrap-server 192.168.56.20:9092,192.168.56.21:9092,192.168.56.22:9092 --topic first

 

②在 IDEA 中执行代码，观察 conch01控制台中是否接收到消息。

---

六、数据可靠性

 

1）ack 应答原理

isr： 

 2）代码配置

// 设置 acks properties.put(ProducerConfig.ACKS_CONFIG, "all");
 // 重试次数 retries，默认是 int 最大值，2147483647
 properties.put(ProducerConfig.RETRIES_CONFIG, 3);package com.kafka.demo;import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class CustomProducerAck {

    public static void main(String[] args) {

        //1、创建Properties配置信息对象
        Properties properties = new Properties();
        //2、配置kafka集群信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"conch01:9092,conch02:9092,conch03:9092");
        //3、指定key和value序列化的类型
        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);

        //4、创建生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        //5、使用生产者发送数据
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<String, String>("first", "test测试ack" + i));
        }
        //6、关闭资源
        kafkaProducer.close();
    }

}

---

七、数据去重

1、数据传递语义

• 至少一次（At Least Once）= ACK级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2
• 最多一次（At Most Once）= ACK级别设置为0

• 总结：

        At Least Once可以保证数据不丢失，但是不能保证数据不重复；
        At Most Once可以保证数据不重复，但是不能保证数据不丢失。

• 精确一次（Exactly Once）：对于一些非常重要的信息，比如和钱相关的数据，要求数据既不能重复也不丢失。

Kafka 0.11版本以后，引入了一项重大特性：幂等性和事务。

2、幂等性

1）幂等性原理

2）如何使用幂等性
开启参数 enable.idempotence 默认为 true，false 关闭。 

3、生产者事务

1）Kafka 事务原理

2）Kafka 的事务一共有如下 5 个 API

// 1 初始化事务
void initTransactions();
// 2 开启事务
void beginTransaction() throws ProducerFencedException;
// 3 在事务内提交已经消费的偏移量（主要用于消费者）
void sendOffsetsToTransaction(Map<TopicPartition, OffsetAndMetadata> offsets, String consumerGroupId) throws ProducerFencedException;
// 4 提交事务
void commitTransaction() throws ProducerFencedException;
// 5 放弃事务（类似于回滚事务的操作）
void abortTransaction() throws ProducerFencedException;

 3）单个 Producer，使用事务保证消息的仅一次发送需指定事务id

package com.kafka.demo;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.errors.ProducerFencedException;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class CustomProducerTranzactions {

    public static void main(String[] args) {

        //1、创建Properties配置信息对象
        Properties properties = new Properties();
        //2、配置kafka集群信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"conch01:9092,conch02:9092,conch03:9092");
        //3、指定key和value序列化的类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        // 指定事务id
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"tranactional_id_01");

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

        kafkaProducer.initTransactions();
        kafkaProducer.beginTransaction();

        try {
            //5、使用生产者发送数据
            for (int i = 0; i < 5; i++) {
                kafkaProducer.send(new ProducerRecord<String, String>("first", "test测试事务" + i));
            }
            int i = 1/0;
            kafkaProducer.commitTransaction();
        } catch (ProducerFencedException e) {
            kafkaProducer.abortTransaction();
        } finally {
            //6、关闭资源
            kafkaProducer.close();
        }
    }

}

---

八、数据有序

---

九、数据乱序