消息队列
消息:系统间通信介质,存在形式多样化一般使用字节序列化、json、xml等
队列:先进先出FIFO数据结构
消息队列(Message Queue):可以用于系统间通讯的一个组件-middle ware(中间件),该组件可以用于做消息缓冲的中间件(持久化)解决一些 并发处理、数据库缓冲等实现对高并发的业务场景的削峰填谷。
消息中间件还有:ActiveMQ-单机、ZoreMQ、RocketMQ、Kafka MQ Apache
场景分析
- 异步消息
使用Kafka MQ功能实现模块间异步通信,把一些费时的操作交给额外的服务或者设备去执行,这样可以提升系统运行效率,加速连接释放的速度,例如:用户注册模块,在用户注册成功后,业务系统需要给用户发送一个通知短信,通知用户登录邮箱去激活刚注册的用户信息。这种业务场景如图所示,因为短信通知和邮件发送是一个比较耗时的操作,所以在这里没必要将短信和邮件发送作为注册模块的流程,使用Message Queue功能可以将改业务和主业务注册分离,这样可以缩短用户浏览器和服务建立的链接时间,同时也能满足发送短信和邮件的业务。
- 系统解耦|削峰填谷
①在某些高吞吐的业务场景下,可能会出现在某一个时间段系统负载写入的负载压力比较大,短时间有大量的数据需要持久化到数据库中,但是由于数据的持久化需要数据库提供服务,由于传统的数据库甚至一些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集群安装
环境准备
- 准备三台物理主机主机名分别是CentOSA|CentOSB|CentOSC
- 关闭防火墙
[root@CentOSX ~]# service iptables stop
iptables: Setting chains to policy ACCEPT: filter [ OK ]
iptables: Flushing firewall rules: [ OK ]
iptables: Unloading modules: [ OK ]
[root@CentOSX ~]# chkconfig iptables off
- 安装JDK,配置JAVA_HOME
[root@CentOSX ~]# rpm -ivh jdk-8u171-linux-x64.rpm
[root@CentOSX ~]# ls -l /usr/java/
total 4
lrwxrwxrwx. 1 root root 16 Mar 26 00:56 default -> /usr/java/latest
drwxr-xr-x. 9 root root 4096 Mar 26 00:56 jdk1.8.0_171-amd64
lrwxrwxrwx. 1 root root 28 Mar 26 00:56 latest -> /usr/java/jdk1.8.0_171-amd64
[root@CentOSX ~]# vi .bashrc
JAVA_HOME=/usr/java/latest
PATH=$PATH:$JAVA_HOME/bin
CLASSPATH=.
export JAVA_HOME
export PATH
export CLASSPATH
[root@CentOSX ~]# source ~/.bashrc # 加载环境变量
- 校准物理主机时钟,确保时间一致。
[root@CentOSX ~]# yum install -y ntp
[root@CentOSX ~]# service ntpd start # 启动时钟服务器
Starting ntpd: [ OK ]
[root@CentOSX ~]# ntpdate time.windows.com # 更新本地时间
11 Jun 13:46:16 ntpdate[1276]: the NTP socket is in use, exiting
[root@CentOSX ~]# chkconfig ntpd on # 设置时间同步服务器开机自启动
- 配置主机名和IP的映射关系,这是必须的,因为Kafka默认只认主机名,最后别忘记关闭防火墙。
192.168.111.128 CentOSA
192.168.111.129 CentOSB
192.168.111.130 CentOSC
- 安装Zookeeper集群,并且保证Zookeeper能正常运行。
[root@CentOSX ~]# tar -zxf zookeeper-3.4.6.tar.gz -C /usr/
[root@CentOSX ~]# mkdir /root/zkdata
[root@CentOSA ~]# echo 1 >> /root/zkdata/myid
[root@CentOSB ~]# echo 2 >> /root/zkdata/myid
[root@CentOSC ~]# echo 3 >> /root/zkdata/myid
[root@CentOSX ~]# touch /usr/zookeeper-3.4.6/conf/zoo.cfg
[root@CentOSX ~]# vi /usr/zookeeper-3.4.6/conf/zoo.cfg
tickTime=2000
dataDir=/root/zkdata
clientPort=2181
initLimit=5
syncLimit=2
server.1=CentOSA:2887:3887
server.2=CentOSB:2887:3887
server.3=CentOSC:2887:3887
[root@CentOSX ~]# /usr/zookeeper-3.4.6/bin/zkServer.sh start zoo.cfg
[root@CentOSX ~]# /usr/zookeeper-3.4.6/bin/zkServer.sh status zoo.cfg
JMX enabled by default
Using config: /usr/zookeeper-3.4.6/bin/../conf/zoo.cfg
Mode: `follower|leader`
[root@CentOSX ~]# jps
5879 `QuorumPeerMain`
7423 Jps
下载Kafka服务安装包http://archive.apache.org/dist/kafka/2.2.0/kafka_2.11-2.2.0.tgz
因为Kafka底层是使用Scala编程语言这里2.11指的是Scala的版本号,2.2.0才是Kafka的版本。
目前企业用的0.11.0居多,这里采用2.2.0是为了更好的支持Kafka Streaming
安装步骤
[root@hadoopX ~]# tar -zxf kafka_2.11-2.2.0.tgz -C /usr
[root@hadoop2 ~]# vi /usr/kafka_2.11-2.2.0/config/server.properties
############################# Server Basics #############################
broker.id=[0|1|2]
############################# Socket Server Settings #############################
listeners=PLAINTEXT://CentOS[A|B|C]:9092
############################# 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
启动服务
[root@CentOSX ~]# cd /usr/kafka_2.11-2.2.0/
[root@CentOSX kafka_2.11-2.2.0]# ./bin/kafka-server-start.sh -daemon config/server.properties
测试环境
- 创建topic01
[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
Created topic topic01.
这里partitions指定日志分区数目,replication-factor指定分区日志的副本因子。
- 消费者订阅topic01
[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
关闭Kafka服务
vi bin/kafka-server-stop.sh
#!/bin/sh
SIGNAL=${SIGNAL:-TERM}
#PIDS=$(ps ax | grep -i 'kafka\.Kafka' | grep java | grep -v grep | awk '{print $1}')
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,需要重新启动Kafka服务
- 清空zookeeper所有Kafka数据
[cluster, controller_epoch, brokers, zookeeper, admin, isr_change_notification, consumers, log_dir_event_notification, latest_producer_id_block, config]
删除zookeeper以外所有节点
- 删除kafka配置log.dirs目录下的所有数据
[root@CentOSX ~]# rm -rf /usr/kafka-logs
Topic 和 日志
Kafka集群是通过日志形式存储Topic中的Record,Record会根据分区策略计算得到的分区数存储到相应分区的文件中。每个分区都是一个有序的,不可变的记录序列,不断附加到结构化的commit-log中。每个分区文件会为Record进去分区的顺序进行编排。每一个分区中的Record都有一个id,该id标示了该record进入分区的先后顺序,通常将该id称为record在分区中的offset偏移量从0开始,依次递增。
Kafka集群持久地保留所有已发布的记录 - 无论它们是否已被消耗 - 使用可配置的保留时间。例如,如果保留策略设置为2天,则在发布记录后的2天内,它可供使用,之后将被丢弃以释放空间。Kafka的性能在数据大小方面实际上是恒定的,因此长时间存储数据不是问题。
事实上,基于每个消费者保留的唯一元数据是该消费者在日志中的偏移或位置。这种offset由消费者控制:通常消费者在读取记录时会线性地增加其偏移量,但事实上,由于消费者控制位置,它可以按照自己喜欢的任何顺序消费记录。例如,消费者可以重置为较旧的偏移量以重新处理过去的数据,或者跳到最近的记录并从“现在”开始消费。
生产者
生产者负责发送Record到Kafka集群中的Topic中。在发布消息的时候,首先先计算Record分区计算方案有三种:①如果用户没有指定分区但是指定了key信息,生产者会根据hash(key)%分区数计算该Record所属分区信息,②如果生产者在发送消息的时候并没有key,也没有指定分区数,生产者会使用轮训策略选择分区信息。③如果指定了分区信息,就按照指定的分区信息选择对应的分区;当分区参数确定以后生产者会找到相应分区的Leader节点将Record记录写入到Topic日志存储分区中。
消费者
消费者作为消息的消费放,消费者对Topic中消息的消费方式是以Group为单位进行消费,Kafka服务器会自动的按照组内和组间对消费者消费的分区进行协调。
- 组内均分分区,确保一个组内的消费者不可重复消费分区中的数据,一般来说一个组内的消费者实例对的数目应该小于或者等于分区数目。
- 组间广播形式消费,确保所有组都可以拿到当前Record。组间数据之间可以保证对数据的独立消费。
Topic管理篇(DDL)
- 创建topic
[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详细信息
[root@CentOSC kafka_2.11-2.2.0]# ./bin/kafka-topics.sh
--describe
--zookeeper CentOSA:2181,CentOSB:2181,CentOSC:2181
--topic topic01
Topic:topic01 PartitionCount:3 ReplicationFactor:3 Configs:
Topic: topic01 Partition: 0 Leader: 2 Replicas: 1,2,0 Isr: 2,0,1
Topic: topic01 Partition: 1 Leader: 2 Replicas: 2,0,1 Isr: 2,0,1
Topic: topic01 Partition: 2 Leader: 2 Replicas: 0,1,2 Isr: 2,0,1
- 删除topic
如果用户没有配置delete.topic.enable=true,则Topic删除不起作用。
[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-topics.sh
--zookeeper CentOSA:2181,CentOSB:2181,CentOSC:2181
--delete
--topic topic01
- topic列表
[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-topics.sh
--zookeeper CentOSA:2181,CentOSB:2181,CentOSC:2181
--list
Kafka API
- pom依赖
<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
- 快速入门
生产
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) {
//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");
//1.创建Kafka生产者
KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);
//2.构建ProducerRecord
for (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);
//3.发送消息
producer.send(record);
}
//4.清空缓冲区
producer.flush();
//5.关闭生产者
producer.close();
}
}
消费者
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) {
//0.配置生产者了连接属性
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");
//1.创建Kafka消费者
KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
//2.订阅topics
consumer.subscribe(Arrays.asList("topic04"));
//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);
}
}
}
}
}
管理Topic
- 创建topic
Properties props=new Properties();
props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
AdminClient client= KafkaAdminClient.create(props);
client.createTopics(Arrays.asList(new NewTopic("topic01",3, (short) 3)));
client.close();
- 查看topic信息
Properties props=new Properties();
props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
AdminClient client= KafkaAdminClient.create(props);
ListTopicsResult topicsResult = client.listTopics();
for (String name : topicsResult.names().get()) {
System.out.println(name);
}
client.close();
- 获取topic详细信息
Properties props=new Properties();
props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
AdminClient client= KafkaAdminClient.create(props);
DescribeTopicsResult topicsResult = client.describeTopics(Arrays.asList("topic01"));
Map<String, KafkaFuture<TopicDescription>> values = topicsResult.values();
for (Map.Entry<String, KafkaFuture<TopicDescription>> entry : values.entrySet()) {
System.out.println("key:"+entry.getKey());
TopicDescription topicDescription = entry.getValue().get();
System.out.println(topicDescription);
}
client.close();
- 删除topic信息
```java
Properties props=new Properties();
props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
AdminClient client= KafkaAdminClient.create(props);
client.deleteTopics(Arrays.asList("topic01"));
client.close();
- 删除Topic
./bin/kafka-delete-records.sh --bootstrap-server CentOSA:9092,CentOSB:9092,CentOSC:9092 --offset-json-file /root/delete.json
- delete.json
{"partitions":
[{"topic": "topic01", "partition": 0,
"offset": 4}],
"version":1
}
目前使用Kafka API无法实现截断topic
Properties props=new Properties();
props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
AdminClient client= KafkaAdminClient.create(props);
Map<TopicPartition,RecordsToDelete> recordsToDeleteMap=new HashMap<>();
TopicPartition part = new TopicPartition("topic01", 0);
RecordsToDelete delete=RecordsToDelete.beforeOffset(8);
recordsToDeleteMap.put(part,delete);
client.deleteRecords(recordsToDeleteMap);
client.close();
偏移量控制
默认当用户使用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,"group2");
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");//默认值 latest
因为消费端在使用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) {
//0.配置生产者了连接属性
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);
//1.创建Kafka消费者
KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
//2.订阅topics
consumer.subscribe(Arrays.asList("topic03"));
//3.死循环读取消息
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);
}
}
}
}
指定消费分区
通过assign方式kafka对消费者的组管理策略失效。也就是说用户可以无需配置组ID。例如如下案例:
public class KafkaConsumerDemo {
public static void main(String[] args) {
//0.配置生产者了连接属性
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");
//1.创建Kafka消费者
KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
//2.指定分区
consumer.assign(Arrays.asList(new TopicPartition("topic04",1)));
consumer.seek(new TopicPartition("topic04",1),1);
//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);
}
}
}
}
}
如果使用assign方式使用手动提交offset没有意义,因为程序在启动的时候可以通过seek指定对应分区的偏移量。因此在asssign模式下一般不做任何offset管理
Kafka发送/接收Object
- 生产者发送object
public interface Serializer<T> extends Closeable {
void configure(Map<String, ?> configs, boolean isKey);
//重点实现serialize
byte[] serialize(String topic, T data);
default byte[] serialize(String topic, Headers headers, T data) {
return serialize(topic, data);
}
@Override
void 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);
}
@Override
void close();
}
- 实现序列化和反序列化
public class ObjectCodec implements Deserializer<Object>, Serializer<Object> {
@Override
public void configure(Map<String, ?> configs, boolean isKey) {
}
@Override
public byte[] serialize(String topic, Object data) {
return SerializationUtils.serialize((Serializable) data);
}
@Override
public Object deserialize(String topic, byte[] data) {
return SerializationUtils.deserialize(data);
}
@Override
public 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) {
//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);//重试3次
props.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,3000);//等待3s应答
props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);//开启幂等性
//1.创建Kafka生产者
KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);
//2.构建ProducerRecord
for (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>("topic06", decimalFormat.format(i), "user"+i);
//3.发送消息
producer.send(record);
}
//4.清空缓冲区
producer.flush();
//5.关闭生产者
producer.close();
}
生产者批量发送
生产者会尝试缓冲record,实现批量发送,通过一下配置控制发送时机,记住如果开启可batch,一定在关闭producer之前需要flush。
batch.size = 16384 //16KB 缓冲16kb数据本地
linger.ms = 2000 //默认逗留时间
public static void main(String[] args) {
//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);//设置逗留时常
//1.创建Kafka生产者
KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);
//2.构建ProducerRecord
for (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>("topic06", decimalFormat.format(i), "user"+i);
//3.发送消息
producer.send(record);
}
//4.清空缓冲区
producer.flush();
//5.关闭生产者
producer.close();
}
生产者事务
kafka生产者事务指的是在发送多个数据的时候,保证多个Record记录发送的原子性。如果有一条发送失败就回退,但是需要注意在使用kafka事务的时候需要调整消费者的事务隔离级别设置为read_committed因为kafka默认的事务隔离策略是read_uncommitted
- 开启事务
transactional.id=transaction-1 //必须保证唯一
enable.idempotence=true //开启kafka的幂等性
生产者Only
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.订阅topics
consumer.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 org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.Deserializer;
import org.apache.kafka.common.serialization.Serializer;
import java.util.Properties;
import java.util.UUID;
public class KafkaUtils {
public static KafkaConsumer<String, String> buildKafkaConsumer(String servers, Class<? extends Deserializer> keyDeserializer,
Class<? extends Deserializer> valueDeserializer,String group) {
Properties props = new Properties();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,servers);
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,keyDeserializer);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,valueDeserializer);
props.put(ConsumerConfig.GROUP_ID_CONFIG,group);
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");
props.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG,"read_committed");
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false);//设置为手动提交
return new KafkaConsumer<String, String>(props);
}
public static KafkaProducer<String, String> buildKafkaProducer(String servers, Class<? extends Serializer> keySerializer,
Class<? extends Serializer> valueSerializer) {
//0.配置生产者了连接属性
Properties props = new Properties();
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,servers);
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,keySerializer);
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,valueSerializer);
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);
}
}
KafkaProducerAndConsumer
import com.baizhi.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);
}
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
- KafkaApplicationDemo
@SpringBootApplication
@EnableScheduling
public class KafkaApplicationDemo {
@Autowired
private 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);
}
}