Logstash 消费 kafka 写入 kafka

第一章 Kafka概述--消息中间件（微信）

1.1 定义

kafka 非常的重要，做实时或者准实时项目必用工具（绕不开）。Kafka就是用来存储消息的，消息中间件。

Kafka是分布式的发布—订阅消息系统。它最初由LinkedIn(领英)公司发布，使用Scala语言编写，于2010年12月份开源，成为Apache的顶级项目。Kafka是一个高吞吐量的、持久性的、分布式发布订阅消息系统。它主要用于处理活跃live的数据(登录、浏览、点击、分享、喜欢等用户行为产生的数据)。
     kafka 在大数据技术中，属于实时计算架构中的一员悍将！

Scala语言的底层是Java。越底层速度越快。
    
   Kafka传统定义：Kafka是一个分布式的基于发布/订阅模式的消息队列（Message Queue），主要应用于大数据实时处理领域。
   Java工程师：  一辈子都在研究高并发。
   大数据工程师：做分析（离线、实时）【分析过往数据，也可以预测未来】
    发布/订阅：消息的发布者不会将消息直接发送给特定的订阅者，而是将发布的消息分为不同的类别，订阅者只接收感兴趣的消息。
    
   Kafka最新定义 ： Kafka是 一个开源的分布式事件流平台（Event Streaming Platform），被数千家公司用于高性能数据管道、流分析、数据集成和关键任务应用。

   IBM--全球最大的信息技术和业务解决方案公司，xxx领导者。

   Spring框架（所谓的java工程师其实已经演变为了Spinrg工程师，比如SpingMVC Spring Spring数据库\分布式框架 SpringCloud -->SpringCloud Alibaba）

日常由于磁盘的读取速度是100M/S 左右，日常flume --> Hadoop 是可以的，但是双十一的话，采集速度超过100M/S 就会造成 Hadoop无法处理的情况，此时可以使用KAFKA.

kafka类似于这个悬挂。 

1.2、kafka的中的组成成员

kafka四大核心

生产者API
允许应用程序发布记录流至一个或者多个kafka的主题（topics）。

消费者API
允许应用程序订阅一个或者多个主题，并处理这些主题接收到的记录流

StreamsAPI
允许应用程序充当流处理器（stream processor），从一个或者多个主题获取输入流，并生产一个输出流到一个或 者多个主题，能够有效的变化输入流为输出流。

ConnectorAPI
允许构建和运行可重用的生产者或者消费者，能够把kafka主题连接到现有的应用程序或数据系统。例如：一个连 接到关系数据库的连接器可能会获取每个表的变化。

1.3 消息队列（中间件）

目前企业中比较常见的 消息 队列产 品主 要有Kafka、ActiveMQ 、RabbitMQ 、 RocketMQ 等。

在大数据场景主要采用 Kafka 作为消息队列。在 JavaEE 开发中主要采用 ActiveMQ、 RabbitMQ、RocketMQ。

Kafka:  是最适用于大数据技术的消息中间件。  
RabbitMQ: Erlang编写。
RocketMQ: 阿里出品，纯java，性能特别好，但是特别大，不好安装，还收费。
ActiveMQ: 实现了SUN公司当年JMS规范的，学习成本不高，也比较好用，性能不是特别高。
Redis: 也有分布订阅模式，但是一般不说它是消息中间件。（别深究，缓存之王）

1.3.1 传统消息队列的应用场景

传统的消息队列的主要应用场景包括：缓存/消峰（削峰填谷）、解耦和异步通信。

- 解耦 各系统之间通过消息系统这个统一的接口交换数据，无须了解彼此的存在
        重要的作用
- 冗余 部分消息系统具有消息持久化能力，可规避消息处理前丢失的风险
- 扩展 消息系统是统一的数据接口，各系统可独立扩展
- 峰值处理能力 消息系统可顶住峰值流量，业务系统可根据处理能力从消息系统中获取并处理对应量的请求
       重要的作用
- 可恢复性 系统中部分键失效并不会影响整个系统，它恢复会仍然可从消息系统中获取并处理数据
- 异步通信 在不需要立即处理请求的场景下，可以将请求放入消息系统，合适的时候再处理

场景解释：

缓冲/削峰（萧峰）：有助于控制和优化数据流经过系统的速度，解决生产消息和消费消息的处理速度不一致的情况。

削峰填谷

双十一假如每秒有10亿人/s ，但是集群处理能力只有1千万人/s ，此时是顶不住压力的，所以可以中间添加一个消息队列来解决这个问题。

 解耦：允许你独立的扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束（媒婆）

异步通信：允许用户把一个消息放入队列，但并不立即处理它，然后在需要的时候再去处理它们。

1.3.2 消息队列的两种模式

1.4 Kafka 基础架构

ISR:In-Sync Replicas isr 是一个副本的列表，里面存储的都是能跟leader 数据一致的副本

1）Producer：消息生产者，就是向 Kafka broker 发消息的客户端。 
2）Consumer：消息消费者，向 Kafka broker 取消息的客户端。 
3）Consumer Group（CG）：消费者组，由多个 consumer 组成。消费者组内每个消 费者负责消费不同分区的数据，一个分区只能由一个组内消费者消费；消费者组之间互不影响。所有的消费者都属于某个消费者组，即消费者组是逻辑上的一个订阅者。 
4）Broker：一台 Kafka 服务器就是一个 broker。一个集群由多个 broker 组成。一个 broker 可以容纳多个 topic。 
5）Topic：可以理解为一个队列，生产者和消费者面向的都是一个 topic。 
6）Partition：为了实现扩展性，一个非常大的 topic 可以分布到多个 broker（即服务器）上，一个 topic 可以分为多个 partition，每个 partition 是一个有序的队列。 
7）Replica：副本。一个 topic 的每个分区都有若干个副本，一个 Leader 和若干个 Follower。
8）Leader：每个分区多个副本的“主”，生产者发送数据的对象，以及消费者消费数据的对象都是 Leader。 
9）Follower：每个分区多个副本中的“从”，实时从 Leader 中同步数据，保持和 Leader 数据的同步。Leader 发生故障时，某个 Follower 会成为新的 Leader。

1.5、kafka的名词概念

- Kafka服务：
- Topic：主题，Kafka处理的消息的不同分类。
- Broker：消息服务器代理，Kafka集群中的一个kafka服务节点称为一个broker，主要存储消息数据。存在硬盘中。每个topic都是有分区的。
- Partition：Topic物理上的分组，一个topic在broker中被分为1个或者多个partition，分区在创建topic的时候指定。
- Message：消息，是通信的基本单位，每个消息都属于一个partition
- Kafka服务相关
- Producer：消息和数据的生产者，向Kafka的一个topic发布消息。
- Consumer：消息和数据的消费者，定于topic并处理其发布的消息。
- Zookeeper：协调kafka的正常运行。

名词解释：

第一个：Topic

kafka将消息以topic为单位进行归类

topic特指kafka处理的消息源（feeds of messages）的不同分类。

topic是一种分类或者发布的一些列记录的名义上的名字。kafka主题始终是支持多用户订阅的；也就是说，一 个主题可以有零个，一个或者多个消费者订阅写入的数据。

在kafka集群中，可以有无数的主题。

生产者和消费者消费数据一般以主题为单位。更细粒度可以到分区级别。

第二个：分区

Partitions：分区数：控制topic将分片成多少个log，可以显示指定，如果不指定则会使用 broker（server.properties）中的num.partitions配置的数量。
一个broker服务下，是否可以创建多个分区？
可以的，broker数与分区数没有关系； 在kafka中，每一个分区会有一个编号：编号从0开始
每一个分区的数据是有序的

说明-数据是有序 如何保证一个主题下的数据是有序的？（生产是什么样的顺序，那么消费的时候也是什么样的顺序）

topic的Partition数量在创建topic时配置。

Partition数量决定了每个Consumer group中并发消费者的最大数量。

Consumer group A 有两个消费者来读取4个partition中数据；Consumer group B有四个消费者来读取4个 partition中的数据

第三个：副本数

副本数（replication-factor）：控制消息保存在几个broker（服务器）上，一般情况下等于broker的个数
一个broker服务下，是否可以创建多个副本因子？
不可以；创建主题时，副本因子应该小于等于可用的broker数。 副本因子过程图

副本因子的作用：让kafka读取数据和写入数据时的可靠性。

副本因子是包含本身|同一个副本因子不能放在同一个Broker中。

如果某一个分区有三个副本因子，就算其中一个挂掉，那么只会剩下的两个钟，选择一个leader，但不会在其 他的broker中，另启动一个副本（因为在另一台启动的话，存在数据传递，只要在机器之间有数据传递，就 会长时间占用网络IO，kafka是一个高吞吐量的消息系统，这个情况不允许发生）所以不会在零个broker中启 动。

如果所有的副本都挂了，生产者如果生产数据到指定分区的话，将写入不成功。

lsr表示：当前可用的副本

第四个：kafka Partition offset

任何发布到此partition的消息都会被直接追加到log文件的尾部，每条消息在文件中的位置称为offset（偏移量），
offset是一个long类型数字，它唯一标识了一条消息，消费者通过（offset，partition，topic）跟踪记录。

第五个：分区数和消费组的关系

消费组： 由一个或者多个消费者组成，同一个组中的消费者对于同一条消息只消费一次。某一个主题下的分区数，对于消费组来说，应该小于等于该主题下的分区数。如下所示：

如：某一个主题有4个分区，那么消费组中的消费者应该小于4，而且最好与分区数成整数倍
1	2	4
同一个分区下的数据，在同一时刻，不能被同一个消费组的不同消费者消费

总结：分区数越多，同一时间可以有越多的消费者来进行消费，消费数据的速度就会越快，提高消费的性能.

第 2 章 Kafka 快速入门

2.1 安装部署

2.1.1 集群规划

bigdata01	bigdata02	bigdata03
zk	zk	zk
kafka	kafka	kafka

2.1.2 集群部署

0）官方下载地址：http://kafka.apache.org/downloads.html

检查三台zk是否启动：

zkServer.sh start 默认启动方式

也可以使用脚本启动 zk.sh start

1）解压安装包

kafka中 2.12 是scala语言的版本，3.0.0是kafka版本

tar -zxvf kafka_2.12-3.0.0.tgz -C /opt/installs/

2）修改解压后的文件名称

mv kafka_2.12-3.0.0/ kafka3

3）进入到/opt/installs/kafka3 目录，修改配置文件

cd config/ 
vi server.properties

修改红色部分：

#broker 的全局唯一编号，不能重复，只能是数字。 
broker.id=0 
#处理网络请求的线程数量 
num.network.threads=3 
#用来处理磁盘 IO 的线程数量 
num.io.threads=8 
#发送套接字的缓冲区大小 
socket.send.buffer.bytes=102400 
#接收套接字的缓冲区大小 
socket.receive.buffer.bytes=102400 
#请求套接字的缓冲区大小 
socket.request.max.bytes=104857600 
#kafka 运行日志(数据)存放的路径，路径不需要提前创建，kafka 自动帮你创建，可以 
配置多个磁盘路径，路径与路径之间可以用"，"分隔 
log.dirs=/opt/installs/kafka3/datas 
#topic 在当前 broker 上的分区个数 
num.partitions=1 
#用来恢复和清理 data 下数据的线程数量 
num.recovery.threads.per.data.dir=1 
# 每个 topic 创建时的副本数，默认时 1 个副本 
offsets.topic.replication.factor=1 
#segment 文件保留的最长时间，超时将被删除 
log.retention.hours=168 
#每个 segment 文件的大小，默认最大 1G 
log.segment.bytes=1073741824
# 检查过期数据的时间，默认 5 分钟检查一次是否数据过期 
log.retention.check.interval.ms=300000 
#配置连接 Zookeeper 集群地址（在 zk 根目录下创建/kafka，方便管理） 
zookeeper.connect=bigdata01:2181,bigdata02:2181,bigdata03:2181/kafka
/kafka的意思是：在zk中创建一个文件夹叫做kafka

4）分发安装包

xsync.sh kafka3/

scp /opt/installs/kafka3 root@hadoop12:/opt/installs

5）分别在 bigdata02 和 bigdata03上修改配置文件/opt/installs/kafka/config/server.properties 中的 broker.id=1、broker.id=2

注：broker.id 不得重复，整个集群中唯一。

6）配置环境变量

（1）修改bigdata01的环境变量，增加如下内容：

#KAFKA_HOME 
z'k

分发一下：
xsync.sh /etc/profile

（2）刷新一下环境变量。

xcall.sh source /etc/profile

7）启动集群

（1）先启动 Zookeeper 集群，然后启动 Kafka。

xcall.sh zkServer.sh start

（2）依次在 bigdata01、bigdata02、bigdata03 节点上启动 Kafka。

先进入到kafka3 这个文件夹中，在三台服务器上分别运行启动命令：
bin/kafka-server-start.sh -daemon config/server.properties

关闭集群 ：

在每一台服务器上运行这个

bin/kafka-server-stop.sh

2.1.3 集群启停脚本

1）在/usr/local/sbin 目录下创建文件 kf.sh 脚本文件

vim kf.sh

2) 编写脚本

#! /bin/bash
case $1 in
"start"){
 for i in bigdata01 bigdata02 bigdata03
 do
 echo " --------启动 $i Kafka-------"
 ssh $i "source /etc/profile; /opt/installs/kafka3/bin/kafka-server-start.sh -daemon /opt/installs/kafka3/config/server.properties"
 done
};;
"stop"){
 for i in bigdata01 bigdata02 bigdata03
 do
 echo " --------停止 $i Kafka-------"
 ssh $i "source /etc/profile; /opt/installs/kafka3/bin/kafka-server-stop.sh"
 done
};;
esac

3）添加权限

chmod u+x kf.sh

如何使用：
kf.sh start
kf.sh stop

注意：停止 Kafka 集群时，一定要等 Kafka 所有节点进程全部停止后再停止 Zookeeper 集群。因为 Zookeeper 集群当中记录着 Kafka 集群相关信息，Zookeeper 集群一旦先停止， Kafka 集群就没有办法再获取停止进程的信息，只能手动杀死 Kafka 进程了。

2.2 Kafka 命令行操作

2.2.1 主题命令行操作

1）查看操作主题命令参数

bin/kafka-topics.sh

2）查看当前服务器中的所有 topic 

bin/kafka-topics.sh --bootstrap-server bigdata01:9092 --list

3）创建 first topic

bin/kafka-topics.sh --bootstrap-server bigdata01:9092 --create --partitions 1 --replication-factor 3 --topic first

选项说明： 
--topic 定义 topic 名
--replication-factor 定义副本数
--partitions 定义分区数

4）查看 first 主题的详情

bin/kafka-topics.sh --bootstrap-server bigdata01:9092 --describe --topic first

5）修改分区数（注意：分区数只能增加，不能减少）

bin/kafka-topics.sh --bootstrap-server bigdata01:9092 --alter --topic first --partitions 3

6）再次查看 first 主题的详情

bin/kafka-topics.sh --bootstrap-server bigdata01:9092 --describe --topic first

7）删除 topic

bin/kafka-topics.sh --bootstrap-server bigdata01:9092 --delete --topic first

2.2.2 生产者命令行操作

1）查看操作生产者命令参数

bin/kafka-console-producer.sh

2）发送消息

bin/kafka-console-producer.sh --bootstrap-server bigdata01:9092 --topic first

>hello world

>bigdata bigdata

2.2.3 消费者命令行操作

1）查看操作消费者命令参数

bin/kafka-console-consumer.sh

2）消费消息

（1）消费 first 主题中的数据。

bin/kafka-console-consumer.sh --bootstrap-server bigdata01:9092 --topic first

 （2）把主题中所有的数据都读取出来（包括历史数据）。 

bin/kafka-console-consumer.sh --bootstrap-server bigdata01:9092 --from-beginning --topic first

第 3 章 Kafka 生产者

3.1 生产者消息发送流程

3.1.1 发送原理

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

0:   生产者发送的数据，不需要等数据落盘应答。
1：生产者发送过来的数据，Leader收到数据后应答。
-1：（all）:生产者发送过来的数据，Leader 和 ISR 队列里面的所有节点收齐数据后应答。 -1 和 all 是等价的。

3.1.2 生产者重要参数列表

参数名称	解释说明
bootstrap.servers	生产者连接集群所需的 broker 地 址 清 单 。 例 如hadoop11:9092,hadoop12:9092,hadoop13: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。

3.2 异步发送 API

3.2.1 普通异步发送

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

就是外部数据通过生产者，将数据发送至这个32M的队列中，不用管这个队列中的数据是否发送到了kafka集群。

2）代码编写

（1）创建工程 kafka

（2）导入依赖

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

  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.25</version>
  </dependency>
</dependencies>

（3）创建包名：com.bigdata.kafka.producer
（4）编写不带回调函数的 API 代码

package com.bigdata.producter;

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

import java.util.Properties;

public class CustomProducer01 {

    public static void main(String[] args) {

        // Properties 它是map的一种
        Properties properties = new Properties();
        // 设置连接kafka集群的ip和端口
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"bigdata01:9092");
        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");

        // 创建了一个消息生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 调用这个里面的send方法
        // ctrl + p
        /*ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","告诉你个秘密");
        kafkaProducer.send(producerRecord);*/
        for (int i = 0; i < 5; i++) {
            ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","告诉你个秘密:"+i);
            kafkaProducer.send(producerRecord);
        }

        kafkaProducer.close();
    }
}

通过控制台消费者查看消息：

假如你运行的时候没有日志，如下进行：

# Global logging configuration
#  Debug   info   warn  error 
log4j.rootLogger=DEBUG, stdout
# MyBatis logging configuration...
log4j.logger.org.mybatis.example.BlogMapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

1、导入包（已经导入）
2、拷贝一个log4J.properties文件放入 resources 文件夹
3、清空一下target -- maven clean一下即可。

如果出现如下问题：

记得修改：

C:\Windows\System32\drivers\etc  中 hosts文件中的映射。

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

bin/kafka-console-consumer.sh --bootstrap-server bigdata01:9092 --topic first

3.2.2 带回调函数的异步发送

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

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

package com.bigdata.producter;

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

public class CustomProducer02 {

    public static void main(String[] args) {

        // Properties 它是map的一种
        Properties properties = new Properties();
        // 设置连接kafka集群的ip和端口
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"bigdata01:9092");
        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");

        // 创建了一个消息生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 调用这个里面的send方法
        // ctrl + p
        /*ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","告诉你个秘密");
        kafkaProducer.send(producerRecord);*/
        for (int i = 0; i < 5; i++) {
            ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","告诉你个找女朋友的好办法:"+i);
            // 回调-- 调用之前先商量好，回扣多少。
            kafkaProducer.send(producerRecord, new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {

                    // 获取很多信息，exception == null 说明成功，不为null,说明失败
                    if(exception == null){
                        System.out.println("消息发送成功");
                        System.out.println(metadata.partition());// 三个分区，我什么每次都是2分区，粘性分区
                        System.out.println(metadata.offset());// 13 14 15 16 17
                        System.out.println(metadata.topic());
                    }else{
                        System.out.println("消息发送失败，失败原因："+exception.getMessage());
                    }

                }
            });
        }

        kafkaProducer.close();
    }
}

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

bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first

假如发送消息没有停顿，所有消息都发送给了一个分区，假如发送消息结束，停止2秒，发送的分区就不一样了。

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

主题：first->分区：0 
主题：first->分区：0 
主题：first->分区：1 
主题：first->分区：1 
主题：first->分区：1

3.3 同步发送 API

异步发送有点类似于多线程，同步类似于普通的代码。

同步发送的意思是：一批数据到达队列中之后，这批数据必须全部都达到kafka集群之后，下一波数据才能发送。 

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

package com.bigdata.kafka.producer;

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

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

public class CustomProducerTongBu {

    // 这是一个生产者，生产者发送消息的，发给谁呢？kafka集群！
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        // 这个里面放置配置相关信息
        Properties properties = new Properties();
        properties.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop11:9092");
        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");

        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        for (int i=0;i<5;i++) {
            // 发送 send 方法调用  get() 方法是同步发送。同步发送就是等一批结束后发送另一批
            kafkaProducer.send(new ProducerRecord<>("first","bigdata: "+i)).get();
        }

        kafkaProducer.close();
    }
}

测试：

在 hadoop102 上开启 Kafka 消费者。

bin/kafka-console-consumer.sh --bootstrap-server hadoop11:9092 --topic first

3.4 生产者分区

3.4.1 分区好处

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

3.4.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
    假如发送消息没有指定分区，指定了Key值，对Key进行hash,然后对分区数取模，得到哪个分区就使用哪个分区
* <li>If no partition or key is present choose the sticky 
partition(粘性分区) that changes when the batch is full.
   假如分区和key值都没有指定，使用粘性分区（黏住它，使用它，发送完毕为止）
* 
* See KIP-480 for details about sticky partitioning.
*/
public class DefaultPartitioner implements Partitioner {
 … …
}

案例解析：

例如：第一次随机选择0号分区，等0号分区当前批次满了（默认16k）或者linger.ms设置的时间到， Kafka再随机一个分区进行使用（如果还是0会继续随机）。

2）案例一

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

package com.bigdata.producter;

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

public class CustomProducer04 {

    public static void main(String[] args) {

        // Properties 它是map的一种
        Properties properties = new Properties();
        // 设置连接kafka集群的ip和端口
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"bigdata01:9092");
        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");

        // 创建了一个消息生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 调用这个里面的send方法
        // ctrl + p
        /*ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","告诉你个秘密");
        kafkaProducer.send(producerRecord);*/
        for (int i = 0; i < 5; i++) {
            ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first",0,"keyaaa","告诉你个找女朋友的好办法:"+i);
            // 回调-- 调用之前先商量好，回扣多少。
            kafkaProducer.send(producerRecord, new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {

                    // 获取很多信息，exception == null 说明成功，不为null,说明失败
                    if(exception == null){
                        System.out.println("消息发送成功");
                        System.out.println(metadata.partition());// 三个分区，我什么每次都是2分区，粘性分区
                        System.out.println(metadata.offset());// 13 14 15 16 17
                        System.out.println(metadata.topic());
                    }else{
                        System.out.println("消息发送失败，失败原因："+exception.getMessage());
                    }

                }
            });
        }

        kafkaProducer.close();
    }
}

测试：

①在 bigdata01 上开启 Kafka 消费者。

bin/kafka-console-consumer.sh --bootstrap-server bigdata01:9092 --topic first

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

bin/kafka-console-consumer.sh --bootstrap-server bigdata01:9092 --topic first

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

主题：first->分区：1
主题：first->分区：1 
主题：first->分区：1 
主题：first->分区：1 
主题：first->分区：1

3）案例二

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

package com.bigdata.producter;

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

public class CustomProducer05 {

    public static void main(String[] args) {

        // Properties 它是map的一种
        Properties properties = new Properties();
        // 设置连接kafka集群的ip和端口
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"bigdata01:9092");
        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");

        // 创建了一个消息生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 调用这个里面的send方法
        // ctrl + p
        /*ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","告诉你个秘密");
        kafkaProducer.send(producerRecord);*/
        for (int i = 0; i < 5; i++) {
            // 发送消息的时候，指定key值，但是没有分区号，会根据 hash(key) % 3 = [0,1,2]
            ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","keyaaa","告诉你个找女朋友的好办法:"+i);
            // 回调-- 调用之前先商量好，回扣多少。
            kafkaProducer.send(producerRecord, new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {

                    // 获取很多信息，exception == null 说明成功，不为null,说明失败
                    if(exception == null){
                        System.out.println("消息发送成功");
                        System.out.println(metadata.partition());// 三个分区，我什么每次都是2分区，粘性分区
                        System.out.println(metadata.offset());// 13 14 15 16 17
                        System.out.println(metadata.topic());
                    }else{
                        System.out.println("消息发送失败，失败原因："+exception.getMessage());
                    }

                }
            });
        }

        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.4.3 自定义分区器

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

1）需求

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

2）实现步骤

（1）定义类实现 Partitioner 接口。

（2）重写 partition()方法

package com.bigdata.producter;

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

import java.util.Map;

/**
 *  自定义分区器：需求：
 *  假如消息中含有bigdata 进入0号分区，假如不含有，进入 1号分区
 *
 */
public class CustomPartitioner 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 val = value.toString();
        String val2 = new String(valueBytes);
        System.out.println(val+","+val2);

        // String 工具类 api
        // 判断一个单词是否在一个字符串中
        if(val.contains("bigdata")){
            return 0;
        }
        /* 判断一个词在一句话中的位置，假如存在返回下标，假如不存在，返回 -1
        if(val.indexOf("bigdata")!=-1){

        }*/
        return 1;
    }

    @Override
    public void close() {

    }

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

    }
}

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

package com.bigdata.producter;

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

/**
 *   测试自定义分区器的使用
 */
public class CustomProducer06 {

    public static void main(String[] args) {

        // Properties 它是map的一种
        Properties properties = new Properties();
        // 设置连接kafka集群的ip和端口
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"bigdata01:9092");
        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");

        /**
         *  假如一个类中，全部都是 常量，这个类就是一个工具类
         *  常量：public static final 修饰，并且变量名全部为大写，这个就叫做常量
         *   不能修改的变量就叫做常量
         */
       /* properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,
                "com.bigdata.producter.CustomPartitioner");*/
        properties.put("partitioner.class",
                "com.bigdata.producter.CustomPartitioner");

        // 创建了一个消息生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 调用这个里面的send方法
        // ctrl + p
        /*ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","告诉你个秘密");
        kafkaProducer.send(producerRecord);*/
        for (int i = 0; i < 5; i++) {
            // 发送消息的时候，指定key值，但是没有分区号，会根据 hash(key) % 3 = [0,1,2]
            ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","c","告诉你个找bigdata的好办法:"+i);
            // 回调-- 调用之前先商量好，回扣多少。
            kafkaProducer.send(producerRecord, new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {

                    // 获取很多信息，exception == null 说明成功，不为null,说明失败
                    if(exception == null){
                        System.out.println("消息发送成功");
                        System.out.println(metadata.partition());// 三个分区，我什么每次都是2分区，粘性分区
                        System.out.println(metadata.offset());// 13 14 15 16 17
                        System.out.println(metadata.topic());
                    }else{
                        System.out.println("消息发送失败，失败原因："+exception.getMessage());
                    }

                }
            });
        }

        kafkaProducer.close();
    }
}

（4）测试

①在 bigdata01 上开启 Kafka 消费者。

bin/kafka-console-consumer.sh --bootstrap-server bigdata01:9092 --topic first

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

主题：first->分区：0

主题：first->分区：0

主题：first->分区：0

主题：first->分区：0

主题：first->分区：0

3.5 生产经验——生产者如何提高吞吐量

1、batch.size：批次大小，默认16k 
2、linger.ms：等待时间，修改为5-100ms
3、compression.type：压缩snappy 
4、 RecordAccumulator：缓冲区大小，修改为64m

package com.bigdata.producter;

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

/**
 *   测试自定义分区器的使用
 */
public class CustomProducer07 {

    public static void main(String[] args) {

        // Properties 它是map的一种
        Properties properties = new Properties();
        // 设置连接kafka集群的ip和端口
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"bigdata01:9092");
        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, 18000);
        // 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");



        // 创建了一个消息生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 调用这个里面的send方法
        // ctrl + p
        /*ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","告诉你个秘密");
        kafkaProducer.send(producerRecord);*/
        for (int i = 0; i < 5; i++) {
            // 发送消息的时候，指定key值，但是没有分区号，会根据 hash(key) % 3 = [0,1,2]
            ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","c","告诉你个找bigdata的好办法:"+i);
            // 回调-- 调用之前先商量好，回扣多少。
            kafkaProducer.send(producerRecord, new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {

                    // 获取很多信息，exception == null 说明成功，不为null,说明失败
                    if(exception == null){
                        System.out.println("消息发送成功");
                        System.out.println(metadata.partition());// 三个分区，我什么每次都是2分区，粘性分区
                        System.out.println(metadata.offset());// 13 14 15 16 17
                        System.out.println(metadata.topic());
                    }else{
                        System.out.println("消息发送失败，失败原因："+exception.getMessage());
                    }

                }
            });
        }

        kafkaProducer.close();
    }
}

测试一下查看结果：

测试：

①在 hadoop102 上开启 Kafka 消费者。

bin/kafka-console-consumer.sh --bootstrap-server hadoop11:9092 --topic first

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

3.6 生产经验——数据可靠性

0：生产者发送过来的数据，不需要等数据落盘应答
假如发送了Hello 和 World两个信息，Leader直接挂掉，数据就会丢失
生产者  ---> Kafka集群  一放进去就跑
数据可靠性分析：丢数
1：生产者发送过来的数据，Leader收到数据后应答

生产者把数据发送给了Leader，Leader保存成功，应答完毕，此时生产者就以为数据发送成功了，但是此时，Leader挂了，但是Follower 并没有同步数据过来，Follower此时变成了Leader, 此时的Leader就没有Hello这个数据了，数据丢失了。

数据可靠性分析：丢数

-1（all）：生产者发送过来的数据，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。例如2超时，(leader:0, isr:0,1)。 这样就不用等长期联系不上或者已经故障的节点。
ISR: 可用的，存活的，Leader+Follower

数据可靠性分析：

如果分区副本设置为1个（只有一个leader），或者ISR里应答的最小副本数量 （ min.insync.replicas 默认为1）设置为1，和ack=1的效果是一样的，仍然有丢数的风险（leader：0，isr:0）。

• 数据完全可靠条件 = ACK级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2

副本数是2，但是ISR中不一定有两个，因为会挂掉。

可靠性总结： 
acks=0，生产者发送过来数据就不管了，可靠性差，效率高； 
acks=1，生产者发送过来数据Leader应答，可靠性中等，效率中等； 
acks=-1，生产者发送过来数据Leader和ISR队列里面所有Follwer应答，可靠性高，效率低； 
在生产环境中，acks=0很少使用；acks=1，一般用于传输普通日志，允许丢个别数据；
   acks=-1，一般用于传输和钱相关的数据，对可靠性要求比较高的场景。

数据重复分析：

        acks： -1（all）：生产者发送过来的数据，Leader和ISR队列里面的所有节点收齐数据后应答

记录：acks = -1 有可能出现，数据重复问题
   数据发送给了Leader，Follower 也同步成功了，此时准备应答为-1的时候，Leader挂了，Follower顶上，由于发送者不知道数据已经发送成功，会给新的Leader再发消息，此时数据重复。

package com.bigdata.kafka.producer;

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

public class CustomProducerACKs {

    public static void main(String[] args) {
        // 这个里面放置配置相关信息
        Properties properties = new Properties();
        properties.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop11:9092");
        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");

        // 设置应答机制是哪个级别的，默认是all 等同于 -1
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        // 重试次数 retries，默认是 int 最大值，2147483647
        properties.put(ProducerConfig.RETRIES_CONFIG, 3);


        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        for (int i=0;i<5;i++) {
            // 回调函数  本次发送并没有指定分区和Key值，仅仅发送的是value
            // 本地发送到底发给哪个分区呢？   1）随机 2）黏住它  使用的是粘性分区
            kafkaProducer.send(new ProducerRecord<>("first", "nihao: " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {

                    if(exception == null ){
                        // 通过回调函数，可以获取本次发送的内容和分区
                        int partition = metadata.partition();
                        String topic = metadata.topic();
                        System.out.println("本次发送的主题是："+topic+",发给了哪个分区："+ partition);
                    }else{
                        exception.printStackTrace();
                    }

                }
            });


        }

        // 此处如果不close() 发送不了数据
        kafkaProducer.close();
    }
}

3.7 生产经验——数据去重（面试必问）

3.7.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版本以后，引入了一项重大特性：幂等性和事务。

3.7.2 幂等性

1）幂等性原理

幂等性就是指Producer不论向Broker发送多少次重复数据，Broker端都只会持久化一条，保证了不重复。 

精确一次（Exactly Once） = 幂等性 + 至少一次（ ack=-1 + 分区副本数>=2 + ISR最小副本数量>=2） 。 
幂等性有点类似于sql语句中的 distinct
重复数据的判断标准：具有 <PID, Partition, SeqNumber>相同主键的消息提交时，Broker只会持久化一条。其 中PID是Kafka每次重启都会分配一个新的；Partition 表示分区号；Sequence Number是单调自增的。 
所以幂等性只能保证的是在单分区单会话(重启会话就是下一次了)内不重复。
如果kafka集群挂了，重启了，此时以前的数据还会发送一回，数据又重复了。

2）如何使用幂等性

开启参数 enable.idempotence 默认为 true，false 关闭。

3.7.3 生产者事务

幂等性只能保障服务器不挂掉的情况下，发送数据是唯一的，假如发送者服务器挂掉了，那么重启之后还是会发送重复的数据，所以需要使用事务。

1）Kafka 事务原理

每一个broker都有一个事务协调器，如何知道本次事务是哪个broker对应的事务协调器呢，有一个算法，如图所示。

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

只要是牵涉到数据的技术都有事务！！！
mysql  jdbc mybatis 

跟java代码中的事务一模一样

    try{
        begin 开启事务
        此处写代码
        commit();
    
    }catch(){
       // 回滚
      rollback();
    
    }

// 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，使用事务保证消息的仅一次发送
 

package com.bigdata.producter;

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

/**
 *   使用事务+幂等性，保证数据唯一
 */
public class CustomProducer09 {

    public static void main(String[] args) {

        // Properties 它是map的一种
        Properties properties = new Properties();
        // 设置连接kafka集群的ip和端口
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"bigdata01:9092");
        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");

        // 设置应答机制是哪个级别的，默认是all 等同于 -1
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        // 重试次数 retries，默认是 int 最大值，2147483647
        properties.put(ProducerConfig.RETRIES_CONFIG, 3);
        // 默认幂等性是开启的，所以不用设置
        // 必须设置事务的ID
        // 设置事务 id（必须），事务 id 任意起名
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transaction_id_0");



        // 创建了一个消息生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 初始化事务
        kafkaProducer.initTransactions();

        // 调用这个里面的send方法
        // ctrl + p
        /*ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first","告诉你个秘密");
        kafkaProducer.send(producerRecord);*/
        // 开启事务
        kafkaProducer.beginTransaction();
        try {
            for (int i = 0; i < 5; i++) {
                // 发送消息的时候，指定key值，但是没有分区号，会根据 hash(key) % 3 = [0,1,2]
                ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("first", "c", "告诉你个找bigdata的好办法:" + i);
                // 回调-- 调用之前先商量好，回扣多少。
                kafkaProducer.send(producerRecord, new Callback() {
                    @Override
                    public void onCompletion(RecordMetadata metadata, Exception exception) {

                        // 获取很多信息，exception == null 说明成功，不为null,说明失败
                        if (exception == null) {
                            System.out.println("消息发送成功");
                            System.out.println(metadata.partition());// 三个分区，我什么每次都是2分区，粘性分区
                            System.out.println(metadata.offset());// 13 14 15 16 17
                            System.out.println(metadata.topic());
                        } else {
                            System.out.println("消息发送失败，失败原因：" + exception.getMessage());
                        }

                    }
                });
                if(i==3){
                    int a = 10 /0 ;
                }
            }
            // 提交事务
            kafkaProducer.commitTransaction();
        }catch (Exception e){
            // 如果出错了，回滚事务
            kafkaProducer.abortTransaction();
        }finally {
            kafkaProducer.close();
        }


    }
}

3.8 生产经验——数据有序

生产者发送的数据，单分区内可以做到有序，多分区，无法保证，除非把多个分区的数据拉到消费者端，进行排序，但这样做需要等，效率很低，还不如直接设置一个分区。

3.9 生产经验——数据乱序

1）kafka在1.x版本之前保证数据单分区有序，条件如下： 
max.in.flight.requests.per.connection=1（不需要考虑是否开启幂等性）。 
2）kafka在1.x及以后版本保证数据单分区有序，条件如下： 
（2）开启幂等性 
max.in.flight.requests.per.connection需要设置小于等于5。 
（1）未开启幂等性 
max.in.flight.requests.per.connection需要设置为1。 
原因说明：因为在kafka1.x以后，启用幂等后，kafka服务端会缓存producer发来的最近5个request的元数据， 故无论如何，都可以保证最近5个request的数据都是有序的。

出现乱序的原因：
1）生产者在发送3请求的时候，发生异常，发生异常需要重新发送，所以排在了后面，在进行落盘的时候，先落盘1，2 ，落盘3的时候发现是4，需要等，等到3出现为止，然后将 3，4 ，5排序，排序后再进行落盘。
顺序错乱了，会自动排序（开启幂等性）。