Kafka多维度系统精讲，从入门到熟练掌握

最新推荐文章于 2023-03-31 08:07:08 发布
最新推荐文章于 2023-03-31 08:07:08 发布
阅读量2.5k 收藏 14
点赞数 3
分类专栏： # kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangshengwei230612/article/details/106504146
版权

课程学习连接：Kafka多维度系统精讲，从入门到熟练掌握

kafka的producer是线程安全的

kafka的consumer不是线程安全的

第1章 课程导学与学习指南

1-1 导学

在这里插入图片描述
在这里插入图片描述

第2章 Kafka入门——开发环境准备

2-1 环境准备
2-2 VMware安装
2-3 VMware添加Centos镜像
2-4 CentOS7安装
2-5 XShell使用介绍
2-6 环境准备常见问题介绍

第3章 Kafka入门——Kafka基础操作

3-1 章节介绍

3-2 kafka自我介绍

在这里插入图片描述
3-3 JDK安装
3-4 Zookeeper安装启动
3-5 kafka配置

3-6 Kafka基本概念及使用演示

在这里插入图片描述

第4章 Kafka核心API——Kafka客户端操作

4-1 内容概述

在这里插入图片描述
4-2 五类Kafka客户端作用和区别

前三个常用
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
4-3 学习准备-初始化工程
kafka官网：kafka.apache.org
在这里插入图片描述
在这里插入图片描述
4-4 AdminClient客户端建立
在这里插入图片描述
4-5 创建Topic演示 (05:50)
4-6 查看Topic列表及Internal杂谈 (07:01)
4-7 删除Topic (02:44)
4-8 Topic描述信息查看 (05:41)
4-9 Topic配置信息查看 (06:49)
4-10 Topic配置信息修改 (09:25)
4-11 Partition增加 (05:10)

import org.apache.kafka.clients.admin.*;
import org.apache.kafka.common.KafkaFuture;
import org.apache.kafka.common.config.ConfigResource;
import org.apache.kafka.common.internals.Topic;
import org.apache.kafka.server.quota.ClientQuotaEntity;

import java.util.*;
import java.util.concurrent.ExecutionException;

public class AdminSample {

    public final static String TOPIC_NAME="jiangzh-topic";

    public static void main(String[] args) throws Exception {
//        AdminClient adminClient = AdminSample.adminClient();
//        System.out.println("adminClient : "+ adminClient);
        // 创建Topic实例
       createTopic();
        // 删除Topic实例
//        delTopics();
        // 获取Topic列表
//        topicLists();
        // 描述Topic
        describeTopics();
        // 修改Config
//        alterConfig();
        // 查询Config
//        describeConfig();
        // 增加partition数量
//        incrPartitions(2);
    }

    /*
        增加partition数量
     */
    public static void incrPartitions(int partitions) throws Exception{
        AdminClient adminClient = adminClient();
        Map<String, NewPartitions> partitionsMap = new HashMap<>();
        NewPartitions newPartitions = NewPartitions.increaseTo(partitions);
        partitionsMap.put(TOPIC_NAME, newPartitions);


        CreatePartitionsResult createPartitionsResult = adminClient.createPartitions(partitionsMap);
        createPartitionsResult.all().get();
    }

    /*
        修改Config信息
     */
    public static void alterConfig() throws Exception{
        AdminClient adminClient = adminClient();
//        Map<ConfigResource,Config> configMaps = new HashMap<>();
//
//        // 组织两个参数
//        ConfigResource configResource = new ConfigResource(ConfigResource.Type.TOPIC, TOPIC_NAME);
//        Config config = new Config(Arrays.asList(new ConfigEntry("preallocate","true")));
//        configMaps.put(configResource,config);
//        AlterConfigsResult alterConfigsResult = adminClient.alterConfigs(configMaps);

        /*
            从 2.3以上的版本新修改的API
         */
        Map<ConfigResource,Collection<AlterConfigOp>> configMaps = new HashMap<>();
        // 组织两个参数
        ConfigResource configResource = new ConfigResource(ConfigResource.Type.TOPIC, TOPIC_NAME);
        AlterConfigOp alterConfigOp =
                new AlterConfigOp(new ConfigEntry("preallocate","false"),AlterConfigOp.OpType.SET);
        configMaps.put(configResource,Arrays.asList(alterConfigOp));

        AlterConfigsResult alterConfigsResult = adminClient.incrementalAlterConfigs(configMaps);
        alterConfigsResult.all().get();
    }

    /**
        查看配置信息
        ConfigResource(type=TOPIC, name='jiangzh-topic') ,
        Config(
            entries=[
             ConfigEntry(
               name=compression.type,
               value=producer,
               source=DEFAULT_CONFIG,
               isSensitive=false,
               isReadOnly=false,
               synonyms=[]),
             ConfigEntry(
                name=leader.replication.throttled.replicas,
                value=,
                source=DEFAULT_CONFIG,
                isSensitive=false,
                isReadOnly=false,
                synonyms=[]), ConfigEntry(name=message.downconversion.enable, value=true, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=min.insync.replicas, value=1, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=segment.jitter.ms, value=0, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=cleanup.policy, value=delete, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=flush.ms, value=9223372036854775807, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=follower.replication.throttled.replicas, value=, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=segment.bytes, value=1073741824, source=STATIC_BROKER_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=retention.ms, value=604800000, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=flush.messages, value=9223372036854775807, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=message.format.version, value=2.4-IV1, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=file.delete.delay.ms, value=60000, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=max.compaction.lag.ms, value=9223372036854775807, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=max.message.bytes, value=1000012, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=min.compaction.lag.ms, value=0, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=message.timestamp.type, value=CreateTime, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]),
             ConfigEntry(name=preallocate, value=false, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=min.cleanable.dirty.ratio, value=0.5, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=index.interval.bytes, value=4096, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=unclean.leader.election.enable, value=false, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=retention.bytes, value=-1, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=delete.retention.ms, value=86400000, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=segment.ms, value=604800000, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=message.timestamp.difference.max.ms, value=9223372036854775807, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[]), ConfigEntry(name=segment.index.bytes, value=10485760, source=DEFAULT_CONFIG, isSensitive=false, isReadOnly=false, synonyms=[])])
     */
    public static void describeConfig() throws Exception{
        AdminClient adminClient = adminClient();
        // TODO 这里做一个预留，集群时会讲到
//        ConfigResource configResource = new ConfigResource(ConfigResource.Type.BROKER, TOPIC_NAME);

        ConfigResource configResource = new ConfigResource(ConfigResource.Type.TOPIC, TOPIC_NAME);
        DescribeConfigsResult describeConfigsResult = adminClient.describeConfigs(Arrays.asList(configResource));
        Map<ConfigResource, Config> configResourceConfigMap = describeConfigsResult.all().get();
        configResourceConfigMap.entrySet().stream().forEach((entry)->{
            System.out.println("configResource : "+entry.getKey()+" , Config : "+entry.getValue());
        });
    }

    /**
        描述Topic
        name ：jiangzh-topic ,
        desc: (name=jiangzh-topic,
            internal=false,
            partitions=
                (partition=0,
                 leader=192.168.220.128:9092
                 (id: 0 rack: null),
                 replicas=192.168.220.128:9092
                 (id: 0 rack: null),
                 isr=192.168.220.128:9092
                 (id: 0 rack: null)),
                 authorizedOperations=[])
     */
    public static void describeTopics() throws Exception {
        AdminClient adminClient = adminClient();
        DescribeTopicsResult describeTopicsResult = adminClient.describeTopics(Arrays.asList(TOPIC_NAME));
        Map<String, TopicDescription> stringTopicDescriptionMap = describeTopicsResult.all().get();
        Set<Map.Entry<String, TopicDescription>> entries = stringTopicDescriptionMap.entrySet();
        entries.stream().forEach((entry)->{
            System.out.println("name ："+entry.getKey()+" , desc: "+ entry.getValue());
        });
    }

    /*
        删除Topic
     */
    public static void delTopics() throws Exception {
        AdminClient adminClient = adminClient();
        DeleteTopicsResult deleteTopicsResult = adminClient.deleteTopics(Arrays.asList(TOPIC_NAME));
        deleteTopicsResult.all().get();
    }

    /*
        获取Topic列表
     */
    public static void topicLists() throws Exception {
        AdminClient adminClient = adminClient();
        // 是否查看internal选项
        ListTopicsOptions options = new ListTopicsOptions();
        options.listInternal(true);
//        ListTopicsResult listTopicsResult = adminClient.listTopics();
        ListTopicsResult listTopicsResult = adminClient.listTopics(options);
        Set<String> names = listTopicsResult.names().get();
        Collection<TopicListing> topicListings = listTopicsResult.listings().get();
        KafkaFuture<Map<String, TopicListing>> mapKafkaFuture = listTopicsResult.namesToListings();
        // 打印names
        names.stream().forEach(System.out::println);
        // 打印topicListings
        topicListings.stream().forEach((topicList)->{
            System.out.println(topicList);
        });
    }

    /*
        创建Topic实例
     */
    public static void createTopic() {
        AdminClient adminClient = adminClient();
        // 副本因子
        Short rs = 1;
        NewTopic newTopic = new NewTopic(TOPIC_NAME, 1 , rs);
        CreateTopicsResult topics = adminClient.createTopics(Arrays.asList(newTopic));
        System.out.println("CreateTopicsResult : "+ topics);
    }

    /*
        设置AdminClient
     */
    public static AdminClient adminClient(){
        Properties properties = new Properties();
        properties.setProperty(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"kafka1:9092");

        AdminClient adminClient = AdminClient.create(properties);
        return adminClient;
    }

}

第5章 Kafka核心API——Producer生产者

5-1 Producer章节介绍

在这里插入图片描述

5-2 Producer异步发送演示

    /*
        Producer异步发送演示
     */
    public static void producerSend(){
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BOOTSTRAP_SERVERS);
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        properties.put(ProducerConfig.RETRIES_CONFIG,"0");
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        properties.put(ProducerConfig.LINGER_MS_CONFIG,"1");
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");

        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");

        // Producer的主对象
        Producer<String,String> producer = new KafkaProducer<>(properties);

        // 消息对象 - ProducerRecoder
        for(int i=0;i<10;i++){
            ProducerRecord<String,String> record =
                    new ProducerRecord<>(TOPIC_NAME,"key-"+i,"value-"+i);

            producer.send(record);
        }

        // 所有的通道打开都需要关闭
        producer.close();
    }

5-3 Producer异步阻塞发送演示

/*
        Producer异步阻塞发送（同步发送）
     */
    public static void producerSyncSend() throws ExecutionException, InterruptedException {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BOOTSTRAP_SERVERS);
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        properties.put(ProducerConfig.RETRIES_CONFIG,"0");
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        properties.put(ProducerConfig.LINGER_MS_CONFIG,"1");
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");

        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");

        // Producer的主对象
        Producer<String,String> producer = new KafkaProducer<>(properties);

        // 消息对象 - ProducerRecoder
        for(int i=0;i<10;i++){
            String key = "key-"+i;
            ProducerRecord<String,String> record =
                    new ProducerRecord<>(TOPIC_NAME,key,"value-"+i);

            Future<RecordMetadata> send = producer.send(record);
            //同步主要是 通过异步阻塞的实现,  send.get就会阻塞
            RecordMetadata recordMetadata = send.get();
            System.out.println(key + "partition : "+recordMetadata.partition()+" , offset : "+recordMetadata.offset());
        }

        // 所有的通道打开都需要关闭
        producer.close();
    }

5-4 Producer异步回调发送演示

    /*
        Producer异步发送带回调函数
     */
    public static void producerSendWithCallback(){
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.220.128:9092");
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        properties.put(ProducerConfig.RETRIES_CONFIG,"0");
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        properties.put(ProducerConfig.LINGER_MS_CONFIG,"1");
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");

        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");

        // Producer的主对象
        Producer<String,String> producer = new KafkaProducer<>(properties);

        // 消息对象 - ProducerRecoder
        for(int i=0;i<10;i++){
            ProducerRecord<String,String> record =
                    new ProducerRecord<>(TOPIC_NAME,"key-"+i,"value-"+i);

            producer.send(record, new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    System.out.println(
                            "partition : "+recordMetadata.partition()+" , offset : "+recordMetadata.offset());
                }
            });
        }

        // 所有的通道打开都需要关闭
        producer.close();
    }

5-5 Producer源码讲解

在这里插入图片描述
Producer 发送流程
在这里插入图片描述

5-6 Producer生产者原理

在这里插入图片描述

5-7 Producer自定义Partition负载均衡


    /*
        Producer异步发送带回调函数和Partition负载均衡
     */
    public static void producerSendWithCallbackAndPartition(){
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"10.139.12.150:9092");
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        properties.put(ProducerConfig.RETRIES_CONFIG,"0");
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        properties.put(ProducerConfig.LINGER_MS_CONFIG,"1");
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");

        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");
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"com.imooc.jiangzh.kafka.producer.SamplePartition");

        // Producer的主对象
        Producer<String,String> producer = new KafkaProducer<>(properties);

        // 消息对象 - ProducerRecoder
        for(int i=0;i<10;i++){
            ProducerRecord<String,String> record =
                    new ProducerRecord<>(TOPIC_NAME,"key-"+i,"value-"+i);

            producer.send(record, new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    System.out.println(
                            "partition : "+recordMetadata.partition()+" , offset : "+recordMetadata.offset());
                }
            });
        }

        // 所有的通道打开都需要关闭
        producer.close();
    }

5-8 消息传递保障

发送应答ack
producer 需要server 接收到数据之后发出的确认接收的信号，此项配置就是指procuder需要多少个这样的确认信号。此配置实际上代表了数据备份的可用性。以下设置为常用选项：

  • （1）acks=0： 设置为0 表示producer 不需要等待任何确认收到的信息。副本将立即加到socket buffer 并认为已经发送。没有任何保障可以保证此种情况下server 已经成功接收数据，同时重试配置不会发生作用（因为客户端不知道是否失败）回馈的offset 会总是设置为-1；
  • （2）acks=1： 这意味着至少要等待leader已经成功将数据写入本地log，但是并没有等待所有follower 是否成功写入。这种情况下，如果follower 没有成功备份数据，而此时leader又挂掉，则消息会丢失。
  • （3）acks=all： 这意味着leader 需要等待所有备份都成功写入日志，这种策略会保证只要有一个备份存活就不会丢失数据。这是最强的保证。
  • （4）其他的设置，例如acks=2 也是可以的，这将需要给定的acks 数量，但是这种策略一般很少用。
 properties.put(ProducerConfig.ACKS_CONFIG,"all");

第6章 实战“慕问卷”开发 —— 微信小程序部分

6-1 Producer实现介绍 (02:36)
6-2 微信小程序业务介绍 (05:27)
在这里插入图片描述

6-3 基础环境准备 (08:23)
6-4 微信模板配置创建及解析 (13:14)
6-5 微信小程序后台逻辑层实现 (08:16)
6-6 微信小程序表现层基础构建 (04:20)
6-7 微信小程序表现层实现 (04:04)
6-8 微信小程序业务测试 (02:53)
6-9 Kafka Producer集成 (21:55)
1、Kafka Producer是线程安全的，建议多线程复用，如果每个线程都创建，出现大量的上下文切换或争抢的情况，影响Kafka效率
2、Kafka Producer的key是一个很重要的内容：
2.1 我们可以根据Key完成Partition的负载均衡
2.2 合理的Key设计，可以让Flink、Spark Streaming之类的实时分析工具做更快速处理

   3、ack - all， kafka层面上就已经有了只有一次的消息投递保障，但是如果想真的不丢数据，最好自行处理异常

    public void templateReported(JSONObject reportInfo) {
        // kafka producer将数据推送至Kafka Topic
        log.info("templateReported : [{}]", reportInfo);
        String topicName = "jiangzh-topic";
        // 发送Kafka数据
        String templateId = reportInfo.getString("templateId");
        JSONArray reportData = reportInfo.getJSONArray("result");

        // 如果templateid相同，后续在统计分析时，可以考虑将相同的id的内容放入同一个partition，便于分析使用
        ProducerRecord<String,Object> record =
                new ProducerRecord<>(topicName,templateId,reportData);

        /*
            1、Kafka Producer是线程安全的，建议多线程复用，如果每个线程都创建，出现大量的上下文切换或争抢的情况，影响Kafka效率
            2、Kafka Producer的key是一个很重要的内容：
                2.1 我们可以根据Key完成Partition的负载均衡
                2.2 合理的Key设计，可以让Flink、Spark Streaming之类的实时分析工具做更快速处理

            3、ack - all， kafka层面上就已经有了只有一次的消息投递保障，但是如果想真的不丢数据，最好自行处理异常
         */
        try{
            producer.send(record);
        }catch (Exception e){
            // 将数据加入重发队列， redis，es，...
        }

    }

6-10 CA证书申请及域名绑定

6-11 Springboot工程集成SSL证书

6-12 阿里云部署微信小程序后端

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
6-13 微信小程序部署准备工作 (06:15)
6-14 微信小程序编译部署 (10:53)

第7章 Kafka核心API——Consumer

7-1 Consumer介绍 (02:27)

7-2 Consumer之HelloWorld

    /*
        工作里这种用法，有，但是不推荐
     */
    private static void helloworld(){
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "192.168.220.128:9092");
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "true");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String,String> consumer = new KafkaConsumer(props);
        // 消费订阅哪一个Topic或者几个Topic
        consumer.subscribe(Arrays.asList(TOPIC_NAME));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            for (ConsumerRecord<String, String> record : records)
                System.out.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                        record.partition(),record.offset(), record.key(), record.value());
        }
    }

7-3 Consumer之手动提交

    /*
        手动提交offset
     */
    private static void commitedOffset() {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "192.168.220.128:9092");
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "false");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer(props);
        // 消费订阅哪一个Topic或者几个Topic
        consumer.subscribe(Arrays.asList(TOPIC_NAME));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            for (ConsumerRecord<String, String> record : records) {
                // 想把数据保存到数据库，成功就成功，不成功...
                // TODO record 2 db
                System.out.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                        record.partition(), record.offset(), record.key(), record.value());
                // 如果失败，则回滚， 不要提交offset
            }

            // 如果成功，手动通知offset提交
            consumer.commitAsync();
        }
    }

7-4 Consumer演示观后感

在这里插入图片描述
在这里插入图片描述

7-5 Consumer单Partition提交offset

    /*
        手动提交offset,并且手动控制partition
     */
    private static void commitedOffsetWithPartition() {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "192.168.220.128:9092");
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "false");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer(props);
        // 消费订阅哪一个Topic或者几个Topic
        consumer.subscribe(Arrays.asList(TOPIC_NAME));
        while (true) {
           ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
           // 每个partition单独处理
           for(TopicPartition partition : records.partitions()){
               List<ConsumerRecord<String, String>> pRecord = records.records(partition);
               for (ConsumerRecord<String, String> record : pRecord) {
                   System.out.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                           record.partition(), record.offset(), record.key(), record.value());

               }
               //这个一次消费单个partition,poll到的消息最后的一个消息的offset
               long lastOffset = pRecord.get(pRecord.size() -1).offset();
               // 单个partition中的offset，并且进行提交
               Map<TopicPartition, OffsetAndMetadata> offset = new HashMap<>();
               offset.put(partition,new OffsetAndMetadata(lastOffset+1));
               // 提交offset
               consumer.commitSync(offset);
               System.out.println("=============partition - "+ partition +" end================");
           }
        }
    }

7-6 Consumer手动控制一到多个分区

    /*
        手动提交offset,并且手动控制partition,更高级
     */
    private static void commitedOffsetWithPartition2() {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "192.168.220.128:9092");
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "false");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer(props);

        // jiangzh-topic - 0,1两个partition
        TopicPartition p0 = new TopicPartition(TOPIC_NAME, 0);
        TopicPartition p1 = new TopicPartition(TOPIC_NAME, 1);

        // 消费订阅哪一个Topic或者几个Topic
//        consumer.subscribe(Arrays.asList(TOPIC_NAME));

        // 消费订阅某个Topic的某个分区
        consumer.assign(Arrays.asList(p0));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            // 每个partition单独处理
            for(TopicPartition partition : records.partitions()){
                List<ConsumerRecord<String, String>> pRecord = records.records(partition);
                for (ConsumerRecord<String, String> record : pRecord) {
                    System.out.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                            record.partition(), record.offset(), record.key(), record.value());

                }
                long lastOffset = pRecord.get(pRecord.size() -1).offset();
                // 单个partition中的offset，并且进行提交
                Map<TopicPartition, OffsetAndMetadata> offset = new HashMap<>();
                offset.put(partition,new OffsetAndMetadata(lastOffset+1));
                // 提交offset
                consumer.commitSync(offset);
                System.out.println("=============partition - "+ partition +" end================");
            }
        }
    }

7-7 Consumer多线程并发处理

kafka的producer是线程安全的

kafka的consumer不是线程安全的

  1. 方式一：这种类型是经典模式，每一个线程单独创建一个KafkaConsumer，用于保证线程安全
    在对数据一致性有较高要求的时候适合使用方式一，方式一对partition有较好的管控能力，方便处理失败rollback重新处理
    在这里插入图片描述
public class ConsumerThreadSample {
    private final static String TOPIC_NAME="jiangzh-topic";

    /*
        这种类型是经典模式，每一个线程单独创建一个KafkaConsumer，用于保证线程安全
     */
    public static void main(String[] args) throws InterruptedException {
        KafkaConsumerRunner r1 = new KafkaConsumerRunner();
        Thread t1 = new Thread(r1);

        t1.start();

        Thread.sleep(15000);

        r1.shutdown();
    }

    public static class KafkaConsumerRunner implements Runnable{
        private final AtomicBoolean closed = new AtomicBoolean(false);
        private final KafkaConsumer consumer;

        public KafkaConsumerRunner() {
            Properties props = new Properties();
            props.put("bootstrap.servers", "192.168.220.128:9092");
            props.put("group.id", "test");
            props.put("enable.auto.commit", "false");
            props.put("auto.commit.interval.ms", "1000");
            props.put("session.timeout.ms", "30000");
            props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
            props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

            consumer = new KafkaConsumer<>(props);

            TopicPartition p0 = new TopicPartition(TOPIC_NAME, 0);
            TopicPartition p1 = new TopicPartition(TOPIC_NAME, 1);

            consumer.assign(Arrays.asList(p0,p1));
        }


        public void run() {
            try {
                while(!closed.get()) {
                    //处理消息
                    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));

                    for (TopicPartition partition : records.partitions()) {
                        List<ConsumerRecord<String, String>> pRecord = records.records(partition);
                        // 处理每个分区的消息
                        for (ConsumerRecord<String, String> record : pRecord) {
                            System.out.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                                    record.partition(),record.offset(), record.key(), record.value());
                        }

                        // 返回去告诉kafka新的offset
                        long lastOffset = pRecord.get(pRecord.size() - 1).offset();
                        // 注意加1
                        consumer.commitSync(Collections.singletonMap(partition, new OffsetAndMetadata(lastOffset + 1)));
                    }

                }
            }catch(WakeupException e) {
                if(!closed.get()) {
                    throw e;
                }
            }finally {
                consumer.close();
            }
        }

        public void shutdown() {
            closed.set(true);
            consumer.wakeup();
        }
    }

}
  1. 方式二： 先把数据拿下来，在对每一条数据进行多线程处理
    方式二 线程中处理消息失败成功也不知到，不能手动提交offset
    适合流式数据，对于数据处理正确性要求不高，及非业务系统，推给我数据我就处理，成功失败不重要
    例如：定位gps数据上传
    在这里插入图片描述
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.Properties;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ConsumerRecordThreadSample {
    private final static String TOPIC_NAME = "jiangzh-topic";

    public static void main(String[] args) throws InterruptedException {
        String brokerList = "192.168.220.128:9092";
        String groupId = "test";
        int workerNum = 5;

        //创建一个CunsumerExecutor，也就是一个线程池
        CunsumerExecutor consumers = new CunsumerExecutor(brokerList, groupId, TOPIC_NAME);
        consumers.execute(workerNum);

        Thread.sleep(1000000);

        consumers.shutdown();

    }

    // Consumer处理
    public static class CunsumerExecutor{
        private final KafkaConsumer<String, String> consumer;
        private ExecutorService executors;

        public CunsumerExecutor(String brokerList, String groupId, String topic) {
            Properties props = new Properties();
            props.put("bootstrap.servers", brokerList);
            props.put("group.id", groupId);
            props.put("enable.auto.commit", "true");
            props.put("auto.commit.interval.ms", "1000");
            props.put("session.timeout.ms", "30000");
            props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
            props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
            consumer = new KafkaConsumer<>(props);
            consumer.subscribe(Arrays.asList(topic));
        }

        public void execute(int workerNum) {
            executors = new ThreadPoolExecutor(workerNum, workerNum, 0L, TimeUnit.MILLISECONDS,
                    new ArrayBlockingQueue<>(1000), new ThreadPoolExecutor.CallerRunsPolicy());

            while (true) {
                ConsumerRecords<String, String> records = consumer.poll(200);
                for (final ConsumerRecord record : records) {
                    executors.submit(new ConsumerRecordWorker(record));
                }
            }
        }

        public void shutdown() {
            if (consumer != null) {
                consumer.close();
            }
            if (executors != null) {
                executors.shutdown();
            }
            try {
                if (!executors.awaitTermination(10, TimeUnit.SECONDS)) {
                    System.out.println("Timeout.... Ignore for this case");
                }
            } catch (InterruptedException ignored) {
                System.out.println("Other thread interrupted this shutdown, ignore for this case.");
                Thread.currentThread().interrupt();
            }
        }


    }

    // 记录处理
    public static class ConsumerRecordWorker implements Runnable {

        private ConsumerRecord<String, String> record;

        public ConsumerRecordWorker(ConsumerRecord record) {
            this.record = record;
        }

        @Override
        public void run() {
            // 假如说数据入库操作
            System.out.println("Thread - "+ Thread.currentThread().getName());
            System.err.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                    record.partition(), record.offset(), record.key(), record.value());
        }

    }
}

7-8 Consumer控制offset起始位置

  • 手动指定offset的起始位置
/*
        手动指定offset的起始位置，及手动提交offset
     */
    private static void controlOffset() {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "192.168.220.128:9092");
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "false");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer(props);

        // jiangzh-topic - 0,1两个partition
        TopicPartition p0 = new TopicPartition(TOPIC_NAME, 0);

        // 消费订阅某个Topic的某个分区
        consumer.assign(Arrays.asList(p0));

        while (true) {
            // 手动指定offset起始位置
            /*
                1、人为控制offset起始位置
                2、如果出现程序错误，重复消费一次
             */
            /*
                1、第一次从0消费【一般情况】
                2、比如一次消费了100条， offset置为101并且存入Redis
                3、每次poll之前，从redis中获取最新的offset位置
                4、每次从这个位置开始消费
             */
            consumer.seek(p0, 700);

            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            // 每个partition单独处理
            for(TopicPartition partition : records.partitions()){
                List<ConsumerRecord<String, String>> pRecord = records.records(partition);
                for (ConsumerRecord<String, String> record : pRecord) {
                    System.err.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                            record.partition(), record.offset(), record.key(), record.value());

                }
                long lastOffset = pRecord.get(pRecord.size() -1).offset();
                // 单个partition中的offset，并且进行提交
                Map<TopicPartition, OffsetAndMetadata> offset = new HashMap<>();
                offset.put(partition,new OffsetAndMetadata(lastOffset+1));
                // 提交offset
                consumer.commitSync(offset);
                System.out.println("=============partition - "+ partition +" end================");
            }
        }
    }

7-9 面试点：Consumer限流

    /*
        流量控制 - 限流
        限流一般针对消费单个topic
     */
    private static void controlPause() {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "192.168.220.128:9092");
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "false");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer(props);

        // jiangzh-topic - 0,1两个partition
        TopicPartition p0 = new TopicPartition(TOPIC_NAME, 0);
        TopicPartition p1 = new TopicPartition(TOPIC_NAME, 1);

        // 消费订阅某个Topic的某个分区
        consumer.assign(Arrays.asList(p0));
        long totalNum = 40;
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            // 每个partition单独处理
            for(TopicPartition partition : records.partitions()){
                List<ConsumerRecord<String, String>> pRecord = records.records(partition);
                long num = 0;
                for (ConsumerRecord<String, String> record : pRecord) {
                    System.out.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                            record.partition(), record.offset(), record.key(), record.value());
                    /*
                        1、接收到record信息以后，去令牌桶中拿取令牌
                        2、如果获取到令牌，则继续业务处理
                        3、如果获取不到令牌， 则pause等待令牌
                        4、当令牌桶中的令牌足够， 则将consumer置为resume状态
                     */
                    num++;
                    if(record.partition() == 0){
                        if(num >= totalNum){
                            consumer.pause(Arrays.asList(p0));
                        }
                    }

                    if(record.partition() == 1){
                        if(num == 40){
                            consumer.resume(Arrays.asList(p0));
                        }
                    }
                }

                long lastOffset = pRecord.get(pRecord.size() -1).offset();
                // 单个partition中的offset，并且进行提交
                Map<TopicPartition, OffsetAndMetadata> offset = new HashMap<>();
                offset.put(partition,new OffsetAndMetadata(lastOffset+1));
                // 提交offset
                consumer.commitSync(offset);
                System.out.println("=============partition - "+ partition +" end================");
            }
        }
    }

7-10 面试点

Consumer Rebalance解析

所有topic的分区总数应等于消费组中的消费者数，消费者大于总的分区数，就会有消费者闲置消费不到消息

出现rebalance的情况

  1. 有新的消费者加如消费者组
    在这里插入图片描述
  2. 消费组中的消费者退出
  • 消费组中的消费者异常离开消费组
    在这里插入图片描述
  • 消费组中的消费者主动离开消费组
    在这里插入图片描述

提交为一失败会造成重复消费

在这里插入图片描述

第8章 Kafka核心API——Stream（流处理）

Kafka Stream的主要作用是：在kafka内部处理kafka存储的数据

8-2 Kafka Stream概念及初识高层架构图

在这里插入图片描述
Kafka Stream概念及初识高层架构图：
在这里插入图片描述

8-3 Kafka Stream 核心概念讲解

  • (stream)流及(stream processor)流处理器
  • 流处理拓扑 如下图：
    在这里插入图片描述
  • 源处理器和Sink处理器
    在这里插入图片描述

8-4 Kafka Stream 演示准备

从一个或多个topic 经过Kafka Stream 处理传另外的一个或多个topic
在这里插入图片描述

        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>2.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams</artifactId>
            <version>2.4.0</version>
        </dependency>

import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.kstream.KStream;
import org.apache.kafka.streams.kstream.KTable;
import org.apache.kafka.streams.kstream.Produced;

import java.util.Arrays;
import java.util.Locale;
import java.util.Properties;

public class StreamSample {

    private static final String INPUT_TOPIC="jiangzh-stream-in";
    private static final String OUT_TOPIC="jiangzh-stream-out";

    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.220.128:9092");
        props.put(StreamsConfig.APPLICATION_ID_CONFIG,"wordcount-app");
        props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
        props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());

        // 构建流结构拓扑
        final StreamsBuilder builder = new StreamsBuilder();
        // 构建Wordcount
//        wordcountStream(builder);
        // 构建foreachStream
        foreachStream(builder);

        final KafkaStreams streams = new KafkaStreams(builder.build(), props);

        streams.start();
    }

    // 定义流计算过程（从一个topic取数据，经过算子，直接输出）
    static void foreachStream(final StreamsBuilder builder){
        KStream<String,String> source = builder.stream(INPUT_TOPIC);
        source
                .flatMapValues(value -> Arrays.asList(value.toLowerCase(Locale.getDefault()).split(" ")))
                .foreach((key,value)-> System.out.println(key + " : " + value));
    }

    // 定义流计算过程（从一个topic取数据，经过算子，再发送到另个topic）
    static void wordcountStream(final StreamsBuilder builder){
        // 不断从INPUT_TOPIC上获取新数据，并且追加到流上的一个抽象对象
        KStream<String,String> source = builder.stream(INPUT_TOPIC);
        // Hello World imooc
        // KTable是数据集合的抽象对象
        // 算子
        final KTable<String, Long> count =
                source
                        //先数据拆分(本次按空格拆分)
                        // flatMapValues -> 将一行数据拆分为多行数据  key 1 , value Hello World
                        // flatMapValues -> 将一行数据拆分为多行数据  key 1 , value Hello key 1 , value World
                        /*
                            key 1 , value Hello   -> Hello 1  World 2
                            key 2 , value World
                            key 3 , value World
                         */
                        .flatMapValues(value -> Arrays.asList(value.toLowerCase(Locale.getDefault()).split(" ")))
                        // 合并 -> 按value值合并
                        .groupBy((key, value) -> value)
                        // 统计出现的总数
                        .count();

        // 将结果输入到OUT_TOPIC中
        count.toStream().to(OUT_TOPIC, Produced.with(Serdes.String(),Serdes.Long()));
    }

}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
8-5 Kafka Stream使用演示 (14:12)
8-6 Kafka Stream程序解析 (09:09)
8-7 Kafka Stream算子演示讲解 (04:38)

第9章 Kafka核心API——Connect（实际生产开发中用的很少）

9-1 Kafka Connect章节介绍 (00:37)

9-2 Kafka Connect基本概念介绍

在这里插入图片描述
在这里插入图片描述
9-3 Kakfa Connect环境准备 (13:51)
9-4 Kafka Connect Source和MySQL集成 (06:22)
9-5 Kafka Connect Sink和MySQL集成 (05:30)
9-6 Kafka Connect原理及使用场景介绍 (07:20)

第10章 Kafka集群部署与开发

10-2 Kafka集群部署配置讲解

在这里插入图片描述
10-3 Kafka集群部署并启动 (04:27)

10-4 Kafka副本集-1

在这里插入图片描述
10-5 Kafka副本集-2 (05:22)

    /*
        创建Topic实例
     */
    public static void createTopic() {
        AdminClient adminClient = adminClient();
        // 副本因子（三个副本，副本因子为三，可以保证三个副本分布三个broker中）
        Short rs = 3;
        NewTopic newTopic = new NewTopic(TOPIC_NAME, 3 , rs);
        CreateTopicsResult topics = adminClient.createTopics(Arrays.asList(newTopic));
        System.out.println("CreateTopicsResult : "+ topics);
    }

10-6 图解Kafka集群基本概念

再大的数据集一个topic有5-10patition已经很多，所以patition不要太多，太多主机受不了，一般集群中部署了kafka broker的数量要大于一个topic的patition的数量。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

10-7 Kafka节点故障原因及处理方式

在这里插入图片描述
在这里插入图片描述

10-8 面试点：Kafka Leader选举机制

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

第11章 Kafka集群监控、安全与最佳实践

11-1 集群监控安全介绍 (01:20)

11-2 Kafka监控安装

kafka 开源监控–kafka-manager安装

11-3 Kafka监控界面讲解 (11:31)
11-4 Kafka SSL签名库生成 (08:38)
11-5 Kafka SSL服务端集成 (07:07)
11-6 Kafka SSL客户端集成 (09:11)
11-7 Kafka最佳实践介绍 (03:43)

11-8 Kafka最佳实践配置项讲解

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
11-9 Kafka服务器配置最佳实践讲解 (07:48)

第12章 实战“慕问卷”开发 —— 集成微服务

12-1 SpringCloud Config内容介绍 (01:45)

12-2 SpringCloud Config架构图介绍

在这里插入图片描述
在这里插入图片描述

12-3 SpringCloud演示环境准备

12-4 SpringCloud Config Server配置使用

在这里插入图片描述
Config Server

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-config-server</artifactId>
</dependency>

spring.application.name=config-server
server.port=8900
spring.cloud.config.server.git.uri=https://github.com/jiangzh292679/imooc_conf.git
spring.cloud.config.label=master
spring.cloud.config.server.git.username=3078956183@qq.com
spring.cloud.config.server.git.password=imooc_jiangzh001

验证config server



http://localhost:8900/kafka/master

12-5 SpringCloud Client配置使用

在这里插入图片描述
Config Client

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-config</artifactId>
</dependency>

bootstrap.yml配置：


spring:
	application:
		name: kafka
	cloud:
		config:
			uri: http://localhost:8900/
			label: master

12-6 SpringCloud Config动态刷新准备

在这里插入图片描述

## 动态刷新配置依赖
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

## 增加访问point
management.endpoints.web.exposure.include=health, info, refresh

post请求访问/actuator/refresh

curl -XPOST http://localhost:7002/actuator/refresh

12-7 SpringCloud Config 动态刷新演示 (04:47)
12-8 SpringCloud Config配置使用环节回顾 (01:31)
12-9 SpringCloud Bus内容介绍 (01:02)

12-10 SpringCloud Bus架构图讲解

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

12-11 SpringCloud Bus动态刷新使用演示

配置依赖：
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-bus-kafka</artifactId>
</dependency>

Kafka配置：

spring.cloud.stream.kafka.binder.zkNodes=192.168.220.128:2181
spring.cloud.stream.kafka.binder.brokers=192.168.220.128:9092


management:
  endpoints:
    web:
      exposure:
        include: health, info, refresh, bus-refresh

配置刷新

curl -X POST http://localhost:7002/actuator/bus-refresh


测试：

http://localhost:7001/test
http://localhost:7002/test

12-12 SpringCloud Bus演示多服务动态刷新 (08:47)

第13章 Kafka面试点梳理

13-1 Kafka面试题内容介绍及面试建议

13-2 Kafka概念及优劣势分析

1.问题：kafka 与其他mq的不同

  1. kafka是一个流处理平台
  2. 虽然是一个流式处理平台，但提供了发布和订阅主题的功能，与其他的mq相同
  3. kafka有比其他mq高出很多的吞吐量
  4. kafka 提供offset 管理，可以消费历史消息。
  5. 不保证数据全局有序，只能保证单个分区内有序，其他mq可以保证消息的全局有序

在这里插入图片描述

2.kafak 应用场景

使用kafka的前提使对数据的有序性要求不高
在这里插入图片描述

13-3 Kafka吞吐量大/速度块的原因分析

在这里插入图片描述

13-4 Kafka日志检索底层原理

在这里插入图片描述
每条日志消息的格式：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

13-5 Kafka 零拷贝原理分析

正常linux从文件读取的到发送出去的过程
在这里插入图片描述

kafka通过sendfil实现零拷贝

sendfil由linux实现，在windows没有实现
在这里插入图片描述

13-6 消费者组与消费者

在这里插入图片描述

13-7 Producer客户端

producer 的发送消息的过程：

producer 的时序图

在创建producer 的时候会启动一个专门的守护线程，这个守护线程是一直不停的在轮询，轮询的内容就是将消息发送的kafka上
producer 调用send并不是直接将数据发送的kafka上，而是先发送的一个队列上，满足一定条件后，这个守护线程会将消息推送给kafka，
获取future，producer client 可以调用get()同步阻塞直到返回结果
在这里插入图片描述

producer 的流程图

送消息进行序列化，让后通过分区器将消息发送到不同的分区，每个分区的上的消息被分成不同的批次，然后通过守护进程分批次发送的kafka broker，如果失败的再判断是否需要重试

分区默认的一般是轮询发送，也可以自定义
在这里插入图片描述

producer 一般有俩个线程
一个是在创建producer 的时候会启动一个专门的守护线程来批量将消息推送到kafka
一个是在send消息的时候会另起一个一个线程，将消息追加到队列中

13-8 Kafka消息有序性处理 （保证有序性）

在这里插入图片描述

13-9 Kafka Topic删除背后的故事

实际生产环境中，删除topic的时候尽量先关闭kafka broker
在这里插入图片描述
在这里插入图片描述

13-10 消息重复消费和漏消费原理分析

在这里插入图片描述
避免重复消费的机制：

  1. 独立管理offset 保存在redis中，再出现消费异常是从redis中读取offset
  2. 一个消费组中尽量一个消费者消费一个partition

消息漏消费
消息漏消费一般都是业务程序处理的原因，kafka本身很少会导致消息漏消费

13-11 消费者线程安全性分析

在这里插入图片描述

13-12 Kafka Leader选举分析

在这里插入图片描述

13-13 Kafka幂等性源码分析

幂等性：多次请求返回结果一致

kafka发送消息的保证了幂等性
在这里插入图片描述

13-14 Kafka事务支持实现及原理分析

kafka的事务能不开启尽量不开启，开启事务一般会降低20%-30%的效率

在这里插入图片描述

  1. 添加transaction_id
    在这里插入图片描述
  2. 事务的初始化和开启
    在这里插入图片描述
  3. 完成事务的提交和回滚
    在这里插入图片描述
紫金小飞侠
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
kafka一小时入门精讲笔记.zip
02-05
【Kafka一小时入门精讲笔记】 在大数据处理和实时流计算领域，Apache Kafka是一款非常重要的开源消息系统。本精讲笔记将带你快速了解Kafka的基本概念、核心特性以及使用场景，助你在一小时内掌握Kafka的基础知识。 ...
Kafka 多维度系统精讲（2）- 客户端操作
一角残叶的博客
09-23 279
1 Kafka API 类型 1.1 新建 spring boot 项目 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- https://mv
Kafka 多维度系统精讲（3）- 生产者
一角残叶的博客
09-23 266
1 Producer 发送模式 同步 异步 异步回调 1.1 异步发送 bin/kafka-console-consumer.sh --bootstrap-server master:9092 --topic tzb-new-topic --from-beginning public class ProducerSample { public final static String TOPIC_NAME = "tzb-new-topic"; public static void m
《Kafka技术内幕》读书笔记：Kafka入门
weixin_42881755的博客
05-21 411
1. 介绍 1.1 Kafka流式处理平台 一个流式数据平台，最重要的是要具备如下3个特点： 类似消息系统，提供事件流的发布和订阅，既具备事件注入功能。 存储事件流的数据节点具有故障容错的特点，即具备数据存储功能。 能够对实时的事件流进行流式地处理和分析，即具备流处理功能。 作为一个流式数据平台，Kafka如何实现上面3个功能特点： 1.1.1 消息系统 消息系统（也叫消息队列）主要有两种消息模型：队列和发布订阅。 队列模式：多个消费者读取队列，每条消息只发送给一个消费者 发布-订阅模式：多个消费者订
Kafka从入门到源码分析原理课-视频教程网盘链接提取码下载 .txt
最新发布
08-06
Kafka从入门到源码分析原理课是一门针对Kafka最新版本技术的课程，从入门到掌握Kafka的技术细节，让学员更加深入地理解Kafka的原理和运行机制。课程分为理论和实践两部分，理论部分介绍Kafka架构、技术原理以及Kafka...
Kafka 多维度系统精讲（11）- stream
一角残叶的博客
10-13 219
1 kafka stream 基本概念 2 kafka 流处理关键词
kafka入门到实战一（认识kafka）
qq_42388853的博客
03-02 478
本次kafka的学习打算从三方面开始 * 认识kafka，掌握基础知识 * 搭建kafka，为使用kafka创建条件 * 使用kafka，基本的使用和解决顺序消费等问题
kafka视频教程-免费
01-10
这是一个kafka的视频教程，老师讲解的非常仔细，大家一起学习！
kafka全套视频教程 某客学院
03-22
视频教程从入门到源码分析，内容全面，课程质量很高！
kafka视频教程
12-10
百度云盘下载，kafka视频教程，下载文件查看链接和密码， kafka视频教程
【MQ】Kafka笔记
努力充实，远方可期
07-19 7788
笔记来源：尚硅谷视频笔记2.0版+2.1版 黑马视频：Kafka深入探秘者来了 笔记、代码下载地址：https://me.csdn.net/download/hancoder 第1章 Kafka概述 1.1 定义 Kafka 是一个分布式的基于【发布/订阅模式】的消息队列（Message Queue），主要应用于 大数据实时处理领域。 1.2 消息队列 消息队列又称消息引擎，消息中间件 1.2.1 传统消息队列的应用场景 消息队列的好处 1）解耦： 允许你独立的扩展或修改两边的处理过程，只要确保
私有CA搭建并将HTTPS应用于Tomcat、Springboot
u013256012的博客
12-17 3514
目录 1 CA概念 2 HTTPS过程 3 环境说明 4 搭建私有CA 4.1 环境准备 4.2 搭建CA中心 4.3 操作错误从新来过 5 浏览器证书配置 6 创建服务器证书 6.1 环境准备 6.2 创建服务器证书 6.2 配置证书 7 将CA证书导入JDK 8 创建Tomcat服务器证书 9 Tomcat的HTTPS配置 9.1 单向认证 9.2 双向认证 ...
SpringBoot 集成CAS简单学习
Kylin
08-10 2645
springboot 集成 CAS 简单学习。包含示例代码。
spring boot 和 cas 整合
weixin_30710457的博客
07-26 474
1. 修改依赖 <!-- spring-boot-configuration 配置信息 ,加入此项可以提示 配置信息 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-confi...
Kafka：KafkaAdminClient应用
程序员无羡的博客
03-31 1091
Kafka：KafkaAdminClient应用
Kafka：从入门到实战，详解消息系统与安装
- **复制与扩展**：通过在多个Broker节点上复制数据，Kafka可以轻松水平扩展，提高系统的可用性和容灾能力。 3. **关键技术和设计**： - **消息持久化**：Kafka使用磁盘作为持久化存储，保证数据在系统故障后仍能...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值