概述

Kafka是Apache软件基金会的开源的流处理平台，该平台提供了消息的订阅与发布，能够基于Kafka实现对网络日志流实时在线处理，在这个维度上弥补了Hadoop的离线分析系统的不足。因为基于hadoop的MapReduce系统分析离线数据延迟较高，而且不支持动态数据处理和分析。Kafka的流处理平台不仅仅可以为离线系统储备数据（通常使用Kafka作为数据缓冲），而且Kafka自身也提供了一套数据流的处理机制，实现对数据流在线处理，比如： 统计。

消息队列的概念

可以用于系统间通讯的一个组件-middle ware（中间件），该组件可以用于做消息缓冲的中间件（持久化）解决一些 并发处理、数据库缓冲等实现对高并发的业务场景的削峰填谷。

使用消息队列的场景分析

1.异步消息发送：

使用Kafka MQ功能实现模块间异步通信，把一些费时的操作交给额外的服务或者设备去执行，这样可以提升系统运行效率，加速连接释放的速度，例如：用户注册模块，在用户注册成功后，业务系统需要给用户发送一个通知短信，通知用户登录邮箱去激活刚注册的用户信息。这种业务场景如图所示，因为短信通知和邮件发送是一个比较耗时的操作，所以在这里没必要将短信和邮件发送作为注册模块的流程，使用Message Queue功能可以将改业务和主业务注册分离，这样可以缩短用户浏览器和服务建立的链接时间，同时也能满足发送短信和邮件的业务。

2.系统间解耦合

①在某些高吞吐的业务场景下，可能会出现在某一个时间段系统负载写入的负载压力比较大，短时间有大量的数据需要持久化到数据库中，但是由于数据的持久化需要数据库提供服务，由于传统的数据库甚至一些NoSQL产品也不能很好的解决高并发写入，因为数据库除去要向用户提供链接之外，还需要对新来的数据做持久化，这就需要一定的时间才能将数据落地到磁盘。因此在高并发写入的场景，就需要用户集成Message Queue在数据库前作为缓冲队列。在队列的另一头只需要程序有条不紊的将数据写入到数据库即可，这就保证无论外界写入压力有多么大都可以借助于Message Queue缓解数据库的压力。

②Message Queue除了解决对数据缓冲的压力之外，还可以充当业务系统的中间件（Middleware）作为系统服务间解耦的组件存在，例如上图所示订单模块和库存模块中就可以使用Message Queue作为缓冲队列实现业务系统服务间的解耦，也就意味着即使服务在运行期间库存系统宕机也并不会影响订单系统的正常运行

Kafka 架构

集群模式
Kafka集群以Topic形式负责管理集群中的Record，每一个Record属于一个Topic。底层Kafka集群通过日志分区形式持久化Record。在Kafka集群中，Topic的每一个分区都一定会有1个Borker担当该分区的Leader，其他的Broker担当该分区的follower（取决于分区的副本因子）。一旦对应分区的Lead宕机，kafka集群会给当前的分区指定新的Borker作为该分区的Leader。分区的Leader的选举是通过Zookeeper一些特性实现的，这里就不在概述了。Leader负责对应分区的读写操作，Follower负责数据备份操作。

日志&分区
Kafka集群是通过日志形式存储Topic中的Record，Record会根据分区策略计算得到的分区数存储到相应分区的文件中。每个分区都是一个有序的，不可变的记录序列，不断附加到结构化的commit-log中。每个分区文件会为Record进去分区的顺序进行编排。每一个分区中的Record都有一个id，该id标示了该record进入分区的先后顺序，通常将该id称为record在分区中的offset偏移量从0开始，依次递增。

Kafka集群持久地保留所有已发布的记录 - 无论它们是否已被消耗 - 使用可配置的保留时间。例如，如果保留策略设置为2天，则在发布记录后的2天内，它可供使用，之后将被丢弃以释放空间。Kafka的性能在数据大小方面实际上是恒定的，因此长时间存储数据不是问题。

事实上，基于每个消费者保留的唯一元数据是该消费者在日志中的偏移或位置。这种offset由消费者控制：通常消费者在读取记录时会线性地增加其偏移量，但事实上，由于消费者控制位置，它可以按照自己喜欢的任何顺序消费记录。例如，消费者可以重置为较旧的偏移量以重新处理过去的数据，或者跳到最近的记录并从“现在”开始消费。

分区数目决定系统对外的吞吐能力，分区数目越大吞吐性能越好。通常来说队列一定保证FIFO，但是由于Kafka采取了hash（key）%分区数的分区策略将数据发送到对应的分区中，因此Kafka的Topic只能保证分区内部数据遵循FIFO策略。

生产者
生产者负责发送Record到Kafka集群中的Topic中。在发布消息的时候，首先先计算Record分区计算方案有三种：①如果用户没有指定分区但是指定了key信息，生产者会根据hash（key）%分区数计算该Record所属分区信息，②如果生产者在发送消息的时候并没有key，也没有指定分区数，生产者会使用轮训策略选择分区信息。③如果指定了分区信息，就按照指定的分区信息选择对应的分区；当分区参数确定以后生产者会找到相应分区的Leader节点将Record记录写入到Topic日志存储分区中。
消费者
消费者作为消息的消费者，消费者对Topic中消息的消费是以Group为单位进行消费，Kafka服务会自动的按照组内和组间对消费者消费的分区进行协调。

• 组内均分分区，确保一个组内的消费者不可重复消费分区中的数据，一般来说一个组内的消费者实例对的数目应该小于或者等于分区数目。
• 组间广播形式消费，确保所有组都可以拿到当前Record。组间数据之间可以保证对数据的独立消费。

Kafka集群安装

环境准备
准备三台主机名分别为CentOSA|CentOSB|CentOSC的Linux系统主机
分别关闭防火墙、相互做主机名映射、校对物理时钟、安装配置JDK8配置JAVA_HOME
安装Zookeeper集群确保Kafka集群的正常运行在这里插入代码片

tar -zxf zookeeper-3.4.6.tar.gz -C /usr/
mkdir /root/zkdata#分别在三台机器执行以下命令
echo 1 >> /root/zkdata/myid
echo 2 >> /root/zkdata/myid
echo 3 >> /root/zkdata/myidtouch /usr/zookeeper-3.4.6/conf/zoo.cfg
vim /usr/zookeeper-3.4.6/conf/zoo.cfg

zoo.cfg配置文件

tickTime=2000
dataDir=/root/zkdata
clientPort=2181
initLimit=5
syncLimit=2server.1=CentOSA:2887:3887
server.2=CentOSB:2887:3887
server.3=CentOSC:2887:3887

启动zookeeper并查看zookeeper当前状态

/usr/zookeeper-3.4.6/bin/zkServer.sh start zoo.cfg     #启动
/usr/zookeeper-3.4.6/bin/zkServer.sh status zoo.cfg    #查看状态

Kafka安装步骤

• 下载Kafka服务安装包http://archive.apache.org/dist/kafka/2.2.0/kafka_2.11-2.2.0.tgz

tar -zxf kafka_2.11-2.2.0.tgz -C /usr
vim /usr/kafka_2.11-2.2.0/config/server.properties
############################# Server Basics #############################
broker.id=[0|1|2]  #三台机器分别 0/1/2
############################# Socket Server Settings #############################
listeners=PLAINTEXT://CentOS[A|B|C]:9092 #三台机器分别A、B、C
############################# Log Basics #############################
# A comma separated list of directories under which to store log files
log.dirs=/usr/kafka-logs
############################# Zookeeper #############################
zookeeper.connect=CentOSA:2181,CentOSB:2181,CentOSC:2181

本案例中安装的是kafka_2.11-2.2.0.tgz版本，由于Kafka底层使用的Scala和Java混编，因此在kafka发行版本例如：kafka_2.11-2.2.0.tgz其中2.11是Scala的编译版本，因为Scala兼容Java所以运行Kafka无需安装Scala环境；2.2.0是kafka的版本号。Kafka从0.11.x以后加入事务等特性的支持。

配置说明

配置项	说明
broker.id	每一台Kafka服务的id信息，必须设置不同。
delete.topic.enable	配置该属性开启删除topic的能力，否则kafka无法删除Topic信息。
listeners	配置Kafka服务的监听服务入口。
log.dirs	配置Kafka日志存储路径，存储消息信息。
log.retention.hours	日志存储时间，一旦日志数据超过改时间，系统会自动删除过期日志。
zookeeper.connect	zookeeper链接参数信息，用于保存Kafka元数据信息。

启动服务

cd /usr/kafka_2.11-2.2.0/
./bin/kafka-server-start.sh -daemon config/server.properties
#jps   #使用jps查看kafka进程
5507 Kafka

关闭服务
kafka-server-stop.sh自带的服务脚本中存在的一些问题，用户需要修改该脚本文件，具体修改内容如下所示：
[root@CentOSX kafka_2.11-2.2.0]# vi bin/kafka-server-stop.sh

SIGNAL=${SIGNAL:-TERM}
PIDS=$(jps | grep  Kafka | awk '{print $1}')if [ -z "$PIDS" ]; then
echo "No kafka server to stop"
exit 1
else
kill -s $SIGNAL $PIDS
fi

Kafka自带脚本中PIDS参数获取存在问题，导致每次获取的PIDS都是空信息。

验证是否启动成功

• 创建Tocpic

[root@CentOSA kafka_2.11-2.2.0]#./bin/kafka-topics.sh
--zookeeper CentOSA:2181,CentOSB:2181,CentOSC:2181 --create --topic topic01 --partitions 3 --replication-factor 3

partitions:日志分区数；replication-factor:分区副本因子

• 消费者

[root@CentOSA kafka_2.11-2.2.0]#./bin/kafka-console-consumer.sh 
--bootstrap-server CentOSA:9092,CentOSB:9092,CentOSC:9092 
--topic topic01

• 生产者

 [root@CentOSB kafka_2.11-2.2.0]#./bin/kafka-console-producer.sh 
--broker-list CentOSA:9092,CentOSB:9092,CentOSC:9092 
--topic topic01
> hello kafka

观察CentOSA控制台输出，如果有hello kafka说明安装成功！

Topic管理篇（DDL）

• 创建Tocpic

[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-topics.sh
--zookeeper CentOSA:2181,CentOSB:2181,CentOSC:2181
--create
--topic topic01
--partitions 3
--replication-factor 3

• Topic详细信息

 ./bin/kafka-topics.sh  --describe  --zookeeper CentOSA:2181,CentOSB:2181,CentOSC:2181  --topic topic01

• 删除Topic

 ./bin/kafka-topics.sh 
--zookeeper CentOSA:2181,CentOSB:2181,CentOSC:2181  --delete  --topic topic01

如果用户没有配置delete.topic.enable=true，则Topic删除不起作用。

• Topic列表

./bin/kafka-topics.sh  --zookeeper CentOSA:2181,CentOSB:2181,CentOSC:2181  --list

Kafka API实战(JDK1.8+)

Maven依赖

<dependency><groupId>org.apache.kafka</groupId><artifactId>kafka-clients</artifactId><version>2.2.0</version></dependency><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.25</version>
</dependency>
<dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version>
</dependency><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>1.7.5</version>
</dependency>

引入log4j.properies

### set log levels ###
log4j.rootLogger = info,stdout 
### 输出到控制台 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =%p %d %c %m %n

在Windos配置主机名和IP映射关系

192.168.111.128 CentOSA
192.168.111.129 CentOSB
192.168.111.130 CentOSC

必须配置主机名和IP的映射关系，否则运行主机在连接kafka服务的时候，会抛出无法解析主机异常或者链接超时，这一点是很多初学者在使用Kafka的时候容易忽略的一点。

Topic管理

管理Topic的核心在于创建AdminClient，通过adminClient完成对Topic的基础管理

//创建AdminClient
Properties props = new Properties();
props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"链接参数");
AdminClient adminClient=KafkaAdminClient.create(props);// todo your code here//关闭连接
adminClient.close();

Topic创建

List<NewTopic> newTopics = Arrays.asList(new NewTopic("topic01", 3, (short)2));
adminClient.createTopics(newTopics);

Topic列表

ListTopicsResult topics = adminClient.listTopics();
topics.names()
.get()
.stream()
.forEach((topic)-> System.out.println(topic));

Topic详情

adminClient.describeTopics(Arrays.asList("topic01")).all().get().entrySet().stream().forEach((entry)-> {String topic=entry.getKey();System.out.println(topic);TopicDescription descr = entry.getValue();List<TopicPartitionInfo> partitions = descr.partitions();for (TopicPartitionInfo partition : partitions) {System.out.println("\t"+partition);}});

Topic删除

adminClient.deleteTopics(Arrays.asList("topic01"));

集群状态

adminClient.describeCluster().nodes().get().stream().forEach((node)-> System.out.println(node) );

生产者

生产者负责产生消息，并且将生产的消息发送到kafka集群中，在Kaka集群中所有发送的消息都必须是以二进制分区日志形式存储，因此生产者在发送的数据之前需要指定数据序列化规则

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;import java.text.DecimalFormat;
import java.util.Properties;public class KafkaProducerDemo {public static void main(String[] args) {//1.配置生产者连接属性Properties props = new Properties();props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");//2.创建Kafka生产者KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);//3.构建ProducerRecordfor (int i=0;i<10;i++){DecimalFormat decimalFormat = new DecimalFormat("000");ProducerRecord<String, String> record = new ProducerRecord<String, String>("topic04", decimalFormat.format(i), "value" + i);//4.发送消息producer.send(record);}//5.清空缓冲区producer.flush();//6.关闭生产者producer.close();}
}

生产者常见的属性配置及其含义

属性	默认值	含义	是否必须
bootstrap.servers	“”	连接kafka集群连接参数	是
key.serializer	null	key序列化规则	是
value.serializer	null	value序列化规则	是
acks	1	生产者要求leader在考虑完成请求之前收到的确认数量。	否
retries	2147483647(Integer.MAX_VALUE)	当没有在规定时间内acker，则认定发送失败，重试次数	否
batch.size	16384	一次缓冲多少数据，并不是一条数据就会触发发送	否
linger.ms	0	间隔多长时间构建一次batch发送	否
request.timeout.ms	30000	设置客户端最大等待超时时间	否
enable.idempotence	false	是否开启幂等性，可以保证生产者一个Record只发送一次给broker	否

消费者

消费者负责消费集群中的消息，消费者消费Topic中的消息是按照group消费形式订阅的。

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;import java.time.Duration;
import java.util.Arrays;
import java.util.Properties;public class KafkaConsumerDemo {public static void main(String[] args) {//1.配置消费者连接属性Properties props = new Properties();props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");props.put(ConsumerConfig.GROUP_ID_CONFIG,"group1");//2.创建Kafka消费者KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);//3.订阅topicsconsumer.subscribe(Arrays.asList("topic01"));//4.死循环读取消息while(true){ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));if(records!=null && !records.isEmpty()){for (ConsumerRecord<String, String> record : records) {int partition = record.partition();long offset = record.offset();long timestamp = record.timestamp();String key = record.key();String value = record.value();System.out.println(partition+"\t"+offset+"\t"+timestamp+"\t"+key+"\t"+value);}}}//consumer.close();}
}

消费者常见的属性配置及其含义

属性	默认值	含义	是否必须
bootstrap.servers	“”	连接kafka服务器参数	是
key.deserializer	null	key反序列化	是
value.deserializer	null	value反序列化	是
group.id	“”	如果是订阅方式，必须指定组id	是
enable.auto.commit	true	offset自动提交	否
auto.commit.interval.ms	5000	自动提交频率	否

读取数据偏移量控制

默认当用户使用subscribe方式订阅topic消息， 默认首次offset策略是latest。当用户第一次订阅topic在消费者订阅之前的数据是无法消费到 消息的。用户可以配置消费端参数auto.offset.reset控制kafka消费者行为。

Properties props = new Properties();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");
props.put(ConsumerConfig.GROUP_ID_CONFIG,"group1");props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");//默认值 latest  使用earliest可能导致数据重复消费

因为消费端在使用consumer.poll数据的时候，底层会定时的向Kafka服务器提交消费的偏移量。默认消费端的offset是自动提交的，用户如果不希望自动提交偏移量可以配置如下参数

注意如果用户使用subscribe方式订阅topic，在消费端必须指定group.id，这样Kafka才能够实现消费>端负载均衡以及实现组内均分组件广播。（推荐方式）

默认配置

enable.auto.commit	= true
auto.commit.interval.ms	= 5000

props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");

public class KafkaConsumerDemo {public static void main(String[] args) {//1.配置生产者连接属性Properties props = new Properties();props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");props.put(ConsumerConfig.GROUP_ID_CONFIG,"group1");props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false);//2.创建Kafka消费者KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);//3.订阅topicsconsumer.subscribe(Arrays.asList("topic01"));//4.死循环读取消息while(true){ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));if(records!=null && !records.isEmpty()){Map<TopicPartition, OffsetAndMetadata> offsetMeta=new HashMap<>();for (ConsumerRecord<String, String> record : records) {int partition = record.partition();long offset = record.offset();long timestamp = record.timestamp();String key = record.key();String value = record.value();System.out.println(partition+"\t"+offset+"\t"+timestamp+"\t"+key+"\t"+value);TopicPartition part = new TopicPartition("topic03", partition);//构建分区信息OffsetAndMetadata oam=new OffsetAndMetadata(offset+1);//设置下一次读取起始位置offsetMeta.put(part,oam);//存储需要提交分区参数}consumer.commitSync(offsetMeta);//提交offset}}}
}

指定消费分区

通过assign方式kafka对消费者的组管理策略失效。也就是说用户可以无需配置组ID。

public class KafkaConsumerDemo {public static void main(String[] args) {//1.配置生产者连接属性Properties props = new Properties();props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");//2.创建Kafka消费者KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);//3.指定分区consumer.assign(Arrays.asList(new TopicPartition("topic01",1)));consumer.seek(new TopicPartition("topic01",1),1);//4.死循环读取消息while(true){ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));if(records!=null && !records.isEmpty()){for (ConsumerRecord<String, String> record : records) {int partition = record.partition();long offset = record.offset();long timestamp = record.timestamp();String key = record.key();String value = record.value();System.out.println(partition+"\t"+offset+"\t"+timestamp+"\t"+key+"\t"+value);}}}}
}

Kafka发送/接收Object

生产Object

public interface Serializer<T> extends Closeable {void configure(Map<String, ?> configs, boolean isKey);//重点实现serializebyte[] serialize(String topic, T data);default byte[] serialize(String topic, Headers headers, T data) {return serialize(topic, data);}@Overridevoid close();
}

消费Object

public interface Deserializer<T> extends Closeable {void configure(Map<String, ?> configs, boolean isKey);//重点实现方法T deserialize(String topic, byte[] data);default T deserialize(String topic, Headers headers, byte[] data) {return deserialize(topic, data);}@Overridevoid close();
}

实现序列化和反序列化

public class ObjectCodec implements Deserializer<Object>, Serializer<Object> {@Overridepublic void configure(Map<String, ?> configs, boolean isKey) {}@Overridepublic byte[] serialize(String topic, Object data) {return SerializationUtils.serialize((Serializable) data);}@Overridepublic Object deserialize(String topic, byte[] data) {return SerializationUtils.deserialize(data);}@Overridepublic void close() {}
}

生产者幂等性

幂等:多次操作最终的影响等价与一次操作称为幂等性操作,所有的读操作一定是幂等的.所有的写操作一定不是幂等的.当 生产者和broker默认有acks应答机制,如果当生产者发送完数据给broker之后如果没有在规定的时间内收到应答,生产者可以考虑重发数据.可以通过一下配置参数提升生产者的可靠性.

acks = all // 0 无需应答  n 应答个数 -1所有都需要
retries = 3 // 表示重试次数
request.timeout.ms = 3000 //等待应答超时时间
enable.idempotence = true //开启幂等性

public class KafkaProducerDemo {public static void main(String[] args) {//1.配置生产者连接属性Properties props = new Properties();props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");props.put(ProducerConfig.ACKS_CONFIG,"all");//等待所有从机应答props.put(ProducerConfig.RETRIES_CONFIG,3);//重试3次props.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,3000);//等待3s应答props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);//开启幂等性//2.创建Kafka生产者KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);//3.构建ProducerRecordfor (int i=15;i<20;i++){DecimalFormat decimalFormat = new DecimalFormat("000");User user = new User(i, "name" + i, i % 2 == 0);ProducerRecord<String, String> record = new ProducerRecord<String, String>("topic01", decimalFormat.format(i), "user"+i);//4.发送消息producer.send(record);}//5.清空缓冲区producer.flush();//6.关闭生产者producer.close();}

生产者批量发送

生产者会尝试缓冲record，实现批量发送，通过一下配置控制发送时机，记住如果开启可batch，一定在关闭producer之前需要flush。

batch.size = 16384 //16KB 缓冲16kb数据本地
linger.ms = 2000 //默认逗留时间

public static void main(String[] args) {//1.配置生产者连接属性Properties props = new Properties();props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");props.put(ProducerConfig.ACKS_CONFIG,"all");props.put(ProducerConfig.RETRIES_CONFIG,3);props.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,3000);props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);props.put(ProducerConfig.BATCH_SIZE_CONFIG,1024);//1kb缓冲区props.put(ProducerConfig.LINGER_MS_CONFIG,1000);//设置逗留时常//2.创建Kafka生产者KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);//3.构建ProducerRecordfor (int i=15;i<20;i++){DecimalFormat decimalFormat = new DecimalFormat("000");User user = new User(i, "name" + i, i % 2 == 0);ProducerRecord<String, String> record = new ProducerRecord<String, String>("topic01", decimalFormat.format(i), "user"+i);//4.发送消息producer.send(record);}//5.清空缓冲区producer.flush();//6.关闭生产者producer.close();
}

生产者事务

kafka生产者事务指的是在发送多个数据的时候，保证多个Record记录发送的原子性。如果有一条发送失败就回退，但是需要注意在使用kafka事务的时候需要调整消费者的事务隔离级别设置为read_committed，因为kafka默认的事务隔离策略是read_uncommitted

transactional.id=transaction-1 //必须保证唯一
enable.idempotence=true //开启kafka的幂等性

只有生产者

public class KafkaProducerDemo {public static void main(String[] args) {//1.创建Kafka生产者KafkaProducer<String, String> producer = buildKafkaProducer();//2.初始化事务和开启事务producer.initTransactions();producer.beginTransaction();try {for (int i=5;i<10;i++){DecimalFormat decimalFormat = new DecimalFormat("000");User user = new User(i, "name" + i, i % 2 == 0);ProducerRecord<String, String> record = new ProducerRecord<String, String>("topic07", decimalFormat.format(i), "user"+i);producer.send(record);}producer.flush();//3.提交事务]producer.commitTransaction();} catch (Exception e) {System.err.println(e.getMessage());//终止事务producer.abortTransaction();}//5.关闭生产者producer.close();}private static KafkaProducer<String, String> buildKafkaProducer() {//0.配置生产者连接属性Properties props = new Properties();props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");props.put(ProducerConfig.ACKS_CONFIG,"all");props.put(ProducerConfig.RETRIES_CONFIG,3);props.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,3000);props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);props.put(ProducerConfig.BATCH_SIZE_CONFIG,1024);//1kb缓冲区props.put(ProducerConfig.LINGER_MS_CONFIG,1000);//设置逗留时常//开启事务props.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"transaction-"+UUID.randomUUID().toString());return new KafkaProducer<String, String>(props);}
}

消费者那方需要将事务隔离级别设置为read_committed

public class KafkaConsumerDemo {public static void main(String[] args) {//1.创建Kafka消费者KafkaConsumer<String, String> consumer = buildKafkaConsumer();//2.订阅topicsconsumer.subscribe(Arrays.asList("topic07"));//3.死循环读取消息while(true){ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));if(records!=null && !records.isEmpty()){for (ConsumerRecord<String, String> record : records) {int partition = record.partition();long offset = record.offset();long timestamp = record.timestamp();String key = record.key();String value = record.value();System.out.println(partition+"\t"+offset+"\t"+timestamp+"\t"+key+"\t"+value);}}}}private static KafkaConsumer<String, String> buildKafkaConsumer() {Properties props = new Properties();props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");props.put(ConsumerConfig.GROUP_ID_CONFIG,"group1");props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");props.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG,"read_committed");//消费者设置事务隔离级别return new KafkaConsumer<String, String>(props);}
}

生产者&消费者

import com.msk.demo05.User;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.OffsetAndMetadata;
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.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;import java.text.DecimalFormat;
import java.time.Duration;
import java.util.*;public class KafkaProducerAndConsumer {public static void main(String[] args) {String servers = "CentOSA:9092,CentOSB:9092,CentOSC:9092";String group="g1";//1.创建Kafka生产者KafkaProducer<String, String> producer = KafkaUtils.buildKafkaProducer(servers,StringSerializer.class, StringSerializer.class);KafkaConsumer<String, String> consumer = KafkaUtils.buildKafkaConsumer(servers,StringDeserializer.class, StringDeserializer.class,group);consumer.subscribe(Arrays.asList("topic08"));//初始化事务producer.initTransactions();while (true) {producer.beginTransaction();ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));try {Map<TopicPartition, OffsetAndMetadata> commits = new HashMap<TopicPartition, OffsetAndMetadata>();for (ConsumerRecord<String, String> record : records) {TopicPartition partition = new TopicPartition(record.topic(), record.partition());OffsetAndMetadata offsetAndMetadata = new OffsetAndMetadata(record.offset() + 1);commits.put(partition, offsetAndMetadata);System.out.println(record);ProducerRecord<String, String> srecord = new ProducerRecord<String, String>("topic09", record.key(), record.value());producer.send(srecord);//将topic08里的数据写入topic09中}producer.flush();//并没使用 consumer提交，而是使用producer帮助消费者提交偏移量producer.sendOffsetsToTransaction(commits,group);//提交生产者的偏移量producer.commitTransaction();} catch (Exception e) {//System.err.println(e.getMessage());producer.abortTransaction();}}}
}

SpringBoot整合Kafka

• pom.xml

<properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><java.version>1.8</java.version><kafka.version>2.2.0</kafka.version>
</properties><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.1.5.RELEASE</version>
</parent><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.kafka</groupId><artifactId>spring-kafka</artifactId><version>2.2.5.RELEASE</version></dependency><!-- kafka client处理 --><dependency><groupId>org.apache.kafka</groupId><artifactId>kafka-clients</artifactId><version>${kafka.version}</version></dependency>
</dependencies>

• application.properties

server.port=8888# 生产者
spring.kafka.producer.bootstrap-servers=CentOSA:9092,CentOSB:9092,CentOSC:9092
spring.kafka.producer.acks=all
spring.kafka.producer.retries=1
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer# 消费者
spring.kafka.consumer.bootstrap-servers=CentOSA:9092,CentOSB:9092,CentOSC:9092
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer

• 代码

@SpringBootApplication
@EnableScheduling
public class KafkaApplicationDemo {@Autowiredprivate KafkaTemplate kafkaTemplate;public static void main(String[] args) {SpringApplication.run(KafkaApplicationDemo.class,args);}@Scheduled(cron = "0/1 * * * * ?")public void send(){String[] message=new String[]{"this is a demo","hello world","hello boy"};ListenableFuture future = kafkaTemplate.send("topic07", message[new Random().nextInt(message.length)]);future.addCallback(o -> System.out.println("send-消息发送成功：" + message), throwable -> System.out.println("消息发送失败：" + message));}@KafkaListener(topics = "topic07",id="g1")public void processMessage(ConsumerRecord<?, ?> record) {System.out.println("record:"+record);}
}