Kafka快速入门：Kafka驱动JavaApi的使用

已于 2024-08-20 23:52:53 修改
阅读量337 收藏 2
点赞数 3
分类专栏： Java 中间件 文章标签： kafka java
于 2024-08-20 13:48:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dxh9231028/article/details/141356436
版权

生产者和消费者是Kafka的核心概念之一，它们在客户端被创建和使用，并且包含了许多与Kafka性能和机制相关的配置。虽然Kafka提供的命令行工具能够执行许多基本操作，但它无法实现所有可能的性能优化。相比之下，使用Java API可以充分利用编程语言的灵活性，对生产者和消费者进行更精细的性能调优。对于大多数中间件，熟悉服务器的命令行操作可能足以帮助学习其API的使用。然而，Kafka则不同，要全面掌握Kafka的所有特性，必须系统地学习和理解其Java API。

1. 基础消费流程

在javaApi中可以通过创建一个Kafka生产者和消费者的配置对象，在new生产者或消费者的类时将配置对象传入，然后生产者实例通过调用send方法发送数据，消费者通过poll方法消费数据，数据需要通过ProducerRecords类封装key和value，并在生产者和消费者配置中为key和value指定序列化和反序列化类（key可以传null，key是在日志回收策略中发挥作用）。经过这样一套操作，消息就可以成功从生产者发往消费者。

package com.kafak.testkafka;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.time.Duration;
import java.util.Properties;

@SpringBootTest
class TestKafkaApplicationTests {

    //预定义Kafka对象实例，因为Kafka对象时线程安全，所以可以定义外面节省资源防止重复创建
    KafkaProducer<String, String> kafkaProducer;

    //创建生产者
    public KafkaProducer<String, String> getKafkaProducer() {

        //创建生产者配置
        Properties props = new Properties();
        //配置Kafka集群地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.142.30:9092,192.168.142.31:9092,192.168.142.32:9092");
        //配置序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        //返回生产者
        return new KafkaProducer<String, String>(props);
    }

    //创建消费者
    public KafkaConsumer<String, String> getKafkaConsumer() {
        //创建消费者配置
        Properties props = new Properties();
        //配置Kafka集群地址
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.142.30:9092,192.168.142.31:9092,192.168.142.32:9092");
        //配置消费者组id
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");
        //配置反序列化
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        //返回消费者
        return new KafkaConsumer<>(props);
    }

    //通过生产者生产一百条数据
    @Test
    void kafkaProducerTest() {
        //获取生产者
        kafkaProducer = getKafkaProducer();
        //发送消息
        for (int i = 0; i < 100; i++) {
            kafkaProducer.send(new ProducerRecord<String, String>("topicJava", "testKey" + i, "testValue" + i));
        }
    }

    //通过消费者消费消息
    @Test
    void kafkaConsumerTest() {
        //创建消费者，由于消费者是线程不安全，所以使用一次实例化一次，可以方式出现线程安全问题
        KafkaConsumer<String, String> kafkaConsumer = getKafkaConsumer();
        //接受消费者信息，传入100毫秒，消费者会一百毫秒拉去一次消息
        ConsumerRecords<String, String> records = kafkaConsumer.poll(Duration.ofMillis(100));
        // 处理消息
        for (ConsumerRecord<String, String> record : records) {
            System.out.printf("Consumed message with key %s, value %s, from partition %d with offset %d%n",
                    record.key(), record.value(), record.partition(), record.offset());
        }
    }

}

2. 消息确认

消息确认的原理性知识可以通过下面这篇文章学习，这里主要讲实操。

Kafka运行机制（二）：消息确认，消息日志的存储和回收icon-default.png?t=N7T8https://blog.csdn.net/dxh9231028/article/details/141329851?spm=1001.2014.3001.5501

生产者端

生产者端的消息确认策略由acks配置项控制，其由三种配置方式，其中我在下面这篇文章中详细讲述了相关知识。我们可以通过javaApi配置acks来控制确认策略。

生产者端的消息确认有同步和异步两种方式。

  • 同步消息确认：同步消息确认是生产者实例在调用send方法后紧接着调用get方法，该方法会阻塞线程的继续执行，等待消息发送结果。当消息发送失败时，如果配置了重试机制（通过设置 retries 属性），生产者会自动重试指定的次数。如果在所有重试尝试后仍然失败，最终会抛出异常，通知调用方消息发送失败。
  • 异步消息确认：异步消息确认通过生产者实例调用send方法时传入，第二个回调函数的参数。在成功或失败响应时，执行回调函数，异步消息确认不会阻塞代码，也不会触发自动重试。

消费者端

消费者消费成功在客户端的体现是成功获取到了数据，这本没有什么好说的，不过消费者不仅需要响应客户端数据，还要讲偏移量发送给Kafka，在这一过程中，消费者提供了手动提交和自动提交两种方式。启动自动提交是默认开启的，而手动提交则需要配置enable.auto.commit为false，然后通过创建分区和偏移量的映射关系，通过消费者的commit方法提交偏移量。

代码实现

下面代码中，我创建了四个测试单元，其中前两个测试单元，分别是生产者同步提交和异步提交，而后两个测试单元分别时消费者的自动提交和手动提交。

package com.kafak.testkafka;

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.common.TopicPartition;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

@SpringBootTest
class TestKafkaApplicationTests {
    //预定义Kafka对象实例，因为Kafka对象时线程安全，所以可以定义外面节省资源防止重复创建
    KafkaProducer<String, String> kafkaProducer;

    //创建生产者
    public KafkaProducer<String, String> getKafkaProducer() {
        //创建生产者配置
        Properties props = new Properties();

        //配置消息确认策略
        props.put(ProducerConfig.ACKS_CONFIG, "all");

        //配置重试次数
        props.put(ProducerConfig.RETRIES_CONFIG,3);

        //配置Kafka集群地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.142.30:9092,192.168.142.31:9092,192.168.142.32:9092");
        //配置序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        //返回生产者
        return new KafkaProducer<String, String>(props);
    }

    //创建消费者
    public KafkaConsumer<String, String> getKafkaConsumer(Boolean isAutoCommit) {
        //创建消费者配置
        Properties props = new Properties();
        //配置Kafka集群地址
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.142.30:9092,192.168.142.31:9092,192.168.142.32:9092");
        //配置消费者组id
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");
        //配置反序列化
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        //判断当前消费者是否开启自动提交
        if (!isAutoCommit) {
            //关闭自动提交
            props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        }else{
            //设置自动提交间隔时间1s
            props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");
        }
        //返回消费者
        return new KafkaConsumer<>(props);
    }

    //生产者同步确认
    @Test
    void kafkaProducerGetTest() {
        if(kafkaProducer == null) {
            kafkaProducer = getKafkaProducer();
        }
        //同步确认消息是否发送成功
        for (int i = 0; i < 100; i++) {
            try{
                RecordMetadata topicJava = kafkaProducer.send(new ProducerRecord<String, String>("topicJava", "testKey" + i, "testValue" + i)).get();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
        kafkaProducer.close();
    }
    
    //生产者异步确认
    @Test
    void kafkaProduceSyncTest() {
        if(kafkaProducer == null) {
            kafkaProducer = getKafkaProducer();
        }
        //异步确认是否发送成功
        for (int i = 0; i < 100; i++) {
            kafkaProducer.send(new ProducerRecord<String, String>("topicJava", "testKey" + i, "testValue" + i), (metadata, exception) -> {
                if (exception == null) {
                    System.out.printf("发送消息成功, metadata=%s%n", metadata);
                } else {
                    System.err.printf("发送消息失败, exception=%s%n", exception.getMessage());
                }
            });
        }
        kafkaProducer.close();
    }

    //消费者自动提交
    @Test
    void kafkaAutoCommitConsumerTest() {
        //创建消费者开启自动提交
        KafkaConsumer<String, String> kafkaConsumer = getKafkaConsumer(true);
        //消费数据流程中无需负责偏移量提交
        while (true) {
            //接受消费者信息，传入100毫秒，消费者会一百毫秒拉去一次消息
            ConsumerRecords<String, String> records = kafkaConsumer.poll(Duration.ofMillis(100));
            //处理消息
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("消息消费成功, key=%s, value=%s, partition=%d, offset=%d%n",
                        record.key(), record.value(), record.partition(), record.offset());
            }
        }
    }

    //消费者手动提交
    @Test
    void kafkaSyncCommitConsumerTest() {
        //创建消费者关闭自动提交
        KafkaConsumer<String, String> kafkaConsumer = getKafkaConsumer(false);
        //消费数据流程中需要在消费数据后，提交偏移量
        while (true) {
            //接受消费者信息，传入100毫秒，消费者会一百毫秒拉去一次消息
            ConsumerRecords<String, String> records = kafkaConsumer.poll(Duration.ofMillis(100));
            // 处理消息
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("消息消费成功, key=%s, value=%s, partition=%d, offset=%d%n",
                        record.key(), record.value(), record.partition(), record.offset());
                //创建分区和偏移量的映射类
                Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
                //讲分区和偏移量的数据存入映射类
                offsets.put(new TopicPartition(record.topic(), record.partition()),
                        new OffsetAndMetadata(record.offset() + 1));
                //偏移量提交
                kafkaConsumer.commitSync(offsets);
            }
        }
    }

}

3. 批处理

批处理在生产者端，和消费者端也有不同的实现。我在Kakfa基本概念一文中清楚的讲解了批处理的概念，文章如下

Kafka基本概念icon-default.png?t=N7T8https://blog.csdn.net/dxh9231028/article/details/141270920?spm=1001.2014.3001.5501

生产者

在生产者端，生产者实例的send方法会发送消息到缓冲区中，而缓冲区消息何时发送给Kafka集群，则是通过配置batch.size和linger.ms配置，来实现当缓冲区存入多少消息，和距离上一次发送消息多久后，来发送这一轮缓冲区的消息到Kafka集群，代码实现如下

    //创建生产者
    public KafkaProducer<String, String> getKafkaProducer() {
        //创建生产者配置
        Properties props = new Properties();

        //配置生产者批处理
        //缓冲区大小最大为16384比特
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        //距离上次发送消息时间隔3s
        props.put(ProducerConfig.LINGER_MS_CONFIG,"3000");
        
        //配置消息确认策略
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        //配置重试次数
        props.put(ProducerConfig.RETRIES_CONFIG,3);
        //配置Kafka集群地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.142.30:9092,192.168.142.31:9092,192.168.142.32:9092");
        //配置序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        //返回生产者
        return new KafkaProducer<String, String>(props);
    }

消费者

消费者端批处理，消费者在拉去消息时，会在fetch.max.bytes，max.partition.fetch.bytes和max.poll.records三个配置项，以及传入poll方法的超时时间参数的限制下，尽可能多的拉取更多消息。

  • fetch.max.bytes：fetch.max.bytes 是指 Kafka 消费者单次从服务器拉取数据时能够获取的最大字节数。这是全局的上限，控制每次 poll() 操作可以拉取的数据量总和。 默认值：50MB（即 52428800 字节）。
  • max.partition.fetch.bytes：max.partition.fetch.bytes 是指 Kafka 消费者从单个分区拉取消息时能获取的最大字节数，当消费者数量少于主题分区数量时，一个消费者可能会负责多个分区。默认值：1MB（即 1048576 字节）。
  • max.poll.records：max.poll.records 是指 Kafka 消费者每次调用 poll() 方法时能够拉取的最大消息条数。 默认值：500 条消息。

代码实现如下

    //创建消费者
    public KafkaConsumer<String, String> getKafkaConsumer(Boolean isAutoCommit) {
        //创建消费者配置
        Properties props = new Properties();

        //消费者批处理相关配置
        //消费缓冲区大小，也就是一次消费最多能消费多少比特消息
        props.put(ConsumerConfig.FETCH_MAX_BYTES_CONFIG,16384);
        //一次消费一个分区最多能消费多少比特
        props.put(ConsumerConfig.MAX_PARTITION_FETCH_BYTES_CONFIG,8192);
        //一次消费最多能消费多少条数据
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG,1000);

        //配置Kafka集群地址
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.142.30:9092,192.168.142.31:9092,192.168.142.32:9092");
        //配置消费者组id
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");
        //配置反序列化
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        //判断当前消费者是否开启自动提交
        if (!isAutoCommit) {
            //关闭自动提交
            props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        }else{
            //设置自动提交间隔时间1s
            props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");
        }
        //返回消费者
        return new KafkaConsumer<>(props);
    }

4. 事务操作

Kafka驱动支持事务操作，允许许生产者在多个主题和分区上以原子方式写入消息。这意味着你可以确保一组消息要么全部成功写入Kafka，要么全部失败。

事务操作首先通过生产者实例调用生产者实例的initTransactions方法，向kafka集群申请一个映射当前生产者的事务Id，然后就可以通过调用生产者实例的beginTransaction方法，开启一个事务，进行消息发送，最终通过调用commitTransaction方法完成事务的提交，如果中途发生异常则通过abortTransaction对当前事务进行回滚，代码实例如下

package com.kafak.testkafka;

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.common.TopicPartition;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

@SpringBootTest
class TestKafkaApplicationTests {
    //预定义Kafka对象实例，因为Kafka对象时线程安全，所以可以定义外面节省资源防止重复创建
    KafkaProducer<String, String> kafkaProducer;

    //创建生产者
    public KafkaProducer<String, String> getKafkaProducer() {
        //创建生产者配置
        Properties props = new Properties();
        //配置生产者批处理
        //缓冲区大小最大为16384比特
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        //距离上次发送消息时间隔3s
        props.put(ProducerConfig.LINGER_MS_CONFIG,"3000");
        //配置消息确认策略
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        //配置重试次数
        props.put(ProducerConfig.RETRIES_CONFIG,3);
        //配置Kafka集群地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.142.30:9092,192.168.142.31:9092,192.168.142.32:9092");
        //配置序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        //返回生产者
        return new KafkaProducer<String, String>(props);
    }



    //测试事务
    @Test
    void kafkaProducerTransactionTest() {
        if(kafkaProducer == null) {
            kafkaProducer = getKafkaProducer();
        }
        kafkaProducer.initTransactions();
        try{
            kafkaProducer.beginTransaction();
            //消息发送相关操作
            for (int i = 0; i < 100; i++) {
                try{
                    RecordMetadata topicJava = kafkaProducer.send(new ProducerRecord<String, String>("topicJava", "testKey" + i, "testValue" + i)).get();
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
            kafkaProducer.commitTransaction();
        }catch (Exception e) {
            e.printStackTrace();
            kafkaProducer.abortTransaction();
        }
        kafkaProducer.close();
    }

    

}

5. 自定义分区器

Kafka允许用户自定义分区器，实现特定的分区策略。可以通过实现Partitioner接口来创建自定义分区器。实现Partitioner接口需要实现三个方法，分别是partition，configure，close。

partition方法

partition方法是实现分区逻辑其的主要方法，其接受六个参数，分别是

  • String topic：消息要发送到的Kafka主题名称
  • Object key：消息的 key，可能为 null。
  • byte[] keyBytes：序列化后的 key，可能为 null
  • Object value：消息的 value，可以为任意对象
  • byte[] valueBytes：序列化后的 value，可能为 null。
  • Cluster cluster：Kafka集群的元数据信息，包括主题的分区数、每个分区的领导者等

partition方法的返回值则是发送分区的编号，通过这个机制可以实现不同逻辑的分区器。

configure方法

configuer方法在自定义分区类初始化时调用，当设计一些复杂操作，比如在发送消息前要和数据库交互时，可以在configure中完成数据库的连接。

close方法

close在分区逻辑执行完后调用，和configure一样，在复杂操作时，用于关闭分区逻辑中创建的连接，或一些内存资源等

假设我有一个三主机集群，其中30主机性能最好，31其次，32最差，我要通过自定义分区，将消息发送到三个分区的比例为3：2：1，通过Partitioner接口，可以简单的通过如下方式实现

package com.kafak.testkafka;

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import org.apache.kafka.common.Node;
import org.apache.kafka.common.PartitionInfo;

import java.util.List;
import java.util.Map;

public class CustomPartitioner implements Partitioner {

    @Override
    public int partition(String s, Object o, byte[] bytes, Object o1, byte[] bytes1, Cluster cluster) {
        //获取分区元数据
        List<PartitionInfo> partitionInfos = cluster.partitionsForTopic(s);
        //创建一个0-100的随机数
        double num = Math.random() * 100;
        //默认传递分区号
        Integer finalPartition = 0;
        for (PartitionInfo partitionInfo : partitionInfos) {
            //获取分区的leader
            Node leader = partitionInfo.leader();
            //获取分区leader的ip和端口
            String leaderAddress = leader.host() + ":" + leader.port(); // 生成 "host:port" 格式的字符串
            //如果随机数在0-50之间，发送消息至192.168.142.30:9092
            if (num < 50 && leaderAddress.equals("192.168.142.30:9092")) {
                finalPartition = partitionInfo.partition();
                break; 
            //如果随机数在50-82之间，发送消息至192.168.142.31:9092
            } else if (num < 82 && num >= 50 && leaderAddress.equals("192.168.142.31:9092")) {
                finalPartition = partitionInfo.partition();
                break;
            //如果随机数在82-100之间，发送消息至192.168.142.32:9092
            } else if (num < 100 && num >= 82 && leaderAddress.equals("192.168.142.32:9092")) {
                finalPartition = partitionInfo.partition();
                break;
            }
        }
        //返回最终分区号
        return finalPartition;
    }


    @Override
    public void close() {

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

    }
}

在生产者配置中通过partitioner_class配置自定义分区器，代码如下

 public KafkaProducer<String, String> getKafkaProducer() {
        //创建生产者配置
        Properties props = new Properties();
        
        //启用自定义分区器
        props.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"com.kafak.testkafka.CustomPartitioner");
        
        //配置生产者批处理
        //缓冲区大小最大为16384比特
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        //距离上次发送消息时间隔3s
        props.put(ProducerConfig.LINGER_MS_CONFIG,"3000");
        //配置消息确认策略
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        //配置重试次数
        props.put(ProducerConfig.RETRIES_CONFIG,3);
        //配置Kafka集群地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.142.30:9092,192.168.142.31:9092,192.168.142.32:9092");
        //配置序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        //返回生产者
        return new KafkaProducer<String, String>(props);
    }

如此，便可以实现一个自定义分区策略。 

不止会JS
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
从小白的角度讲解kafka并使用java、python_API实战
weixin_43178406的博客
04-29 5万+
1. 什么是kafka 1.1 基本概述 1.2 深度讲解 2. kafka的安全机制 3. python_API 3.1 作为生产者连接kafka并发送数据
kafka学习之一java api的使用
热门推荐
liushangzaibeijing的博客
12-22 4万+
本篇博文介绍了kafka在java环境的api使用，主要提供了三种方式 1、单纯的api调用kafka生产消费、2、spring整合kafka 3、springBoot整合kafka，是一篇不错的java使用kafka的示例，需要读者收藏以便以后使用。
基于Java API 方式使用Kafka
m0_59839948的博客
06-09 1752
基于Java API 方式使用Kafka
kafka快速入门
赵广陆
02-17 2907
目录1 kafka1.1 kafka介绍1.2 kafka安装和配置1.2.1 jdk环境1.2.2 zookeeper安装1.2.3 kafka安装1.3 kafka入门案例1.3.1 创建工程kafka-demo1.3.2 消息生产者1.3.3 消息消费者1.3.4 测试及结论-重要1.3.5 相关概念再介绍1.3.5 生产者详解-理解1.3.6 消费者详解-理解1.4 spring boot集成kafka收发消息1.4.1 环境搭建1.4.2 消息生产者1.4.3 消息消费者1.4.4 测试1.5 传
Java代码使用kafka api报错：java.net.UnknownHostException: xxxxxxx 解决
codecho的博客
11-18 4304
解决：修改kafka的server.properties文件 sudo vi /kafka安装路径/config/server.properties 去除下面这行配置的注释，并设置ip地址 advertised.listeners=PLAINTEXT://ip地址:9092 ...
Flink+Kafka的JavaAPI应用
05-30
此案例使用的是IDEA开发工具，项目...使用JavaAPI操作Flink的流处理，Flink从Kafka中获取数据，执行处理后再执行输出。 根据（《Flink入门与实战》徐葳著）教材最后的综合案例改变，适合没有学习不会使用Flume的人使用
KafkaDemo:kafka Java API
05-18
#Kafka Java API案例Producer可选配置，如果不配置，则使用默认的partitioner根据key值value映射到指定的Parition props.put("partitioner.class", "kafka.demo.PartitionerDemo");ConsumerString key=(String)obj; ...
2、java调用kafka api
05-29
在Java中调用Apache Kafka API是一项关键任务，特别是在构建分布式数据处理系统时。Apache Kafka是一个高性能、可扩展的消息队列（MQ），它提供实时的数据流处理能力。在Java应用程序中集成Kafka API可以让开发者...
TimingWheel:Kafka时轮的Java实现
05-02
- 时钟分辨率：取决于Java的定时器API，如`ScheduledExecutorService`，影响时轮的最小时间单位。 6. **优化与挑战** - 并发处理：在高并发场景下，需要考虑线程安全，确保时轮旋转和任务操作的正确性。 - 扩...
Simple-Kafka:易于使用的 Apache Kafka Java API 包装器和实现
06-04
Simple-Kafka 旨在为生产者和消费者提供一个更简单的 Java API。 因此，对 Apache Kafka 知之甚少的人可以轻松地将这个实时消息传递系统集成到他们的项目中。 主要特征 1 : 更简单的Java Producer API，其实现和...
深入理解Kafka消费者偏移量管理：如何确保事件已处理
heromps的博客
08-20 409
本文将深入探讨Kafka中消费者如何通过偏移量机制确认事件已被处理，并介绍不同的偏移量提交策略及其优缺点。根据具体需求选择合适的偏移量提交策略，可以在提高处理性能的同时保证消息的可靠处理。当消费者重新启动时，Kafka会根据最后提交的偏移量继续消费未处理的消息。通过批量处理消息并在处理完成后一次性提交偏移量，可以减少提交次数，提高性能，同时避免在处理单条消息失败时丢失多条消息。在每条消息处理完成后立即提交其偏移量，可以确保消息处理与偏移量提交紧密关联，即使在系统崩溃后也不会丢失已处理的消息。
Kafka基本概念介绍
weixin_41992498的博客
08-20 802
也可以采用轮询的方式进行消息发送到分区；顺序写入：kafka会把收到的消息写入磁盘，保证数据不丢失，一般情况下，写数据到磁盘经历磁盘寻址和写入，而对磁盘而言，寻址是机械动作，效率很低；（2）没有限制：生产者写入消息，消费者可能被多个消费者消费，消消费消息的偏移量，消息可以长时间保息服务器仅仅是保存消费者存，每个消费者之间互不影响，在大数据场景使用多。如果是，则product发送后马上flush磁盘，称为同步发送（sync），如果否，则发送后立即返回，由操作系统去flush磁盘，称为（async）；
ActiveMQ、RabbitMQ、Kafka、RocketMQ在事务性消息、性能、高可用和容错、定时消息、负载均衡、刷盘策略的区别
猪猪
08-16 1151
ActiveMQ、RabbitMQ、Kafka、RocketMQ这四种消息队列在事务性消息、性能、高可用和容错、定时消息、负载均衡、刷盘策略等方面各有其特点和差异。
ActiveMQ、RabbitMQ、Kafka、RocketMQ在优先级队列、延迟队列、死信队列、重试队列、消费模式、广播模式的区别
猪猪
08-16 1095
ActiveMQ、RabbitMQ、Kafka、RocketMQ这四款消息队列在优先级队列、延迟队列、死信队列、重试队列、消费模式、广播模式等方面各有其特点和差异。
鲲鹏服务器安装Kafka
最新发布
Angushine的专栏
08-20 248
由于项目需求，需要在鲲鹏云主机上安装Kafka，并且要求安装的版本为2.3.X。下面主要从以下几个步骤说明如何安装：1、下载kafka的安装文件2、上传到服务器3、修改配置4、启动5、使用工具测试。
ActiveMQ、RabbitMQ、Kafka、RocketMQ在消息回溯、消息堆积+持久化、消息追踪、消息过滤的区别
猪猪
08-16 930
ActiveMQ、RabbitMQ、Kafka、RocketMQ在消息回溯、消息堆积+持久化、消息追踪、消息过滤等方面各有其独特的特点和优势。
ActiveMQ、RabbitMQ、Kafka、RocketMQ的区别简介
猪猪
08-16 1023
ActiveMQApache推出的一款开源消息中间件，完全支持JMS 1.1和J2EE 1.4规范。实现高可用、高性能、可伸缩、易用和安全的企业级面向消息服务的系统。RabbitMQ使用Erlang语言开发的基于AMQP标准的开源实现。在分布式系统中用于存储转发消息，表现出良好的易用性、扩展性和高可用性。Kafka源自领英，后贡献给Apache的顶级开源项目，采用Scala语言编写。以高吞吐量和持久性为设计目标，适用于大规模数据流处理。RocketMQ。
【消息队列与事件驱动架构】使用RabbitMQ、Kafka等工具实现消息队列与事件驱动架构
weixin_39372311的博客
08-20 455
消息队列（Message Queue）是一种用于在不同系统或服务之间传递消息的机制。它允许发送方将消息放入队列，接收方从队列中获取消息，从而实现异步通信。消息队列的主要作用是解耦服务，确保消息的可靠传递，并支持异步处理。事件驱动架构（Event-Driven Architecture, EDA）是一种系统设计模式，通过事件的发布和订阅机制实现服务之间的松耦合。每当一个事件发生时，系统会将该事件发布给订阅该事件的服务，服务再根据事件进行相应的处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不止会JS

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值