文章目录
- 1,消息队列的两种模式
- 点对点模式
- 发布/订阅模式
- 2,kafka的基础架构
- 3,kafka的命令行操作
- 4,kafka的发送过程
- 5,Idea编写kafka
- 6,kafka分区器的优点
- 7,分区的策略
- 主要有三种分区策略
- 8,kafka的可靠传输
- a,解决重复传输----幂等性
- b,幂等性的原理
- c,事务
目前md文件尚未上传到git仓库中,如果需要md文件的可以私信我
kafka中的结构
组件 | 是什么 |
Producer | 消息生产者:向Broker发送消息的客户端 |
Producer | 消息消费者:从Broker读取消息的客户端 |
Broker | 消息中间间处理节点:一个Kafka节点就是一个Broker,一个或多个Broker可以组成一个Kafka集群(一般集群建议奇数台,最少三台) |
Topic | 主题:发布到Kafka集群的每条消息都需要指定一个Topic,Kafka的消息都是保存在Topic中 |
Partition | 分区:物理上的存储概念,一个Topic可以分为多个Partition,每个Partition内部都是有序的,但是多个分区组合起来的数据并不是有序的 |
Consumer Group | 消费者组:每个Consumer属于一个特定的Consumer Group(CG),一条消息可以发送到多个不同的CG,但同一个分区的数据只有该CG中的一个Consumer能消费该数据 |
1,消息队列的两种模式
这个和rabbitmq是不一样的,mq的模式要多于kafka的,卡夫卡分为两种模式,一种是点对点,一种是发布订阅的模式
点对点模式
当收到消费者的确定的时候,是会删除消息的
发布/订阅模式
2,kafka的基础架构
生产者----->>kafka----->>消费者
1,kafka可以创建集群,创建多个broker(分散数据的大小)
2,消费者也可以创建组的形式,一个组多个消费者,提高消费的速度。**注意:**同个组内的消费者不能消费同一个partition
3,为了可用,每个partition增加若干副本
3,kafka的命令行操作
4,kafka的发送过程
(1)首先有个main线程,启动生产者,调用send()进行发送,这个时候,可以配置拦截器,一般是使用flume中的拦截器
(2)调用序列化器,方便在网上传输,不是使用的Java中的序列化,应为java中的序列化太过于繁重,需要大量的内容来保证验证等
(3)采用分区器,吧数据分布到不同的队列上,这是基于内存上的,默认的总的大小是32m。每一个小块默认是16kb
(4)当达到batch.size,或者linger.size中的任意一个的时候,就会有一个sender线程去读取,进行转发。
5,Idea编写kafka
(1),导入依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>kafka</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.target>1.8</maven.compiler.target>
<maven.compiler.source>1.8</maven.compiler.source>
<junit.version>5.7.0</junit.version>
</properties>
<dependencies>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>3.0.0</version>
</dependency>
</dependencies>
</project>
(2),编写代码
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
public class test01 {
public static void main(String[] args) {
//配置
Properties properties=new Properties();
//连接集群
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"主机名:9092");
//指定的keycalue进行序列化
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
//创建kafka对象
KafkaProducer<String,String> kafkaProducer=new KafkaProducer<String, String>(properties);
//发送数据
for(int i=0;i<5;i++){
//linux中要建立first这个topic,而且要开启kafka
kafkaProducer.send(new ProducerRecord<>("first","dadaobajiao"+i));
//kafkaProducer.send(new ProducerRecord<>("first","dadaobajiao"+i),new callback{重写});,这是含有回调的异步
// kafkaProducer.send(new ProducerRecord<>("first","dadaobajiao"+i)).get();
//这是同步发送
}
//关闭资源
kafkaProducer.close();
}
}
6,kafka分区器的优点
7,分区的策略
主要有三种分区策略
(1)指明 partition 的情况下,直接将指明的值直接作为 partiton 值;
(2)没有指明 partition 值但有 key 的情况下,将key 的 hash 值与topic 的 partition数进行取余得到partition 值;
(3)既没有 partition 值又没有 key 值的情况下,第一次调用时随机生成一个整数(后面每次调用在这个整数上自增),将这个值与 topic 可用的 partition 总数取余得到 partition值,也就是常说的round-robin轮询算法。
8,kafka的可靠传输
对于可靠性是由三种,分别是0,1,-1
其中-1可靠性最强,但是效率是最低的。(会发生重复传输)
使完全可靠可以建立一个ISR队列
a,解决重复传输----幂等性
• 至少一次(At Least Once)= ACK级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2
• 最多一次(At Most Once)****= ACK级别设置为0
• 总结:
At Least Once可以保证数据不丢失,但是不能保证数据不重复;
At Most Once可以保证数据不重复,但是不能保证数据不丢失。
• **精确一次(Exactly Once):**对于一些非常重要的信息,比如和钱相关的数据,要求数据既不能重复也不丢失。
Kafka 0.11版本以后,引入了一项重大特性:幂等性和事务。
b,幂等性的原理
幂等性就是指Producer不论向Broker发送多少次重复数据,Broker端都只会持久化一条,保证了不重复。
精确一次(Exactly Once) = 幂等性 + 至少一次( ack=-1 + 分区副本数>=2 + ISR最小副本数量**>=2**) 。
注意:幂等性在多个会话中,不能保证消息不会重复
重复数据的判断标准:具有**<PID, Partition, SeqNumber>**相同主键的消息提交时,Broker只会持久化一条。其
中PID是Kafka每次重启都会分配一个新的;Partition 表示分区号;Sequence Number是单调自增的。
所以幂等性只能保证的是在单分区单会话内不重复。
2)如何使用幂等性
开启参数 enable.idempotence 默认为 true,false 关闭。
c,事务
开启事务,必须要开启幂等性
事务的API
// 1 初始化事务
void initTransactions();
// 2 开启事务
void beginTransaction() throws ProducerFencedException;
// 3 在事务内提交已经消费的偏移量(主要用于消费者)
void sendOffsetsToTransaction(Map<TopicPartition, OffsetAndMetadata> offsets,
String consumerGroupId) throws
ProducerFencedException;
// 4 提交事务
void commitTransaction() throws ProducerFencedException;
// 5 放弃事务(类似于回滚事务的操作)
void abortTransaction() throws ProducerFencedException;
代码,其中注意的使一定要对事务指定id
public static void main(String[] args) {
// 0 配置
Properties properties = new Properties();
// 连接集群 bootstrap.servers
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092,hadoop103:9092");
// 指定对应的key和value的序列化类型 key.serializer
// properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
// 指定事务id
properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "tranactional_id_01");
// 1 创建kafka生产者对象
// "" hello
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
//初始化事务
kafkaProducer.initTransactions();
//开启事务
kafkaProducer.beginTransaction();
try {
// 2 发送数据
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new ProducerRecord<>("first", "atguigu" + i));
}
//模拟事务出现异常
int i = 1 / 0;
//提交事务
kafkaProducer.commitTransaction();
} catch (Exception e) {
kafkaProducer.abortTransaction();
} finally {
// 3 关闭资源
kafkaProducer.close();
}