Kafka笔记

Kafka

一个分布式流媒体平台，类似于消息队列或企业消息传递系统

官网

消息中间件对比

特性	ActiveMQ	RabbitMQ	RocketMQ	Kafka
开发语言	Java	erlang	Java	scale
单机吞吐量	万级	万级	10万级	100万级
时效性	ms	us	ms	ms级以内
可扩展性	高(主从)	高(主从)仲裁队列非常高(集群)	非常高(分布式)	非常高(分布式)
功能特性	成熟的产品，较全的文档，各种协议支持好	并发能力强，性能好，延迟低	MQ功能非常完善，扩展性好	只支持主要的MQ功能，主要应用于大数据领域

根据不同需求的选择建议

消息中间件	建议
Kafka	追求高吞吐量，适合产生大量数据的互联网服务的数据收集业务
RocketMQ	可靠性要求很高的金融互联网领域，稳定性高，经历了多次阿里双十一考验
RabbitMQ	性能较好，社区活跃度高，数据量没有那么大，优先选择功能比较完备的RabbitMQ

常用角色:

producer(主题生产者): 发布消息的对象称之为主题生产者

topic(主题): Kafka将消息分门别类，每一类的消息称之为一个主题

consumer(主题消费者): 订阅消息并处理发布的消息的对象称之为主题消费者

broker(代理): 已发布的消息保存在一组服务器，称之为Kafka集群，集群中的每一个服务器都是一个代理(Broker)，消费者可以订阅一个或多个主题，并从Broker拉取数据，从而小消费这些已发布的消息

Kafka环境搭建

Kafka对于Zookeeper是强依赖，保存Kafka相关的节点数据，所以安装Kafka之前必须先安装Zookeeper

新版本的Kafka已经摆脱了对Zookeeper的强依赖

创建网络zookeeper_network

docker network create --driver bridge zookeeper_network

查看网络zookeeper_network的详细信息

docker inspect zookeeper_network

使用该网络创建zookeeper容器

docker run -d --name zookeeper --network zookeeper_network -p 2181:2181 zookeeper:3.4.14

查看zookeeper容器详细信息

docker inspect zookeeper

使用同一个网络创建kafka容器

KAFKA_ZOOKEEPER_CONNECT 后面是zookeeper容器的ip地址和端口

KAFKA_ADVERTISED_LISTENERS 后面的ip是虚拟机的ip

docker run -d --name kafka \
-p 9092:9092 \
--env KAFKA_BROKER_ID=0 \
--env KAFKA_ZOOKEEPER_CONNECT=172.25.0.2:2181 \
--env KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.200.130:9092 \
--env KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 \
--env KAFKA_HEAP_OPTS="-Xmx256M -Xms256M" \
--network zookeeper_network \
wurstmeister/kafka:2.12-2.3.1

查看kafka容器详细信息

docker inspect kafka

使用kafka tool连接 zookeeper

入门案例

1. 导入依赖

   <!-- kafka和spring整合 -->
   <dependency>
       <groupId>org.springframework.kafka</groupId>
       <artifactId>spring-kafka</artifactId>
       <exclusions>
       	<exclusion>
           	<groupId>org.apache.kafka</groupId>
               <artifactId>kafka-clients</artifactId>
           </exclusion>
       </exclusions>
   </dependency>
   <!-- kafka原生依赖 -->
   <dependency>
       <groupId>org.apache.kafka</groupId>
       <artifactId>kafka-clients</artifactId>
   </dependency>

2. 测试

   1. 生产者发送消息

   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 ProducerQuickStart100 {
   
       public static void main(String[] args) {
           //1.kafka的配置信息
           Properties properties = new Properties();
           //kafka的连接地址
           properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.200.130:9092");
           //发送失败，失败的重试次数
           properties.put(ProducerConfig.RETRIES_CONFIG,5);
           //消息key的序列化器
           properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
           //消息value的序列化器
   properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
   
           //2.生产者对象
           KafkaProducer<String,String> producer = new KafkaProducer<String, String>(properties);
   
           //封装发送的消息
           ProducerRecord<String,String> record = new ProducerRecord<String, String>("test-topic","100001","hello kafka");
   
           //3.发送消息
           Future<RecordMetadata> send = producer.send(record);
   
           RecordMetadata recordMetadata = send.get();
           
           System.out.println(recordMetadat.partition());
           System.out.println(recordMetadata.topic());
           System.out.println(recordMetadata.offset());
           
        //4.关闭消息通道，必须关闭，否则消息发送不成功
           producer.close();
    }
  }

2. 消费者接收消息

 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.Collections;
 import java.util.Properties;
 
 /**
  * 消费者
  */
 public class ConsumerQuickStart100 {
 
     public static void main(String[] args) {
         //1.添加kafka的配置信息
         Properties properties = new Properties();
         //kafka的连接地址
         properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.200.130:9092");
         //消费者组 同一个组下消费者订阅同一个主题，消息只能被其中一个消费者取走 不同一个组下消费者订阅同一个主题则特们都可以消费同一条消息
         properties.put(ConsumerConfig.GROUP_ID_CONFIG, "group2");
         //消息的反序列化器
         properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
         properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
 
         //2.消费者对象
         KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(properties);
 
         //3.订阅主题
         consumer.subscribe(Collections.singletonList("test-topic"));
 
         //当前线程一直处于监听状态
         while (true) {
             //4.获取消息
             ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(1000));
             for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                 System.out.println(consumerRecord.key());
                 System.out.println(consumerRecord.value());
             }
         }
     }
 }

分区机制

Kafka中的分区机制是指将每个主题划分成多个分区(Partition)，可以处理更多的消息，不受单台服务器的限制，可以不受限地处理更多的数据

分区

分区策略	说明
轮询策略	按顺序轮流将每条数据分配到每个分区中
随机策略	每次都随机地将消息分配到每个分区
按键保存策略	生产者发送数据的时候，可以指定一个key，计算这个key的hashCode值，按照hashCode的值对不同消息进行存储

修改分区

1. 进入容器

   docker exec -it kafka /bin/bash
   

2. 修改配置文件

   cd /opt/kafka/config
   vi server.properties
   将num.partitions=1改成num.partitions=2
   

3. 重启kafka

   docker restart kafka
   

高可用设计方案

集群

• Kafka的服务器端由被称为Broker的服务进程构成，即一个Kafka集群由多个Broker组成
• 这样如果集群中某一台机器宕机，其他机器上的Broker也依然能够对外提供服务

备份机制

Kafka中消息的备份又叫做副本

Kafka定义了两类副本:

• 领导者副本(Leader Replica)
• 追随者副本(Follower Replica)

同步方式:

ISR(in-sync-replica)需要同步复制保存的follower

如果leader失效，需要选出新的leader，选举的规则:

1. 选举时优先从ISR中选定，因为这个列表中follower的数据是与leader同步的
2. 如果ISR列表中的follower都失效，只能从其他的follower中选取

极端情况，如果所有的副本都失效，此时有两个方案:

1. 等待ISR中的一个活过来，选为Leader，数据可靠，但活过来的时间不一定
2. 选择第一个活过来的Replication，不一定是ISR中的，xuanweiLeader，以最快速度恢复可用性，但数据不一定完整

消息发送类型

同步发送

使用send()方法发送，它会返回一个Future对象，调用get()方法进行等待，就可以知道消息是否发送成功

RecordMetadata recordMetadata = producer.send(kvProducerRecord).get();
System.out.println(recordMetadata.offset());

异步发送

调用send()方法，并指定一个回调函数，服务器在返回响应时调用函数

//异步消息发送
producer.send(kvProducerRecord, new Callback() {
    @Override
    public void onCompletion(RecordMetadata recordMetadata, Exception e) {
        if(e != null){
            System.out.println("记录异常信息到日志表中");
        }
        System.out.println(recordMetadata.offset());
    }
});

参数配置

• ack: 消息响应

  • 代码配置:

  //ack配置  消息确认机制
  prop.put(ProducerConfig.ACKS_CONFIG,"all");
  

  • 参数的选择说明

  确认机制	说明
  acks=0	生产者在成功写入消息之前不会等待任何来自服务器的响应,消息有丢失的风险，但是速度最快
  acks=1（默认值）	只要集群首领节点收到消息，生产者就会收到一个来自服务器的成功响应
  acks=all	只有当所有参与赋值的节点全部收到消息时，生产者才会收到一个来自服务器的成功响应

• retries: 失败重试次数，生产者从服务器收到的错误可能是临时性错误，在这种情况下，retries参数的值决定了生产者可以重发消息的次数，如果达到这个次数，生产者会放弃重试返回错误，默认情况下，生产者会在每次重试之间等待100ms

  • 代码中配置方式:

  //重试次数
  prop.put(ProducerConfig.RETRIES_CONFIG,10);
  

• 消息压缩

  • 默认情况下，消息压缩时不会被压缩

  • 代码中配置方式:

    //数据压缩
    prop.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"lz4");
    

    压缩算法	说明
    snappy	占用较少的 CPU， 却能提供较好的性能和相当可观的压缩比， 如果看重性能和网络带宽，建议采用
    lz4	占用较少的 CPU， 压缩和解压缩速度较快，压缩比也很客观
    gzip	占用较多的 CPU，但会提供更高的压缩比，网络带宽有限，可以使用这种算法

  nginx默认可以压缩gzip

  使用压缩可以降低网络传输开销和存储开销，而这往往是向Kafka发送消息的瓶颈所在

消息有序性

消费者组

• 消费者组: 指的就是由一个或多个消费者组成的群体
• 一个发布在Topic上消息被分发给此消费者组中的一个消费者
  • 所有消费者都在一个组中，那么这就变成了queue模型
  • 所有的消费者都在不同的组中，那么就完全变成了发布-订阅模型

消费有序性应用场景:

1. 即时消息中的单对单聊天和群聊，保证发送方消息发送顺序和接收方的顺序一致
2. 充值转账两个渠道在同一个时间进行余额变换，短信通知必须要有顺序

实现消息有序性:

方式一: 设置topic下只有一个分区

设置kafka的配置server.properties
num.partation=1

方式二: topic下可以有多个分区，但是收发消息时，只使用指定的一个分区，注意消费者可以启用多个，但是需要保证在同一个group下订阅该主题

// 生产者指定分区
// 参数1: 主题名称 参数2: 几号分区 参数3: 消息的key 参数4: 消息的内容
ProducerRecord<String, String> record = new ProducerRecord<String, String>("test-topic", 0, "key", "value");

// 消费者指定分区
TopicPartition topicPartition = new TopicPartition("test-topic", 0);
consumer.assign(Collections.signletonList(topicPartition));

手动提交偏移量

可能会出现的问题:

问题一: 如果提交的偏移量小于客户端处理的最后一个消息的偏移量，那么处于两个偏移量之间的消息就会被重复处理

问题二: 如果提交的偏移量大于客户端的最后一个消息的偏移量，那么处于两个偏移量之间的消息就会对视

提交偏移量的方式有两种，分别是自动提交偏移量和手动提交

1. 自动提交偏移量:

   当enable.auto.commit被设置为true，提交方式就是让消费者自动提交偏移量，每隔5秒消费者就会自动把从poll()方法接收的最大偏移量提交上去

2. 手动提交，当enable.quto.commit被设置为false可以有一下三种提交方式:

   1. 提交当前偏移量(自动提交)
   2. 异步提交
   3. 同步和异步组合提交

• 提交当前偏移量（同步提交）

把enable.auto.commit设置为false,让应用程序决定何时提交偏移量。使用commitSync()提交偏移量，commitSync()将会提交poll返回的最新的偏移量，所以在处理完所有记录后要确保调用了commitSync()方法。否则还是会有消息丢失的风险。

只要没有发生不可恢复的错误，commitSync()方法会一直尝试直至提交成功，如果提交失败也可以记录到错误日志里。

while (true){
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
    for (ConsumerRecord<String, String> record : records) {
        System.out.println(record.value());
        System.out.println(record.key());
    

    }
        try {
            consumer.commitSync();//同步提交当前最新的偏移量
        }catch (CommitFailedException e){
            System.out.println("记录提交失败的异常："+e);
        }
}

• 异步提交

手动提交有一个缺点，那就是当发起提交调用时应用会阻塞。当然我们可以减少手动提交的频率，但这个会增加消息重复的概率（和自动提交一样）。另外一个解决办法是，使用异步提交的API。

while (true){
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
    for (ConsumerRecord<String, String> record : records) {
        System.out.println(record.value());
        System.out.println(record.key());
    }
    consumer.commitAsync(new OffsetCommitCallback() {
        @Override
        public void onComplete(Map<TopicPartition, OffsetAndMetadata> map, Exception e) {
            if(e!=null){
                System.out.println("记录错误的提交偏移量："+ map+",异常信息"+e);
            }
        }
    });
}

• 同步和异步组合提交

异步提交也有个缺点，那就是如果服务器返回提交失败，异步提交不会进行重试。相比较起来，同步提交会进行重试直到成功或者最后抛出异常给应用。异步提交没有实现重试是因为，如果同时存在多个异步提交，进行重试可能会导致位移覆盖。

举个例子，假如我们发起了一个异步提交commitA，此时的提交位移为2000，随后又发起了一个异步提交commitB且位移为3000；commitA提交失败但commitB提交成功，此时commitA进行重试并成功的话，会将实际上将已经提交的位移从3000回滚到2000，导致消息重复消费。

try {
    while (true){
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
        for (ConsumerRecord<String, String> record : records) {
            System.out.println(record.value());
            System.out.println(record.key());
        }
        consumer.commitAsync();
    }
}catch (Exception e){+
    e.printStackTrace();
    System.out.println("记录错误信息："+e);
}finally {
    try {
        consumer.commitSync();
    }finally {
        consumer.close();
    }
}

SpringBoot整合Kafka

入门步骤

1.导入spring-kafka依赖信息

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- kafkfa -->
    <dependency>
        <groupId>org.springframework.kafka</groupId>
        <artifactId>spring-kafka</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
    </dependency>
</dependencies>

2.在resources下创建文件application.yml

server:
  port: 9991
spring:
  application:
    name: kafka-demo
  kafka:
    bootstrap-servers: 192.168.200.130:9092
    producer:
      retries: 10
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer:
      group-id: ${spring.application.name}-test
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

3.消息生产者

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private KafkaTemplate<String,String> kafkaTemplate;

    @GetMapping("/hello")
    public String hello(){
        kafkaTemplate.send("itcast-topic","黑马程序员");
        return "ok";
    }
}

4.消息消费者

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Component
public class HelloListener {

    @KafkaListener(topics = {"itcast-topic","itcast-topic2"})
    public void onMessage(String message){
        if(!StringUtils.isEmpty(message)){
            System.out.println(message);
        }

    }
}

传递消息

目前springboot整合后的kafka，因为序列化器是StringSerializer，这个时候如果需要传递对象可以有两种方式

方式一：可以自定义序列化器，对象类型众多，这种方式通用性不强，不介绍

方式二：可以把要传递的对象进行转json字符串，接收消息后再转为对象即可，本项目采用这种方式

• 发送消息

@GetMapping("/hello")
public String hello(){
    User user = new User();
    user.setUsername("xiaowang");
    user.setAge(18);

    kafkaTemplate.send("user-topic", JSON.toJSONString(user));

    return "ok";
}

• 接收消息

import com.alibaba.fastjson.JSON;
import com.heima.kafka.pojo.User;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Component
public class HelloListener {

    @KafkaListener(topics = "user-topic")
    public void onMessage(String message){
        if(!StringUtils.isEmpty(message)){
            User user = JSON.parseObject(message, User.class);
            System.out.println(user);
        }

    }
}