高性能KAfKA之实战篇（基本使用）03

已于 2024-08-30 01:46:15 修改
阅读量1k 收藏 19
点赞数 14
分类专栏： 高性能kafka之学习篇 文章标签： kafka 分布式
于 2024-08-28 16:19:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41874544/article/details/141642689
版权

在之前两篇文章当中，我们简单了解了kafka的基本概念和安装、集群搭建，那么接下来这一章我们就开始试着使用一下kafka，看看到底是怎么消费数据的。

1.在kafka的目录中存在着很多的脚本文件，在kafka中对应模块的对应操作脚本

 

14d3442b428e8cd2dc1204e1662bccf6.png


topic

  • kafka-topics.sh --[参数名1] [值] [参数名2] [值]... ，注意参数可以为多个，而值根据参数的需要而变化例：
# 查看所有主题，因为我们还没有创建任何主题，所以没有东西
[root@node1-zookeeper bin]# kafka-topics.sh --bootstrap-server node1-zookeeper:9092 --list

# 我们可以指定要连接哪个节点的客户端,只需要在--bootstrap-server后指定IP或映射名+端口号即可
# 这里可以指定一个节点或多个节点。
 kafka-topics.sh --bootstrap-server node1-zookeeper:9092,node2-zookeeper:9092 --list
  • 常用参数

 

b6170ad6febc5a4cdc034acc3c79a0b8.png

 

  • 通过kafka命令创建一个topic
[root@node1-zookeeper bin]# kafka-topics.sh --bootstrap-server node1-zookeeper:9092 --create  --topic demo01 --partitions 1 --replication-factor 3

图中描述了各个命令的含义： 

 

b858cd2022e3598b7f1d96da7f551699.png

  • 查看所有topic（所有主题） 
[root@node1-zookeeper bin]# kafka-topics.sh --bootstrap-server node1-zookeeper:9092 --list
demo01
  • 查看我们刚才创建好的demo01主题的详细信息 
[root@node1-zookeeper bin]# kafka-topics.sh --bootstrap-server node1-zookeeper:9092 --topic demo01 --describe
Topic: demo01	
TopicId: JP_DT173QCGOvfd7NjAJFw	
PartitionCount: 1	#分区数量
ReplicationFactor: 3	#副本数
Configs: segment.bytes=1073741824
Topic: demo01	#主题名
Partition: 0 	#当前分区
Leader: 0	#集群中的节点代理ID（borker.id）
Replicas: 0,2,1	
Isr: 0,2,1
  • 修改主题 
# 将demo01的一个分区修改为三个分区
[root@node1-zookeeper kafka_2.12-3.0.0]# bin/kafka-topics.sh --bootstrap-server node1-zookeeper:9092 --topic demo01 --alter --partitions 3

# 查看demo01主题的信息，此时就能看到三个分区了
[root@node1-zookeeper kafka_2.12-3.0.0]# bin/kafka-topics.sh --bootstrap-server node1-zookeeper:9092 --topic demo01 --describe
Topic: demo01	TopicId: JP_DT173QCGOvfd7NjAJFw	PartitionCount: 3	ReplicationFactor: 3	Configs: segment.bytes=1073741824
	Topic: demo01	Partition: 0	Leader: 0	Replicas: 0,2,1	Isr: 0,2,1
	Topic: demo01	Partition: 1	Leader: 1	Replicas: 1,2,0	Isr: 1,2,0
	Topic: demo01	Partition: 2	Leader: 2	Replicas: 2,0,1	Isr: 2,0,1
 
# 修改副本：副本不能通过命令行的方式进行修改，这里后续介绍

 

  • 注意在修改已经创建好的主题分区时，分区数量只能增加不能减少，如：某个主题原来有两个分区，修改的时候就不能改为一个分区，分区数只能比原来的大。因为如果原来有两个消费者分别读取两个分区，如果改为一个，那么这两个消费者就不知道要去读取哪一个分区的数据。


生产和消费消息操作

  • 发送消息到broker
[root@node1-zookeeper kafka_2.12-3.0.0]# bin/kafka-console-producer.sh --bootstrap-server node1-zookeeper:9092 --topic demo01
> 张三
> 李四
  • 这里使用节点二和节点三消费消息
[root@node2-zookeeper kafka_2.12-3.0.0]# bin/kafka-console-consumer.sh --bootstrap-server node1-zookeeper:9092 --topic demo01

 

24f50d7fd814fbacfc696fb6e2840c8a.png

  • 此时生产者发送消息时消费者客户端还未启动，当客户端启动完成后就不能读取到之前的历史消息，只能读取到生产者最新发送的消息
  • 如果想要同样消费到历史数据，需要在消费者客户端添加参数 --from-beginning

所以读取方式有两种

 

a3b2e6a2c529e8b48be377d94105afac.png

比如读取demo01的数据，包含历史数据

[root@node2-zookeeper kafka_2.12-3.0.0]# bin/kafka-console-consumer.sh --bootstrap-server node1-zookeeper:9092 --topic demo01 --from-beginning



消息发送流程

 

01f0550fe90264864d51e7c5911efcfb.png

 

  • 生产者在main线程中创建一个Producer对象，通过一个send() 方法发送到拦截器（根据自己业务需求来定），然后到kafka自带的序列化器对数据进行序列化，通过分区器来规划数据发送往哪一个分区，其实就是缓存队列，缓存队列大小时32MB，其中每个批次的队列大小时16KB，其实这个是一个双端队列，当消息发送批次数据时创建该批次的大小，创建的时候会从内存池中取出内存，发送到kafka集群完成后将内存释放回收到内存池，接着Sender线程主动拉取队列，拉取数据的条件有两个：
    • batch.size： 只有数据累计到batch.size之后，sender才会发送数据。默认为16KB
    • linger.ms：如果数据迟迟未达到batch.size的大小，sender等待linger.ms设置的时间到了，也会发送数据，单位ms，默认是是0ms，表示没有延迟
  • 当然这两个条件是‘或’的关系，要么数据满16KB，要么等待时间到了，就会发送，发送的队列数据会以节点的方式进行发送，在发送请求时如果没有及时应答，最多等待5个请求，只有其中某些请求响应回来了，等待队列不满五个了，才能发送新的请求。以此类推，通过Selector疏通，类似一个数据流通道，打通之后，开始将数据发送到borker（集群节点），集群收到之后会执行副本的同步，同步完成进行acks应答，应答有三种级别：
    • 0：生产者发送过来的数据，不需要等待数据落盘应答。
    • 1：生产者发送过来的数据，Leader收到数据之后应答。
    • -1（all）：生产者发送过来的数据，Leader和ISR队列里面的所有节点收齐数据之后应答。-1和ALL等价
  • 应答回来如果成功，则清除对应请求和分区的数据，如果失败则会进行重试上述发送步骤，重试的次数为int的最大值（该值可设置），直到成功为止。

JavaAPI的使用


1.导入测试项目依赖

<!--导入Kafka客户端对应依赖,与kafka版本对应即可-->
<dependency>
  <groupId>org.apache.kafka</groupId>
  <artifactId>kafka-clients</artifactId>
  <version>3.0.0</version>
</dependency>


2.kafka同步/异步发送，这里的异步发送和同步发送场景时是发生在外部数据发送到缓冲区队列中的过程

  • Java示例:简单的消息发送和同步异步的区别
package com.moyuwanjia.kafka_study;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import org.junit.Test;

import java.util.Properties;
import java.util.concurrent.ExecutionException;

/**
 * CustomProducer 生产者测试(同步/异步),这里的异步发送和同步发送场景时是发生在外部数据发送到缓冲区中的过程
 * 外部数据 ——生产者——> 缓冲区 ——缓冲队列——> send线程 ——> kafka集群
 * 调用get()方法：当使用get()方法发送消息时，它会阻塞当前线程，程序会等待get()方法方法的返回结果（成功或失败的响应）。
 *              这意味着外部数据进入缓冲区队列时，等待上一批数据发送到kafka集群（borker节点）之后，才会将外部数据
 *              继续送入缓冲区队列中。
 *
 * 不调用get()方法：不调用get()方法时，消息发送会是一个异步操作，并且当前线程不会进行阻塞，不会等待发送结果。
 *              这时外部数据进入缓冲区队列时，不会等待上一批数据是否发送到kafka集群中，会直接将数据继续送入缓冲区队列中。
 *
 */
public class demo01_CustomProducer {

    /**
     * 异步发送一条简单的消息
     */
    @Test
    public void test1(){
//      1.拼接和配置参数
        Properties properties = new Properties();
//      --bootstrap-servers参数
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1-zookeeper:9092,node2-zookeeper:9092,node3-zookeeper:9092");
//      指定key和value的序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//      2.创建kafka生产者对象
        KafkaProducer<String,String> kafkaProducer = new KafkaProducer<>(properties);
//      3.指定参数
        ProducerRecord producerRecord = new ProducerRecord("demo01","第一条数据...");
//      4.发送数据
        kafkaProducer.send(producerRecord);
//      5.关闭资源
        kafkaProducer.close();
    }


    /**
     * 异步发送一条携带回调的简单消息
     */
    @Test
    public void test2(){
//      1.拼接和配置参数
        Properties properties = new Properties();
//      --bootstrap-servers参数
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1-zookeeper:9092,node2-zookeeper:9092,node3-zookeeper:9092");
//      指定key和value的序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//      2.创建kafka生产者对象
        KafkaProducer<String,String> kafkaProducer = new KafkaProducer<>(properties);
//      3.指定参数
        ProducerRecord producerRecord = new ProducerRecord("demo01","第一条数据...");
//      4.发送数据,添加回调方式一
        kafkaProducer.send(producerRecord, new Callback() {
            @Override
            public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                if(null == e){
                    System.out.println("主题：" + recordMetadata.topic() + "\n" +
                            "分区：" + recordMetadata.partition() + "\n" +
                            "偏移量：" + recordMetadata.offset() + "\n"
                    );
                }
            }
        });
//      5.关闭资源
        kafkaProducer.close();
    }


    /**
     *  同步发送一条携带回调的简单消息
     *  同步：在外部同一批次数据全部发送完毕之后，才能再次发送下一批数据
     *  实现方式：直接在发送数据时调用get()方法即可，与异步发送方式执行原理不一致。
     */
    @Test
    public void test3() throws ExecutionException, InterruptedException {
//      1.拼接和配置参数
        Properties properties = new Properties();
//      --bootstrap-servers参数
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1-zookeeper:9092,node2-zookeeper:9092,node3-zookeeper:9092");
//      指定key和value的序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//      2.创建kafka生产者对象
        KafkaProducer<String,String> kafkaProducer = new KafkaProducer<>(properties);
//      3.指定参数
        ProducerRecord producerRecord = new ProducerRecord("demo01","第一条数据...");
//      4.发送数据,添加回调方式一
        kafkaProducer.send(producerRecord, new Callback() {
            @Override
            public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                if(null == e){
                    System.out.println("主题：" + recordMetadata.topic() + "\n" +
                            "分区：" + recordMetadata.partition() + "\n" +
                            "偏移量：" + recordMetadata.offset() + "\n"
                    );
                }
            }
        }).get();
//      5.关闭资源
        kafkaProducer.close();
    }
}

kafka中的分区器

 

  • 拦截器：在实际应用中并不常见，这里先忽略
  • 序列化器：我们在数据处理过程中常见的都是为String类型，其他自定义类型自行百度
  • 分区器：
    • ①：便于合理使用存储资源，每个Partition在一个Broker上存储，可以把海量的数据按照分区切割成一块块数据存储在多台Broker上。合理控制分区的任务，实现负载均衡的效果。
    • ②：提高并行度，生产者可以以分区为单位发送数据，消费者可以以分区为单位进行消费。

分区策略

  • ①指明partition的情况下，直接将指明的值作为partition的值，例如partition=0，所有数据写入分区0。
  •  ②没有指明partition值的情况下，将key的hash值与topic的partition进行取余数得到partition值，例如分区总数为2：key1的hash值=5，key2的hash值=6，topic的partition数=2，那么key1对应的value1写入1号分区(5%2=1)，key2对应的value2写入0号分区(6%2=0)。
  • ③即没有指定分区值又没有key值的情况下，kafka采用Sticky Partition(粘性分区器)，会随机选择一个分区，并且尽可能一直使用该分区，等待该分区的batch已满（16KB）或者linger.ms时间到了，kafka会再次随机一个分区进行使用（和上一次的分区不同）例如：第一次随机选择0号分区，等待0号分区当前一批次的满了或时间到了，kafka会再随机一个分区进行使用，如果此时随机到了0号分区仍然不会使用，还会继续随机
package com.moyuwanjia.kafka_study;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import org.junit.Test;

import java.util.Properties;

/**
 * 默认分区器：
 * @see org.apache.kafka.clients.producer.internals.DefaultPartitioner
 *
 * 分区策略：
 *      ①指明partition的情况下，直接将指明的值作为partition的值，例如partition=0，所有数据写入分区0。
 *      ②没有指明partition值的情况下，将key的hash值与topic的partition进行取余数得到partition值，例如，分区总数为2：
 *        key1的hash值=5，key2的hash值=6，topic的partition数=2，那么key1对应的value1写入1号分区(5%2=1)，key2
 *        对应的value2写入0号分区(6%2=0)。
 *      ③即没有指定分区值又没有key值的情况下，kafka采用Sticky Partition(粘性分区器)，会随机选择一个分区，并且尽可能一直使用
 *        该分区，等待该分区的batch已满（16KB）或者linger.ms时间到了，kafka会再次随机一个分区进行使用（和上一次的分区不同）
 *        例如：第一次随机选择0号分区，等待0号分区当前一批次的满了或时间到了，kafka会再随机一个分区进行使用，如果此时随机
 *        到了0号分区仍然不会使用，还会继续随机
 */
public class demo02_TestPartitioner{

    /**
     * 测试 指定分区策略
     */
    @Test
    public void test1(){
//      1.拼接和配置参数
        Properties properties = new Properties();
//      --bootstrap-servers参数
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1-zookeeper:9092,node2-zookeeper:9092,node3-zookeeper:9092");
//      指定key和value的序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//      2.创建kafka生产者对象
        KafkaProducer<String,String> kafkaProducer = new KafkaProducer<>(properties);
//      3.指定分区等参数
        ProducerRecord producerRecord = new ProducerRecord("demo01",2,"","第一条数据...");
//      4.发送数据,添加回调方式一
        kafkaProducer.send(producerRecord, new Callback() {
            @Override
            public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                if(null == e){
                    System.out.println("主题：" + recordMetadata.topic() + "\n" +
                            "分区：" + recordMetadata.partition() + "\n" +
                            "偏移量：" + recordMetadata.offset() + "\n"
                    );
                }
            }
        });
//      5.关闭资源
        kafkaProducer.close();
    }

    /**
     * 测试 指定不指定分区，指定key策略
     */
    @Test
    public void test2(){
//      1.拼接和配置参数
        Properties properties = new Properties();
//      --bootstrap-servers参数
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1-zookeeper:9092,node2-zookeeper:9092,node3-zookeeper:9092");
//      指定key和value的序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//      2.创建kafka生产者对象
        KafkaProducer<String,String> kafkaProducer = new KafkaProducer<>(properties);
//      3.指定key等参数
        ProducerRecord producerRecord = new ProducerRecord("demo01","ThisIsAKeyValue","第一条数据...");
//      4.发送数据,添加回调方式一
        kafkaProducer.send(producerRecord, new Callback() {
            @Override
            public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                if(null == e){
                    System.out.println("主题：" + recordMetadata.topic() + "\n" +
                            "分区：" + recordMetadata.partition() + "\n" +
                            "偏移量：" + recordMetadata.offset() + "\n"
                    );
                }
            }
        });
//      5.关闭资源
        kafkaProducer.close();
    }

    /**
     * 测试 既不指定分区，也不指定key策略
     */
    @Test
    public void test3() throws InterruptedException {
//      1.拼接和配置参数
        Properties properties = new Properties();
//      --bootstrap-servers参数
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node1-zookeeper:9092,node2-zookeeper:9092,node3-zookeeper:9092");
//      指定key和value的序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//      2.创建kafka生产者对象
        KafkaProducer<String,String> kafkaProducer = new KafkaProducer<>(properties);
//      3.指定参数
        for (int i = 0; i < 50; i++) {
//      4.发送数据,添加回调方式一
            kafkaProducer.send(new ProducerRecord("demo01","第"+i+"条数据..."), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if(null == e){
                        System.out.println("主题：" + recordMetadata.topic() + "\n" +
                                "分区：" + recordMetadata.partition() + "\n" +
                                "偏移量：" + recordMetadata.offset() + "\n"
                        );
                    }
                }
            });
//          每次发送完成后等待
            Thread.sleep(2);
        }
//      5.关闭资源
        kafkaProducer.close();
    }
}

自定义分区器

  • 测试：如研发人员根据企业需求，自己重新实现分区器。
  • 需求：实现一个分区器，发送过来的数据中如果包含“张三”，就发送往0号分区，不包含“张三”就发往1号分区
  • 用法：实现Partitioner类，并重写其中的方法
package com.moyuwanjia.kafka_study;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.Cluster;
import org.apache.kafka.common.serialization.StringSerializer;
import org.junit.Test;

import java.util.Map;
import java.util.Properties;

/**
 * 自定义分区器
 * 如研发人员根据企业需求，自己重新实现分区器。
 * 需求：实现一个分区器，发送过来的数据中如果包含“张三”，就发送往0号分区，不包含“张三”就发往1号分区
 *
 * 实现Partitioner类，并重写其中的方法
 */
public class demo03_TestMyPartitioner implements Partitioner {

    /**
     * @param topic      主题名称
     * @param key        key值
     * @param keyBytes   序列化后的key值
     * @param value      value值
     * @param valueBytes 序列化后的value值
     * @param cluster    The current cluster metadata
     * @return
     */
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        return value.toString().contains("张三") ? 0 : 1;
    }

    @Override
    public void close() {

    }

    @Override
    public void configure(Map<String, ?> configs) {

    }

    /**
     * 测试 自定义分区策略
     */
    @Test
    public void test3() throws InterruptedException {
        //      1.拼接和配置参数
        Properties properties = new Properties();
        //      --bootstrap-servers参数
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node1-zookeeper:9092,node2-zookeeper:9092,node3-zookeeper:9092");
        //      指定key和value的序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        //      使用自定义分区器
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, demo03_TestMyPartitioner.class.getName());

        //      2.创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
        //      3.指定参数
        for (int i = 0; i < 50; i++) {
            //      4.发送数据,添加回调方式一
            kafkaProducer.send(new ProducerRecord("demo01", "第" + (i % 2 > 0 ? "张三" : "李四") + "条数据"), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (null == e) {
                        System.out.println("主题：" + recordMetadata.topic() + "\n" +
                                           "分区：" + recordMetadata.partition() + "\n" +
                                           "偏移量：" + recordMetadata.offset() + "\n"
                                          );
                    }
                }
            });
            //          每次发送完成后等待
            Thread.sleep(2);
        }
        //      5.关闭资源
        kafkaProducer.close();
    }
}

以上就是kafka的使用、主题、分区等概念

 

摸鱼丸加
关注
专栏目录
kafka实战
weixin_30614109的博客
11-08 5661
1. kafka介绍 1.1. 主要功能 根据官网的介绍，ApacheKafka®是一个分布式流媒体平台，它主要有3种功能： 　　1：It lets you publish and subscribe to streams of records.发布和订阅消息流，这个功能类似于消息队列，这也是kafka归类为消息队列框架的原因 　　2：It lets ...
图解 Kafka 之实战指南
03-29
### 图解Kafka之实战指南知识点详述 #### 一、Kafka简介 **Kafka** 起初由LinkedIn采用Scala语言开发，后捐赠给Apache基金会，现已成为一款广泛应用于分布式流处理平台的成熟软件。它凭借高吞吐量、可持久化存储、...
Kafka全面教程，适合项目实战（包括源码剖析）
09-25
Kafka属于Apache组织，是一个高性能跨语言分布式发布订阅消息队列系统[7]。本课程是精短视频教程，从初步认识，用户日志上报实时统计与分析，消息处理与集群维护、消费者与生产者实例（Python和java）、源码剖析。
Kafka实战
行者小朱的博客
11-03 1395
        从搭建Windows下的Kafka运行环境和搭建Linux下的Kafka运行环境可以看出，环境一旦搭建完成，执行以下逻辑程序是固定的顺序，与环境无关： 启动Zookeeper 启动Kafka 创建Topic 启动生产者Producer发消息 启动消费者Consumer消费消息         因此，这里以Windows下的运行环境为例（windows环境搭建可以参见笔者之前的...
Kafka 实战
qq_41510985的博客
06-22 933
Kafka 实战一、kafka集群的安装与搭建1.1 kafka下载1.2 服务器准备1.3 解压安装包1.4 修改配置文件1.5配置环境变量1.6启动集群1.7kafka的命令行的使用创建topic查看所有的topickafka的消息发送kafka消息的消费使用zk来连接集群二、kafka的API使用第一步：创建maven工程，导入jar包第二步：kafka的生产者API第三步：kafka的消费者的API三、kafkaManager管理工具的使用 一、kafka集群的安装与搭建 1.1 kafka下载 下
Kafka-Vip-高性能消息中间件Kafka实战(1)1
08-08
Kafka 是一款高性能的分布式消息中间件，由 Scala 编写，主要特点是高吞吐量、持久化和可扩展性。Kafka 不是严格遵循 JMS 规范，但借鉴了其思想，提供了消息发布订阅功能。在 Kafka 中，消息以 Topic 形式组织，每个...
图解 Kafka 之实战指南.7z
12-22
《图解 Kafka 之实战指南》是一本深入解析Apache Kafka的实用书籍，旨在帮助读者理解和掌握这个分布式消息系统的精髓。Kafka是一个高吞吐、低延迟的开源流处理平台，常用于实时数据管道和流应用的构建。在这个实战...
Kafka 高级实战
08-19
- **硬件选择**：选择高性能的 SSD 存储和高速网络，减少磁盘 I/O 和网络延迟。 - **主题分区设计**：根据业务需求合理规划主题分区数量，避免热点分区导致的性能瓶颈。 - **监控与调优**：利用监控工具如 Kafka ...
高性能消息中间件Kafka实战1
08-08
Kafka是一种高性能的分布式消息中间件，主要用于处理实时数据流。它由Apache开发，并使用Scala编写，具有高吞吐量和可扩展性。Kafka借鉴了JMS（Java Message Service）的一些理念，但并未完全遵循其规范，而是创造了...
Kafaka实战应用
qq_43515662的博客
04-12 1926
kafka封装1功能需求2定义2.1约束定义2.2重点封装类：实现设计 1功能需求 有这么多消息中间件，为什么要使用kafka呢，Kafka,在大数据领域，Kafka目前是使用最多的框架，为了适应项目中大数据量的吞吐，实时流量计算等功能。 2定义 2.1约束定义 1.Topic命名约束： Topic分为单类和混合消息，不同类消息命名约束如下： 单类：heima.topic.[自定义名称].single 混合类： heima.topic.[自定义名称].bus 将工具类拷贝到common模块下的kafka
【Kafka】Kafka 实战教程（一）
书山有路，学海无涯。记录成长，追逐梦想
10-22 1993
应用往 Kafka 写数据的原因有很多：用户行为分析、日志存储、异步通信等。多样化的使用场景带来了多样化的需求：消息是否能丢失？是否容忍重复？消息的吞吐量？消息的延迟？
kafka实战应用——基础了解
qq_44871116的博客
01-05 861
对kafka最简单的介绍和卡夫卡的一些基础特性简单介绍。
kafka(10) 应用级实战
RichardGeek的博客
11-02 130
kafka 官网：Apache Kafka 1.kafka-connect 异构数据源同步方案 业务实战背景： Confluent Schema Registry +kafka-connector Kafka 中使用 Avro 序列化组件(三)：Confluent Schema Registry - 云+社区 - 腾讯云掘金https://juejin.cn/post/7025497478535315469 Apache Kafkahttp://kafka.apa...
大牛呕心力作——Kafka开发实战，助你徜徉大数据时代
最新发布
2401_84186026的博客
04-12 877
Kafka快速入门消息引擎系统Kafka概要设计Kafka基本概念与术语Kafka使用场景本章小结。
KafKa详细入门实战
少年Dream
08-10 3117
输入命令执行后，此时会进入一个等待状态，当生产者再次发送一条消息，这边消费者就能消费接收到对应的消息。
Kafka：从概念到实战的高性能消息系统解析
Kafka的初步认识 Kafka是由LinkedIn公司在2010年12月开源的一款分布式消息系统，它最初是为了解决应用程序间...掌握Kafka，不仅有助于理解消息传递的基本模式，还能提升在高并发和大数据场景下的系统设计和优化能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值