kafka生产者详解

最新推荐文章于 2024-04-08 04:21:55 发布
最新推荐文章于 2024-04-08 04:21:55 发布
阅读量660 收藏 3
点赞数 2
文章标签： kafka java 分布式 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangshenglu1/article/details/105235135
版权

maven依赖如下：

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

生产者就是将消息发送到kafka上的应用程序。

一般来说正常的一个消费者需要准备以下几个步骤：

1）、配置生产者客户端参数及创建相应的生产者实例

2）、构建待发送的的消息

3）、发送消息

4）、关闭生产者实例

kafka生产者发送消息的示例：

public class ProducerDemo {
    public static  final  String brokerList="192.168.195.134:9092";
    public static  final String topic = "topic-demo";

  public static void main(String[] args) throws ExecutionException, InterruptedException {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,brokerList);
        properties.put(ProducerConfig.RETRIES_CONFIG,3);
        properties.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG,MyProducerInterceptor.class.getName());


      //  objectJsonSerializer.setAddTypeInfo(false);
        //实例化produce
        KafkaProducer<String,String> producer = new KafkaProducer<>(properties, new StringSerializer(),new StringSerializer());

      for(int i= 0;i<1000;i++){
          //发送消息
          //构建发送的记录
          ProducerRecord<String,String> record = new ProducerRecord<>(topic,"hello","hello,kafka");
          Future<RecordMetadata> send = producer.send(record,((metadata, exception) -> {
              if(exception !=null){
                  exception.printStackTrace();
              }else{
                  System.out.println(metadata.topic()+"-" + metadata.offset() + "-" + metadata.partition());
              }
          }));
          //阻塞等待发送的结果
          send.get();
         // Thread.sleep(500);
      }


        //关闭客户端
       producer.close();

    }
}

上述代码按照 配置参数 -->实例化生产者–>构建发送记录 -->发送消息步骤进行。接下来我们将按照此步骤进行一一分析。

1、生产者参数配置

在java 客户端，生产者的参数配置我们可以参考org.apache.kafka.clients.producer.ProducerConfig 类。其中定义各参数的名称,源码如下：

public class ProducerConfig extends AbstractConfig {

    /*
     * NOTE: DO NOT CHANGE EITHER CONFIG STRINGS OR THEIR JAVA VARIABLE NAMES AS THESE ARE PART OF THE PUBLIC API AND
     * CHANGE WILL BREAK USER CODE.
     */

    private static final ConfigDef CONFIG;

    /** <code>bootstrap.servers</code> */
    public static final String BOOTSTRAP_SERVERS_CONFIG = CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG;

    /** <code>client.dns.lookup</code> */
    public static final String CLIENT_DNS_LOOKUP_CONFIG = CommonClientConfigs.CLIENT_DNS_LOOKUP_CONFIG;

    /** <code>metadata.max.age.ms</code> */
    public static final String METADATA_MAX_AGE_CONFIG = CommonClientConfigs.METADATA_MAX_AGE_CONFIG;
    private static final String METADATA_MAX_AGE_DOC = CommonClientConfigs.METADATA_MAX_AGE_DOC;

    /** <code>batch.size</code> */
    public static final String BATCH_SIZE_CONFIG = "batch.size";


    /** <code>acks</code> */
    public static final String ACKS_CONFIG = "acks";


    /** <code>linger.ms</code> */
    public static final String LINGER_MS_CONFIG = "linger.ms";


    /** <code>request.timeout.ms</code> */
    public static final String REQUEST_TIMEOUT_MS_CONFIG = CommonClientConfigs.REQUEST_TIMEOUT_MS_CONFIG;
    private static final String REQUEST_TIMEOUT_MS_DOC = CommonClientConfigs.REQUEST_TIMEOUT_MS_DOC
        + " This should be larger than <code>replica.lag.time.max.ms</code> (a broker configuration)"
        + " to reduce the possibility of message duplication due to unnecessary producer retries.";

    /** <code>delivery.timeout.ms</code> */
    public static final String DELIVERY_TIMEOUT_MS_CONFIG = "delivery.timeout.ms";


    /** <code>client.id</code> */
    public static final String CLIENT_ID_CONFIG = CommonClientConfigs.CLIENT_ID_CONFIG;

    /** <code>send.buffer.bytes</code> */
    public static final String SEND_BUFFER_CONFIG = CommonClientConfigs.SEND_BUFFER_CONFIG;

    /** <code>receive.buffer.bytes</code> */
    public static final String RECEIVE_BUFFER_CONFIG = CommonClientConfigs.RECEIVE_BUFFER_CONFIG;

    /** <code>max.request.size</code> */
    public static final String MAX_REQUEST_SIZE_CONFIG = "max.request.size";


    /** <code>reconnect.backoff.ms</code> */
    public static final String RECONNECT_BACKOFF_MS_CONFIG = CommonClientConfigs.RECONNECT_BACKOFF_MS_CONFIG;

    /** <code>reconnect.backoff.max.ms</code> */
    public static final String RECONNECT_BACKOFF_MAX_MS_CONFIG = CommonClientConfigs.RECONNECT_BACKOFF_MAX_MS_CONFIG;

    /** <code>max.block.ms</code> */
    public static final String MAX_BLOCK_MS_CONFIG = "max.block.ms";


    /** <code>buffer.memory</code> */
    public static final String BUFFER_MEMORY_CONFIG = "buffer.memory";

    /** <code>retry.backoff.ms</code> */
    public static final String RETRY_BACKOFF_MS_CONFIG = CommonClientConfigs.RETRY_BACKOFF_MS_CONFIG;

    /** <code>compression.type</code> */
    public static final String COMPRESSION_TYPE_CONFIG = "compression.type";

    /** <code>metrics.sample.window.ms</code> */
    public static final String METRICS_SAMPLE_WINDOW_MS_CONFIG = CommonClientConfigs.METRICS_SAMPLE_WINDOW_MS_CONFIG;

    /** <code>metrics.num.samples</code> */
    public static final String METRICS_NUM_SAMPLES_CONFIG = CommonClientConfigs.METRICS_NUM_SAMPLES_CONFIG;

    /**
     * <code>metrics.recording.level</code>
     */
    public static final String METRICS_RECORDING_LEVEL_CONFIG = CommonClientConfigs.METRICS_RECORDING_LEVEL_CONFIG;

    /** <code>metric.reporters</code> */
    public static final String METRIC_REPORTER_CLASSES_CONFIG = CommonClientConfigs.METRIC_REPORTER_CLASSES_CONFIG;

    /** <code>max.in.flight.requests.per.connection</code> */
    public static final String MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION = "max.in.flight.requests.per.connection";

    /** <code>retries</code> */
    public static final String RETRIES_CONFIG = CommonClientConfigs.RETRIES_CONFIG;


    /** <code>key.serializer</code> */
    public static final String KEY_SERIALIZER_CLASS_CONFIG = "key.serializer";

    /** <code>value.serializer</code> */
    public static final String VALUE_SERIALIZER_CLASS_CONFIG = "value.serializer";


    /** <code>connections.max.idle.ms</code> */
    public static final String CONNECTIONS_MAX_IDLE_MS_CONFIG = CommonClientConfigs.CONNECTIONS_MAX_IDLE_MS_CONFIG;
    /** <code>partitioner.class</code> */
    public static final String PARTITIONER_CLASS_CONFIG = "partitioner.class";

    /** <code>interceptor.classes</code> */
    public static final String INTERCEPTOR_CLASSES_CONFIG = "interceptor.classes";

    /** <code>enable.idempotence</code> */
    public static final String ENABLE_IDEMPOTENCE_CONFIG = "enable.idempotence";

    /** <code> transaction.timeout.ms </code> */
    public static final String TRANSACTION_TIMEOUT_CONFIG = "transaction.timeout.ms";

    /** <code> transactional.id </code> */
    public static final String TRANSACTIONAL_ID_CONFIG = "transactional.id";

对于每一个参数具体含义及重要等级可以参考官网：http://kafka.apache.org/documentation/#producerconfigs

上面所有的参数，有三个是必须要自己指定的。

  • **bootstrap.servers ** :kafka集群的地址列表。如：localhost:9092,localhost:9093 。多个之间采用","分隔。
  • key.serializer :用来对消息的key值进行序列化
  • value.serializer : 对消息的value值进行序列化

2、创建Producer对象

其主要的构建方法有如下的3个：

public KafkaProducer(final Map<String, Object> configs)
public KafkaProducer(Map<String, Object> configs, Serializer<K> keySerializer, Serializer<V> valueSerializer) 
public KafkaProducer(Properties properties)

3、构建要发送的消息

在我们完成生产者实例后，接下来的工作就是构建消息，即创建org.apache.kafka.clients.producer.ProducerRecord对象 ，topic和value值是必填的值。

 public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V value, Iterable<Header> headers) 
     
 public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V value) 
     
public ProducerRecord(String topic, Integer partition, K key, V value, Iterable<Header> headers) 
     
public ProducerRecord(String topic, Integer partition, K key, V value)
    

    public ProducerRecord(String topic, K key, V value) 
     

    public ProducerRecord(String topic, V value)

实例中是采用的是第四个构造函数来创建ProducerRecord对象。

生产者发送消息一般有两种方式：同步发送和异步发送。像示例中的发送方式就是同步的。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8m23bRLA-1585667238961)(assets/1585645796216.png)]

这里两个重载的send方法都会返回future对象，要想实现同步，需要用到Future对象实现。

如：

future.send(record).get();

kakfa的生产者发送消息如果发生可重试的异常且配置了重置参数，那么只要在规定重试次数内自行恢复，就不会抛出异常。retries参数的默认值为0；配置方式参考如下：

   properties.put(ProducerConfig.RETRIES_CONFIG,3);

示例中配置的重试次数为5。如果重试了5次后还没有恢复，那么依旧会抛出异常。

采用同步发送的方式最为可靠，但是性能低。异步的发送就在send()方法中指定一个Callback回调方法。kafka在返回响应的时候来调用该函数来实现异步的发送确认。如通过以下示例进行异步发送：

producer.send(record,((metadata, exception) -> {
            if(exception !=null){
                exception.printStackTrace();
            }else{
                System.out.println(metadata.topic()+"-" + metadata.offset() + "-" + metadata.partition());
            }
        }));

4、序列化器

生产需要使用序列化器（Serializer）把对象转化为字节数组才能通过网络发送个kafka。在对应的消费端，消费者则需要使用反序列化器（Deserializer)把从kafka中收到的字节数组转换成相应的java对象。示例中的key和value都使用了字符串。

kafka默认是实现的序列化器的实现如下：
在这里插入图片描述

序列化接口定义的几个方法如下

 default void configure(Map<String, ?> configs, boolean isKey) {
        // intentionally left blank
    }
    byte[] serialize(String topic, T data);

    default byte[] serialize(String topic, Headers headers, T data) {
        return serialize(topic, data);
    }
   @Override
    default void close() {
        // intentionally left blank
    }

configure方法是用来配置当前类的。serialize方法是用来执行序列操作的。而close方法是用来关闭当前的序列化器的，一般情况下close()是一个空方法。

5、分区器

消息在通过send()方法发往broker的过程中，有可能需要经过拦截器（interceptor)、序列器(serializer)及分区器(Partitioner)的一系列作用后才能被真正的发往broker.拦截器一般不是必需的，而序列化器是必需的 。消息经过序列化器后就要确定它发往的分区，如果消息（ProducerRecord）对象中指定了patition字段，那么不需要分区器，因为partition字段代表的就是其将要发送的分区号

可以通过org.apache.kafka.clients.producer.KafkaProducer#partitionsFor方法来获取一个主题目前所拥有的所有分区

如果没有指定，就使用配置的分区器来处理。以下代码是配置分区器的源码，这里配置是如果创建生产者实例的时候有配置分区器就使用配置的分区器，如果没有那么使用DefaultPartitioner进行分区。
在这里插入图片描述

this.partitioner = config.getConfiguredInstance(ProducerConfig.PARTITIONER_CLASS_CONFIG, Partitioner.class);

org.apache.kafka.clients.producer.Partitioner 接口定义如下：

    /**
     * Compute the partition for the given record.
     *
     * @param topic The topic name
     * @param key The key to partition on (or null if no key)
     * @param keyBytes The serialized key to partition on( or null if no key)
     * @param value The value to partition on or null
     * @param valueBytes The serialized value to partition on or null
     * @param cluster The current cluster metadata
     */
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster);

    /**
     * This is called when partitioner is closed.
     */
    public void close();

默认分区器选择分区的逻辑是：如果发送的消息（ProducerRecord）key值为空，那么就轮询所有分区。否则对key进行hash运算（采用murmur2算法，具备高性能，低碰撞性），根据获取到的hash值来选择对应的分区。源码如下所示：

    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        List<PartitionInfo> partitions = cluster.partitionsForTopic(topic);
        int numPartitions = partitions.size();
        if (keyBytes == null) {
            int nextValue = nextValue(topic);
            List<PartitionInfo> availablePartitions = cluster.availablePartitionsForTopic(topic);
            if (availablePartitions.size() > 0) {
                int part = Utils.toPositive(nextValue) % availablePartitions.size();
                return availablePartitions.get(part).partition();
            } else {
                // no partitions are available, give a non-available partition
                return Utils.toPositive(nextValue) % numPartitions;
            }
        } else {
            // hash the keyBytes to choose a partition
            return Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
        }
    }

如果需要自定义一个分区，可以实现partitioner接口。实现后可以通过如下代码进行配置

      properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,MyPartition.class.getName())

6、拦截器

拦截器是早在kafka 0.10.0.0中就已经引入的一个功能，kafka一共有两种拦截器：生产者拦截器和消费者拦截器。这里我们将着重的介绍生产者拦截器，后期介绍《kafka消费者详解》的时候将会介绍消费者拦截器。

生产者拦截器的即可以在消息发送前做一些准备工作，比如按照某个规则过滤不符合要求的消息、修改消息的内容等。也可以用来在发送回调逻辑前做一些定制化的需求。比如统计类的工作。

以下是一个拦截器实现的示例：


public class MyProducerInterceptor implements ProducerInterceptor<String,String> {
    private AtomicLong success = new AtomicLong();
    private AtomicLong fail = new AtomicLong();

    /**
     * 能够让我们可以在发送前修改消息的内容，但是没有办法做到取消该条消息的发送
     * @param record
     * @return
     */
    @Override
    public ProducerRecord<String, String> onSend(ProducerRecord<String, String> record) {
        return record;
    }

    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
        if (exception == null) {
            success.incrementAndGet();
            return;
        }
        fail.incrementAndGet();
    }
    @Override
    public void close() {
       double  successRatio =  (double)success.get()/(success.get() + fail.get());
        System.out.println("成功率：" + successRatio *100 + "%");
    }

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

    }
}

给是生产者配置拦截器：

     properties.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG,MyProducerInterceptor.class.getName());
张声录1
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
kafka生产者
M_Ene的学习日志
06-02 125
消息发送流程 kafka的Producer发送消息采用的是异步发送的方式。在消息发送的过程中，设计到了两个线程——main线程和Sender线程，以及一个线程共享变量——RecordAccumulator。main线程将消息发送给RecourdAccumulator，Sender线程不断从RecordAccumulator中拉去消息发送到kafka broker。 相关参数： batch.size：只有数据累积到batch.size之后，sender才会发送数据。 linger.ms：如果数据迟迟未达到b
Kafka 生产者（Producer）详解
qianyulin
01-08 6442
Producer : 消息生产者，就是向Kafka broker 发消息的客户端。 下面将从producer的分区策略，数据可靠性保证、Exactly Once、Producer API 来进行介绍。 1、分区策略 1）分区原因 方便在集群中扩展（相当于负载） ：每个Partition 可以通过调整以适应它所在的机...
kafka之生产者、消费者
言午玉口才
01-25 978
一、生产者 生成者是指消息的生成者，即将消息发送到指定的Topic中的生产者。生产者可以通过特定的分区函数决定消息路由到Topic的某个分区。 1、设计原则 生产者就是将消息发送到指定的Topic中。生产者本质上就是指定具体的Topic，然后向目的端Broker Server发送ProducerRequest请求，并且通过分区函数可以指定具体的消息至特定的分区。生产者内部会动态维护与Topi...
java Kafka生产者推送数据与消费者接收数据（参数配置以及案例）_java实现kafka消息发送和接收
最新发布
2401_84164721的博客
04-08 687
以上大数据开发知识点，真正体系化！**
Kafka生产者详解
mxk4869的博客
07-11 1903
Kafka生产者详解
Kafka 生产者
m0_56017821的博客
09-24 2381
kafka生产者原理 异步发送 分区 提高吞吐量 数据的可靠性 ack级别设置 数据重复问题 生产者事务 数据的有序和乱序
Kafka生产者详解.md
08-07
Kafka生产者详解，进阶篇
Kafka生产者详解（很细）
08-07
一、生产者发送消息的过程 二、创建生产者 二、发送消息 2.1 同步发送 2.2 异步发送 三、自定义分区器 四、生产者其他属性
大数据技术之Kafka详解
09-03
1. Producer：消息生产者，就是向 kafka broker 发消息的客户端。 2. Consumer：消息消费者，向 kafka broker 取消息的客户端。 3. Consumer Group（CG）：消费者组，由多个 consumer 组成。消费者组内每个消费者...
Kafka入门教程与详解
08-15
Kafka 集群中没有“中心主节点”的概念，集群中所有的服务器都是对等的，因此，可以在不做任何配置的更改的情况下实现服务器的添加与删除，同样的消息的生产者和消费者也能够做到随意重启和机器的上下线。...
Kafka篇——Kafka基本概念，命令行实现生产者和消费者，详细的介绍让你一遍拿下Kafka基本知识，保姆级教程！
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
01-07 1038
Kafka是一个分布式的流处理平台，主要用于发布和订阅实时数据流。以下是Kafka的基本概念：1. Producer（生产者）：负责将数据发布到Kafka集群中的特定主题（topic）。2. Consumer（消费者）：从Kafka集群中的特定主题中订阅数据，并进行相应的处理。3. Topic（主题）：一个主题可以被看作是一个数据流的类别或名称，用于区分不同类型的数据。4. Partition（分区）：一个主题可以被分为多个分区，每个分区可以在不同的服务器上。
Kafka个人笔记前篇
C_Xiang_Falcon的博客
09-16 592
Kafka个人总结一Kafka的概述消息队列的回顾消息队列消息队列的好处消息队列的两种模式Kafka的基础架构Kafka架构深入Kafka工作流程及文件存储机制Kafka生产者分区策略数据可靠性保证acks参数配置：故障处理细节Exactly Once语义(精确一次)Kafka消费者消费模式分区分配策略offset维护消费者组测试 Kafka的概述 kafka是一个分布式的消息队列,基于发布/订阅...
Kafka高级特性解析之生产者
凉茶铺的博客
12-05 971
对kafka生产者进行了详细的介绍
Kafka中的生产者详解
昨日的桥
01-04 636
Kafka中的生产者主要是用来向Kafka中写入消息。其包含的主要内容有如下个方面： 01、应用程序往Kafka中写入消息的场景 记录用户的活动（用于审计好分析）、记录度量指标、保存日志消息、记录智能家电的信息、与其他应用程序进行异步通信、缓冲即将写入到数据库的数据，等等。 02、Kafka发送消息的过程 1、创建ProducerRecord对象 2、使用send()发送ProducerRecor...
Kafka生产者简介
weixin_33928137的博客
06-20 284
Kafka 生产者 Kafka是分布式消息发布和订阅的消息系统。而生产者则对应的是消息的生产和发布。也就是说，生产者是消息的来源。生产者将消息发送搭kafka中。 ProducerRecord Kafka生产者发送的消息封装成ProduceRecord，其中包含了消息的主题和要发送的内容。 ProducerRecord对象有四个属性： Topic 消息的主题 Partition 消息也可以指定发...
kafka生产者总结(五)
coshise的专栏
05-20 4127
就今天我对kafka的生产做个总结，首先我们来看一下我们来看看通过java实现kafka生产者客户端向kafka集群发送消息的通用代码：public class Producer extends Thread {    private final KafkaProducer&lt;Integer, String&gt; producer;    private final String topic...
【kafka】一、kafka框架介绍（生产者篇）
lsr40的博客
11-13 1295
嗯，菜鸡是我，骄傲在败坏以先，狂心在跌倒之前。所以有什么说错的地方，还请大家指出批评！ 继爬虫之后，kafka的介绍。 该系列文章暂时更新两篇： 【kafka】一、kafka框架介绍（消费者篇）：https://blog.csdn.net/lsr40/article/details/84029034 【kafka】二、kafka框架介绍（消费者篇）：https://blog.csdn.ne...
Kafka源码解析（二）-消费者
qq_40344505的博客
06-12 2033
kafka消费者源码
kafka生产者消费者
12-01
以下是Kafka生产者和消费者的介绍和演示： 1. Kafka生产者 Kafka生产者将消息发布到主题中。以下是一个简单的Python示例，演示如何使用Kafka生产者API将消息发布到主题中： ```python from kafka import ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值