Kafka 生产者消息发送流程

最新推荐文章于 2024-05-25 20:31:37 发布
最新推荐文章于 2024-05-25 20:31:37 发布
阅读量1.4k 收藏 11
点赞数 1
分类专栏： Kafka 文章标签： kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rzpy_qifengxiaoyue/article/details/109528706
版权

1. 数据生产流程解析

在这里插入图片描述

  1. Producer创建时，会创建一个Sender线程并设置为守护线程。
  2. 生产消息时，内部其实是异步流程;生产的消息先经过拦截器->序列化器->分区器，然后将消息缓存在缓冲区(该缓冲区也是在Producer创建时创建)。
  3. 批次发送的条件为:缓冲区数据大小达到batch.size或者linger.ms达到上限，哪个先达到就算哪个。
  4. 批次发送后，发往指定分区，然后落盘到broker;如果生产者配置了retrires参数大于0并且失败原因允许重试，那么客户端内部会对该消息进行重试。
  5. 落盘到broker成功，返回生产元数据给生产者。
  6. 元数据返回有两种方式:一种是通过阻塞直接返回，另一种是通过回调返回。

2. 配置参数:

  • 配置使用方式：
Map<String, Object> configs = new HashMap();
configs.put("bootstrap.servers", "node1:9092");
configs.put("key.serializer","org.apache.kafka.common.serialization.StringSerializer");
configs.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
configs.put("acks", "all");
configs.put("compression", "gzip");
configs.put("retries", 3);

//key可以使用ProducerConfig常量
//        configs.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node1:9092");

KafkaProducer<String, String> producer = new KafkaProducer<String, String>(configs);

*配置参数：

属性说明重要性
bootstrap.servers生产者客户端与broker集群建立初始连接需要的broker地址列表，由 该初始连接发现Kafka集群中其他的所有broker。该地址列表不需要 写全部的Kafka集群中broker的地址，但也不要写一个，以防该节点 宕机的时候不可用。形式为: host1:port1,host2:port2,… .high
key.serializer实现了接口 org.apache.kafka.common.serialization.Serializer 的key序列化类。high
value.serializer实现了接口 org.apache.kafka.common.serialization.Serializer 的value序列化类。high
acks该选项控制着已发送消息的持久性。
acks=0 :生产者不等待broker的任何消息确认。只要将消息放到了socket的缓冲区，就认为消息已发送。不能保证服务器是否收到该消 息， retries 设置也不起作用，因为客户端不关心消息是否发送失 败。客户端收到的消息偏移量永远是-1。
acks=1 :leader将记录写到它本地日志，就响应客户端确认消息， 而不等待follower副本的确认。如果leader确认了消息就宕机，则可 能会丢失消息，因为follower副本可能还没来得及同步该消息。
acks=all :leader等待所有同步的副本确认该消息。保证了只要有 一个同步副本存在，消息就不会丢失。这是最强的可用性保证。等价 于
acks=-1。默认值为1，字符串。可选值:[all, -1, 0, 1]		high
compression.type生产者生成数据的压缩格式。默认是none(没有压缩)。允许的 值: none ， gzip ， snappy 和 lz4 。压缩是对整个消息批次来讲 的。消息批的效率也影响压缩的比例。消息批越大，压缩效率越好。 字符串类型的值。默认是none。high
retries设置该属性为一个大于1的值，将在消息发送失败的时候重新发送消 息。该重试与客户端收到异常重新发送并无二至。允许重试但是不设 置 max.in.flight.requests.per.connection 为1，存在消息乱序 的可能，因为如果两个批次发送到同一个分区，第一个失败了重试， 第二个成功了，则第一个消息批在第二个消息批后。int类型的值，默 认:0，可选值:[0,…,2147483647]high
retry.backoff.ms在向一个指定的主题分区重发消息的时候，重试之间的等待时间。 比如3次重试，每次重试之后等待该时间长度，再接着重试。在一些失败的场 景，避免了密集循环的重新发送请求。long型值，默认100。可选值:[0,…]
request.timeout.ms客户端等待请求响应的最大时长。如果服务端响应超时，则会重发请求，除非 达到重试次数。该设置应该比replica.lag.time.max.ms (a broker configuration)要大，以免在服务器延迟时间内重发消息。int类型值，默认: 30000，可选值:[0,…]
interceptor.classes在生产者接收到该消息，向Kafka集群传输之前，由序列化器处理之前，可以 通过拦截器对消息进行处理。
要求拦截器类必须实现org.apache.kafka.clients.producer.ProducerInterceptor 接口。 默认没有拦截器。Map<String, Object> configs中通过List集合配置多个拦截器类名。
batch.size当多个消息发送到同一个分区的时候，生产者尝试将多个记录作为一个批来处 理。批处理提高了客户端和服务器的处理效率。 该配置项以字节为单位控制默认批的大小。
所有的批小于等于该值。 发送给broker的请求将包含多个批次，每个分区一个，并包含可发送的数
据。 如果该值设置的比较小，会限制吞吐量(设置为0会完全禁用批处理)。如果 设置的很大，又有一点浪费内存，因为Kafka会永远分配这么大的内存来参与 到消息的批整合中。
client.id生产者发送请求的时候传递给broker的id字符串。 用于在broker的请求日志中追踪什么应用发送了什么消息。 一般该id是跟业务有关的字符串。
send.buffer.bytesTCP发送数据的时候使用的缓冲区(SO_SNDBUF)大小。如果设置为0，则使 用操作系统默认的。
buffer.memory生产者可以用来缓存等待发送到服务器的记录的总内存字节。如果记录的发送 速度超过了将记录发送到服务器的速度，则生产者将阻塞 max.block.ms 的时 间，此后它将引发异常。此设置应大致对应于生产者将使用的总内存，但并非 生产者使用的所有内存都用于缓冲。一些额外的内存将用于压缩(如果启用了 压缩)以及维护运行中的请求。long型数据。默认值:33554432，可选值: [0,…]
connections.max.idle.ms当连接空闲时间达到这个值，就关闭连接。long型数据，默认:540000
linger.ms生产者在发送请求传输间隔会对需要发送的消息进行累积，然后作为一个批次 发送。一般情况是消息的发送的速度比消息累积的速度慢。有时客户端需要减 少请求的次数，即使是在发送负载不大的情况下。该配置设置了一个延迟，生 产者不会立即将消息发送到broker，而是等待这么一段时间以累积消息，然 后将这段时间之内的消息作为一个批次发送。该设置是批处理的另一个上限: 一旦批消息达到了 batch.size 指定的值，消息批会立即发送，如果积累的消 息字节数达不到 batch.size 的值，可以设置该毫秒值，等待这么长时间之 后，也会发送消息批。该属性默认值是0(没有延迟)。如果设置 linger.ms=5 ，则在一个请求发送之前先等待5ms。long型值，默认:0，可 选值:[0,…]
max.block.ms控制 KafkaProducer.send() 和 KafkaProducer.partitionsFor() 阻塞的 时长。当缓存满了或元数据不可用的时候，这些方法阻塞。在用户提供的序列 化器和分区器的阻塞时间不计入。long型值，默认:60000，可选值:[0,…]
max.request.size单个请求的最大字节数。该设置会限制单个请求中消息批的消息个数，以免单 个请求发送太多的数据。服务器有自己的限制批大小的设置，与该配置可能不 一样。int类型值，默认1048576，可选值:[0,…]
partitioner.class实现了接口org.apache.kafka.clients.producer.Partitioner 的分区 器实现类。默认值为:org.apache.kafka. clients.producer.internals.DefaultPartitioner
receive.buffer.bytesTCP接收缓存(SO_RCVBUF)，如果设置为-1，则使用操作系统默认的值。 int类型值，默认32768，可选值:[-1,…]
security.protocol跟broker通信的协议:PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL. string类型值，默认:PLAINTEXT
max.in.flight.requests.per .connection单个连接上未确认请求的最大数量。达到这个数量，客户端阻塞。如果该值大 于1，且存在失败的请求，在重试的时候消息顺序不能保证。 int类型值，默认5。可选值:[1,…]
reconnect.backoff.max.ms对于每个连续的连接失败，每台主机的退避将成倍增加，直至达到此最大值。 在计算退避增量之后，添加20%的随机抖动以避免连接风暴。 long型值，默认1000，可选值:[0,…]
reconnect.backoff.ms尝试重连指定主机的基础等待时间。避免了到该主机的密集重连。该退避时间 应用于该客户端到broker的所有连接。
long型值，默认50。可选值:[0,…]

3. 自定义序列化器

由于Kafka中的数据都是字节数组，在将消息发送到Kafka之前需要先将数据序列化为字节数组。
序列化器的作用就是用于序列化要发送的消息的。
Kafka使用 org.apache.kafka.common.serialization.Serializer 接口用于定义序列化器，将泛型指定类型的数据转换为字节数组。

要序列化的实体类

import lombok.Data;

/**
 * 用户自定义的封装消息的实体类
 */
@Data
public class User {
    private Integer userId;
    private String username;
}

自定义序列化方器

public class UserSerializer implements Serializer<User> {

    @Override
    public void configure(Map<String, ?> configs, boolean isKey) {
        // do nothing
        // 用于接收对序列化器的配置参数，并对当前序列化器进行配置和初始化的
    }

    @Override
    public byte[] serialize(String topic, User data) {
        try {
            if (data == null) {
                return null;
            } else {
                final Integer userId = data.getUserId();
                final String username = data.getUsername();

                if (userId != null) {
                    if (username != null) {
                        final byte[] bytes = username.getBytes("UTF-8");
                        int length = bytes.length;
                        // 第一个4个字节用于存储userId的值
                        // 第二个4个字节用于存储username字节数组的长度int值
                        // 第三个长度，用于存放username序列化之后的字节数组
                        ByteBuffer buffer = ByteBuffer.allocate(4 + 4 + length);
                        // 设置userId
                        buffer.putInt(userId);
                        // 设置username字节数组长度
                        buffer.putInt(length);
                        // 设置username字节数组
                        buffer.put(bytes);
                        // 以字节数组形式返回user对象的值
                        return buffer.array();
                    }
                }
            }
        } catch (Exception e) {
            throw new SerializationException("数据序列化失败");
        }
        return null;
    }

    @Override
    public void close() {
        // do nothing
        // 用于关闭资源等操作。需要幂等，即多次调用，效果是一样的。
    }
}

使用自定义序列化器发送消息

public class MyProducer {
    public static void main(String[] args) {
        Map<String, Object> configs = new HashMap();
        configs.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node1:9092");
        configs.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 设置自定义的序列化器
        configs.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, UserSerializer.class);

        KafkaProducer<String, User> producer = new KafkaProducer<String, User>(configs);

        User user = new User();
        user.setUserId(400);
        user.setUsername("赵四");

        ProducerRecord<String, User> record = new ProducerRecord<String, User>(
                "tp_user_01",   // topic
                user.getUsername(),   // key
                user                  // value
        );

        producer.send(record, new Callback() {
            @Override
            public void onCompletion(RecordMetadata metadata, Exception exception) {
                if (exception != null) {
                    System.out.println("消息发送异常");
                } else {
                    System.out.println("主题：" + metadata.topic() + "\t"
                            + "分区：" + metadata.partition() + "\t"
                            + "生产者偏移量：" + metadata.offset());
                }
            }
        });

        // 关闭生产者
        producer.close();

    }
}

4. 自定义分区器

默认(DefaultPartitioner)分区计算:

  1. 如果record提供了分区号，则使用record提供的分区号
  2. 如果record没有提供分区号，则使用key的序列化后的值的hash值对分区数量取模
  3. 如果record没有提供分区号，也没有提供key，则使用轮询的方式分配分区号。
    - 会首先在可用的分区中分配分区号
    - 如果没有可用的分区，则在该主题所有分区中分配分区号。

如果要自定义分区器，则需要

  1. 首先开发Partitioner接口的实现类
  2. 在KafkaProducer中进行设置:configs.put(“partitioner.class”, “xxx.xx.Xxx.class”)

自定义分区器

/**
 * 自定义分区器
 */
public class MyPartitioner implements Partitioner {
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        // 此处可以计算分区的数字。
        // 我们直接指定为2
        return 2;
    }

    @Override
    public void close() {

    }

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

    }
}

使用自定义分区器发送消息

public class MyProducer {
    public static void main(String[] args) {

        Map<String, Object> configs = new HashMap<>();
        configs.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node1:9092");
        configs.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configs.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);

        // 指定自定义的分区器
        configs.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, MyPartitioner.class);

        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(configs);

        // 此处不要设置partition的值
        ProducerRecord<String, String> record = new ProducerRecord<String, String>(
                "tp_part_01",
                "mykey",
                "myvalue"
        );

        producer.send(record, new Callback() {
            @Override
            public void onCompletion(RecordMetadata metadata, Exception exception) {
                if (exception != null) {
                    System.out.println("消息发送失败");
                } else {
                    System.out.println(metadata.topic());
                    System.out.println(metadata.partition());
                    System.out.println(metadata.offset());
                }
            }
        });

        // 关闭生产者
        producer.close();

    }
}

5. 自定义拦截器

在这里插入图片描述
Producer拦截器(interceptor)和Consumer端Interceptor是在Kafka 0.10版本被引入的，主要用于实现Client端的定制化控制逻辑。

对于Producer而言，Interceptor使得用户在消息发送前以及Producer回调逻辑前有机会对消息做 一些定制化需求，比如修改消息等。同时，Producer允许用户指定多个Interceptor按序作用于同一条消 息从而形成一个拦截链(interceptor chain)。Intercetpor的实现接口是 org.apache.kafka.clients.producer.ProducerInterceptor，其定义的方法包括:

  • onSend(ProducerRecord):该方法封装进KafkaProducer.send方法中，即运行在用户主线程 中。Producer确保在消息被序列化以计算分区前调用该方法。用户可以在该方法中对消息做任 何操作，但最好保证不要修改消息所属的topic和分区，否则会影响目标分区的计算。
  • onAcknowledgement(RecordMetadata, Exception):该方法会在消息被应答之前或消息发送 失败时调用，并且通常都是在Producer回调逻辑触发之前。onAcknowledgement运行在Producer的IO线程中，因此不要在该方法中放入很重的逻辑，否则会拖慢Producer的消息发 送效率。
  • close:关闭Interceptor，主要用于执行一些资源清理工作。

如前所述，Interceptor可能被运行在多个线程中，因此在具体实现时用户需要自行确保线程安全。 另外倘若指定了多个Interceptor，则Producer将按照指定顺序调用它们，并仅仅是捕获每个 Interceptor可能抛出的异常记录到错误日志中而非在向上传递。这在使用过程中要特别留意。

自定义拦截器:

  1. 实现ProducerInterceptor接口
  2. 在KafkaProducer的设置中设置自定义的拦截器

自定义拦截器

public class InterceptorOne implements ProducerInterceptor<Integer, String> {

    private static final Logger LOGGER = LoggerFactory.getLogger(InterceptorOne.class);

    @Override
    public ProducerRecord<Integer, String> onSend(ProducerRecord<Integer, String> record) {
        System.out.println("拦截器1 -- go");


        // 消息发送的时候，经过拦截器，调用该方法

        // 要发送的消息内容
        final String topic = record.topic();
        final Integer partition = record.partition();
        final Integer key = record.key();
        final String value = record.value();
        final Long timestamp = record.timestamp();
        final Headers headers = record.headers();


        // 拦截器拦下来之后根据原来消息创建的新的消息
        // 此处对原消息没有做任何改动
        ProducerRecord<Integer, String> newRecord = new ProducerRecord<Integer, String>(
                topic,
                partition,
                timestamp,
                key,
                value,
                headers
        );
        // 传递新的消息
        return newRecord;
    }

    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
        System.out.println("拦截器1 -- back");
        // 消息确认或异常的时候，调用该方法，该方法中不应实现较重的任务
        // 会影响kafka生产者的性能。
    }

    @Override
    public void close() {

    }

    @Override
    public void configure(Map<String, ?> configs) {
        final Object classContent = configs.get("classContent");
        System.out.println(classContent);
    }
}

public class InterceptorTwo implements ProducerInterceptor<Integer, String> {

    private static final Logger LOGGER = LoggerFactory.getLogger(InterceptorTwo.class);

    @Override
    public ProducerRecord<Integer, String> onSend(ProducerRecord<Integer, String> record) {
        System.out.println("拦截器2 -- go");


        // 消息发送的时候，经过拦截器，调用该方法

        // 要发送的消息内容
        final String topic = record.topic();
        final Integer partition = record.partition();
        final Integer key = record.key();
        final String value = record.value();
        final Long timestamp = record.timestamp();
        final Headers headers = record.headers();


        // 拦截器拦下来之后根据原来消息创建的新的消息
        // 此处对原消息没有做任何改动
        ProducerRecord<Integer, String> newRecord = new ProducerRecord<Integer, String>(
                topic,
                partition,
                timestamp,
                key,
                value,
                headers
        );
        // 传递新的消息
        return newRecord;
    }

    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
        System.out.println("拦截器2 -- back");
        // 消息确认或异常的时候，调用该方法，该方法中不应实现较重的任务
        // 会影响kafka生产者的性能。
    }

    @Override
    public void close() {

    }

    @Override
    public void configure(Map<String, ?> configs) {
        final Object classContent = configs.get("classContent");
        System.out.println(classContent);
    }
}

public class MyProducer {
    public static void main(String[] args) {

        Map<String, Object> configs = new HashMap<>();
        configs.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node1:9092");
        configs.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, IntegerSerializer.class);
        configs.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);

        // 保证等待确认的消息只有设置的这几个。如果设置为1，则只有一个请求在等待响应
        // 此时可以保证发送消息即使在重试的情况下也是有序的。
        configs.put(ProducerConfig.MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION, 1);
//        configs.put("max.in.flight.requests.per.connection", 1);

//        interceptor.classes
        // 如果有多个拦截器，则设置为多个拦截器类的全限定类名，中间用逗号隔开
        configs.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG,
                "com.lagou.kafka.demo.interceptor.InterceptorOne," +
                        "com.lagou.kafka.demo.interceptor.InterceptorTwo");


        configs.put("classContent", "this is lagou's kafka class");

        KafkaProducer<Integer, String> producer = new KafkaProducer<Integer, String>(configs);

        ProducerRecord<Integer, String> record = new ProducerRecord<Integer, String>(
                "tp_inter_01",
                0,
                1001,
                "this is lagou's 1001 message"
        );

        producer.send(record, new Callback() {
            @Override
            public void onCompletion(RecordMetadata metadata, Exception exception) {
                if (exception == null) {
                    System.out.println("消息发送成功：" + metadata.topic() + " " + metadata.offset());
                }
            }
        });

        // 关闭生产者
        producer.close();


    }
}

运行结果

拦截器1 -- go
拦截器2 -- go
拦截器1 -- back
拦截器2 -- back
消息发送成功： tp_inter_01 1
四月丶丶
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
kafka 生产者发送流程
qq_38016945的博客
02-09 339
Kafka是由Apache软件基金会开发的一个开源流处理平台，由Scala和Java编写。Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者在网站中的所有动作流数据。kafka的基础架构：Kafka生产者发送流程详解 :​​​拦截器序列化器分区器生产者端由两个线程协调完成，分别是main线程和Sender线程。main线程在将消息通过拦截器、序列化器和分区器处理后缓存到消息累加器（RecordAccumlator）中。
kafka生产者消费者插件 steps.zip
11-16
标题中的"Kafka生产者消费者插件 steps.zip"指的是在Kettle 8.2版本中使用的，与Kafka交互的特定插件。这个插件允许Kettle作业或转换发送和接收消息到Kafka集群，从而实现数据的实时流动。 描述中提到，该插件适用...
kafka 生产者源码分析（一）- 生产者发送消息过程
扎克begod的专栏
08-14 1257
基于kafka 0.10版本源码分析    早期kafka 0.8.22，0.9.X 版本kafka 生产者消费者服务端都是用scala编写。而且放在cores包下，新版本的客户端使用java实现，放在clients包下。      新的生产者客户端是一个进程，使用KafkaProducer对象实例化。这个生产者客户端，不直接发送消息给服务端，而是使用了一个名叫 RecordAccumulat...
Kafka详解
最新发布
qq_41644412的博客
05-25 1306
consumer 提交offset的时候，kafka Offset manager会首先追加一条新的conmit消息到 _consumer_offset topic中，然后更新对应的缓存，读offset时从缓存中读取，而不是直接读取 _consumer_offset topic。如查找368801的offset消息。同一个Topic的每个分区中的数据是不重复的，partition的表现形式是一个一个文件夹。文件，每个 .log文件 的大小是一样的，但是里面存储的消息条数可能不相同（可能消息的大小不一致）。
Kafka生产者发送消息的流程
张俊杰 的博客
01-27 556
生产者发送消息的流程 文章来源于我的知识库: https://www.yuque.com/crow/message_oriented_middleware 概念 Kafka的Producer发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main线程和Sender线程，以及一个线程共享变量——RecordAccumulator(两个线程之间共享的)。 main线程将要发送的消息包装成ProducerRecord 之后放到RecordAccumulator(线程共享变量)，Sender
从源码分析如何优雅的使用 Kafka 生产者
weixin_34228662的博客
10-11 131
前言 在上文 设计一个百万级的消息推送系统 中提到消息流转采用的是 Kafka 作为中间件。 其中有朋友咨询在大量消息的情况下 Kakfa 是如何保证消息的高效及一致性呢？ 正好以这个问题结合 Kakfa 的源码讨论下如何正确、高效的发送消息。 内容较多，对源码感兴趣的朋友请系好安全带
Kafka生产者流程客户端消息发送过程解析
weixin_43956062的博客
06-17 313
本文Kafka源码版本：1.0.0. 一、KafkaProducer介绍 1、KafkaProducer介绍与使用 KafkaProducer是Kafka的客户端、消息的生产者，用来将消息发往Kafka cluster。KafkaProducer是线程安全的，并且单线程使用KafkaProducer实例比多线程性能更高。 使用示例： Properties props = new Properties(); props.put("bootstrap.servers", "localhost:9092");
Kafka 生产者解析.doc
07-13
本文将深入解析Kafka生产者的内部机制，包括消息发送流程、必要的参数配置以及拦截器的使用。 ### 一、消息发送 1. **数据生产流程** 生产者在启动时创建一个Sender线程作为守护线程，用于处理消息发送。当生产...
kettle kafka 消息生产插件
01-17
Kafka的生产者是负责将消息写入Kafka集群的组件，而这款插件则使得Kettle可以扮演生产者的角色。 在文件“pentaho-kafka-producer”中，我们可以预期找到与这个插件相关的源代码、配置文件、文档或其他支持资源。...
kafka生产数据工程
04-26
6. **配置优化**：为了获得最佳性能，我们需要调整Kafka生产者的各种配置，如批量发送大小、缓冲区大小、超时时间等。这需要根据实际的硬件资源和业务需求进行。 7. **监控与日志**：为了确保数据流动的稳定性和可...
消息队列kafka源码详细讲解分析
12-21
1. 生产者（Producer）：生产者是数据的源头，负责将消息发布到Kafka的主题（Topic）上。在源码中，`ProducerRecord`类是消息的基本单元，包含了主题名、键、值和元数据等信息。 2. 消费者（Consumer）：消费者订阅...
Kafka简介及使用PHP处理Kafka消息
08-15
4. Producers：消息和数据生产者，向 Kafka 的一个 topic 发布消息的过程叫做 producers。 5. Consumers：消息和数据消费者，订阅 topics 并处理其发布的消息的过程叫做 consumers。 6. Broker：缓存代理，Kafka ...
KafkaDemo.rar
04-07
- 学习如何编写简单的Kafka生产者和消费者程序。 - 掌握配置Kafka客户端的基本方法。 - 实践消息的发布与订阅操作，了解消息的顺序性和一致性。 记得在实践过程中，关注错误处理和配置优化，这对理解和掌握Kafka至...
Springboot整合kafka做消息通信_20200410.docx
04-10
为了提高效率，Kafka 支持批量发送和接收消息，生产者可以一次性发送多条消息，消费者也可以一次性处理一批消息。 八、关于 SpringBoot 中的 Kafka “事务”： SpringBoot 集成了 Kafka 事务支持，允许在分布式环境...
kafka消息管理可视化运行软件
06-21
它允许生产者发布消息到主题（topics），消费者则可以从这些主题中订阅并消费消息。Kafka通过分区和复制机制保证了数据的可靠性和可用性，使其在大规模数据处理场景下表现出色。 这款可视化软件的主要功能包括： 1...
python hbase读取数据发送kafka的方法
09-19
这里假设我们已经配置了Kafka的生产者实例。 ```python def send_to_kafka(self, data): producer = KafkaProducer(bootstrap_servers=['localhost:9092']) # 假设Kafka运行在本地 producer.send('my-topic', ...
kafka生产者的发送消息的流程以及代码案例
健康平安的活着的专栏
04-06 4969
一 kafka发送消息流程 1.1 发送流程原理 kafka在发送消息的过程中，主要涉及两个线程main 线程和 Sender 线程。 在 main 线程 中创建了一个双端队列 RecordAccumulator。main 线程将消息发送给 RecordAccumulator。 Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka Broker。 1.2 发送信息的时机 生产者何时向broker中发送信息。触发什么机制开始发送呢？这里有两种机制 1.
kafka生产者API操作
鸭梨的博客
11-27 249
example 创建producer发送信息给消费者 object kafakaTest extends App { //设定配置相关 private val prop = new Properties() prop.setProperty("bootstrap.servers", "mypc01:9092,mypc02:9092,mypc03:9092") prop.setProperty("acks", "0") prop.setProperty("key.serializer", "o
KAFKA 消息生产过程
weixin_30716725的博客
08-06 200
写入方式 producer 采用推（push）模式将消息发布到 broker，每条消息都被追加（append）到分区（patition）中，属于顺序写磁盘（顺序写磁盘效率比随机写内存要高，保障 kafka 吞吐率） 分区（Partition） 消息发送时都被发送到一个 topic，其本质就是一个目录，而 topic 是由一些 ...
"Kafka 生产者消息发送流程与参数配置详解
消息发送的过程涉及到多个步骤和参数配置，下面将对Kafka生产者的消息发送流程和必要的参数配置进行详细解析。 首先，消息发送的数据生产流程如下：当Producer创建时，会同时创建一个Sender线程并设置为守护线程。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值