Kafka Java 客户端使用

最新推荐文章于 2024-07-30 11:28:03 发布
最新推荐文章于 2024-07-30 11:28:03 发布
阅读量353 收藏 1
点赞数
文章标签： kafka kafka-clients spring-kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36160730/article/details/106728692
版权

文章目录

1. 常用配置

生产者

配置描述类型默认值
bootstrap.servers用于建立与kafka集群的连接，仅影响用于初始化的hosts，来发现全部的servers。
格式：host1:port1,host2:port2,…，数量尽量不止一个，以防其中一个down了。		list
acks生产者要求Leader在确认请求完成之前已收到的确认数。
acks = 0：如果设置为零，那么生产者将完全不等待服务器的任何确认。 该记录将立即添加到套接字缓冲区中并视为已发送。 在这种情况下，不能保证服务器已收到记录，并且重试配置不会生效（因为客户端通常不会知道任何故障）。 为每个记录提供的偏移量将始终设置为-1。
acks = 1：这将意味着Leader会将记录写入其本地日志，但会在不等待所有Followers的完全确认的情况下做出响应。 在这种情况下，如果领导者在确认记录后立即失败，但在追随者复制记录之前失败，则记录将丢失。
acks=all 或 acks=-1：这意味着Leader将等待完整的同步副本集确认记录。 这保证了只要至少一个同步副本仍处于活动状态，记录就不会丢失。 这是最有力的保证。		string1
request.timeout.ms客户端等待请求响应的最长时间。如果超时之前仍未收到响应，则客户端将在必要时重新发送请求，如果重试已用尽，则会使请求失败。int30000
retries请求失败时重试次数。int2147483647
batch.size批次大小，批次就是一组消息，这些消息属于同一个主题和分区，把消息分成批次传输可以减少网络开销。int163834
linger.ms发送时延，即发送消息时，生产者等待给定的延迟，才允许发送，以便可以聚合更多的消息。long0
buffer.memory生产者可以用来缓冲等待发送到服务器的记录的总内存字节，即生产者所管理的最大内存。 如果记录的发送速度超过了将记录发送到服务器的速度，则生产者将阻塞max.block.ms，此后它将引发异常。long33554432
key.serializer消息key序列化方式class
value.serializer消息本身的序列化方式class

消费者

配置描述类型默认值
bootstrap.servers用于建立与kafka集群的连接，仅影响用于初始化的hosts，来发现全部的servers。
格式：host1:port1,host2:port2,…，数量尽量不止一个，以防其中一个down了。		list
group.id消费者所属消费组的唯一标识stringnull
enable.auto.commit如果为true，则消费者的offset将在后台定期提交。booleantrue
auto.commit.interval.ms如果将enable.auto.commit设置为true，则消费者offset自动提交给Kafka的频率（以毫秒为单位）。int5000
session.timeout.ms检测消费者是否失效的超时时间，该值必须在group.min.session.timeout.ms和group.max.session.timeout.ms允许范围内。int10000
group.min.session.timeout.ms检测消费者是否失效的超时最小时间。int6000
group.max.session.timeout.ms检测消费者是否失效的超时最大时间。int1800000
key.deserializer消息key反序列化方式class
value.deserializer消息value反序列化方式class

2. kafka-clients

添加依赖

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

2.1 生产者

同步发送消息

KafkaProducer是线程安全的，可以在多个线程之间共享生产者实例。

@Test
public void syncProducer() {
    Properties properties = new Properties();
    properties.put("bootstrap.servers", "192.168.110.40:9092,192.168.110.40:9093,192.168.110.40:9094");
	properties.put("acks", "all");
    properties.put("retries", 0);
    properties.put("batch.size", 16384);
    properties.put("buffer.memory", 33554432);
    properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

    KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

    // 同步发送消息，发送10条
    for (int i = 1; i <= 10; i++) {
        kafkaProducer.send(new ProducerRecord<>("java-client-test", "test,test,test " + i));
    }

    try{
        // 同步发送消息，可获取RecordMetadata，服务器已确认记录的元数据
        Future<RecordMetadata> future = kafkaProducer.send(new ProducerRecord<>("java-client-test", "test,test,test"));
        RecordMetadata recordMetadata = future.get();
        System.out.printf("RecordMetadata : topic = %s, partition = %d, offset = %d, toString() = %s\n",
                recordMetadata.topic(),recordMetadata.partition(),recordMetadata.offset(),recordMetadata.toString());
    } catch(Exception e) {
        // 连接错误、No Leader错误都可以通过重试解决
        // 消息太大这类错误kafkaProducer不会进行任何重试，直接抛出异常
        e.printStackTrace();
    }

    kafkaProducer.close();
}

异步发送消息

发送消息时，传递一个回调对象

@Test
public void producer() {
    Properties properties = new Properties();
    properties.put("bootstrap.servers", "192.168.110.40:9092,192.168.110.40:9093,192.168.110.40:9094");
	properties.put("acks", "all");
    properties.put("retries", 0);
    properties.put("batch.size", 16384);
    properties.put("buffer.memory", 33554432);
    properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

    KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

    // 异步发送消息，发送10条
    for (int i = 1; i <= 10; i++) {
        // 发送消息时，传递一个回调对象
        kafkaProducer.send(new ProducerRecord<>("java-client-test", "test,test,test " + i), new Callback() {
            @Override
            public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                System.out.printf("ProducerCallback RecordMetadata : topic = %s, partition = %d, offset = %d, toString() = %s\n",
                        recordMetadata.topic(),recordMetadata.partition(),recordMetadata.offset(),recordMetadata.toString());

                // 如果Kafka返回一个错误，onCompletion方法抛出一个non null异常。
                if (e != null) {
                    // 对异常进行一些处理，这里只是简单打印出来
                    e.printStackTrace();
                }
            }
        });
    }

    kafkaProducer.close();
}

2.2 消费者

KafkaConsumer 是线程不安全的。

@Test
public void consumer() {
	Properties properties = new Properties();
	properties.put("bootstrap.servers", "192.168.110.40:9092,192.168.110.40:9093,192.168.110.40:9094");
	properties.put("group.id", "test");
	properties.put("enable.auto.commit", "true");
	properties.put("auto.commit.interval.ms", "1000");
	properties.put("session.timeout.ms", "30000");
	properties.put("key.deserializer","org.apache.kafka.common.serialization.StringDeserializer");
	properties.put("value.deserializer","org.apache.kafka.common.serialization.StringDeserializer");

	KafkaConsumer<String, String> consumer = new KafkaConsumer<>(properties);
	
	consumer.subscribe(Arrays.asList("java-client-test"));

	try{
		while (true) {
			// 间隔100ms去拉取数据
			ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
			for (ConsumerRecord<String, String> record : records){
				System.out.printf("消费 : topic = %s, partition = %d, offset = %d, value = %s\n",
						record.topic(),record.partition(),record.offset(), record.value());
			}
		}
	}finally {
		consumer.close();
	}
}

2.3 多线程

生产者
将生产者定义为一个工具类

public class BaseProducer {

    private static KafkaProducer<String, String> kafkaProducer;

    static {
        Properties properties = new Properties();
        properties.put("bootstrap.servers", "192.168.110.40:9092,192.168.110.40:9093,192.168.110.40:9094");
        properties.put("acks", "all");
        properties.put("retries", 0);
        properties.put("batch.size", 16384);
        properties.put("buffer.memory", 33554432);
        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        kafkaProducer = new KafkaProducer<>(properties);

        Runtime.getRuntime().addShutdownHook(new Thread() {
            public void run() {
                BaseProducer.kafkaProducer.close();
            }
        });
    }

    public static void send(String content, String... topics){
        if (topics != null && topics.length > 0) {
            for (int i = 0;i < topics.length; i++) {
                System.out.println("send " + topics[i] + " message " + content);
                kafkaProducer.send(new ProducerRecord<>(topics[i], content));
            }
        }
    }
}

多线程消费者
实现Runnable，定义一个抽象的消费者，每个线程里面都有一个KafkaConsumer。

public abstract class AbstractConsumer implements Runnable {

    protected KafkaConsumer<String, String> consumer;

    protected String topic;

    public AbstractConsumer(String topic) {
        this.topic = topic;
    }

    /**
     * 创建消费者，订阅topic
     */
    private void connect() {
        Properties properties = new Properties();
        properties.put("bootstrap.servers", "192.168.110.40:9092,192.168.110.40:9093,192.168.110.40:9094");
        properties.put("group.id", "test-user");
        properties.put("enable.auto.commit", "false");
        properties.put("session.timeout.ms", "30000");
        properties.put("key.deserializer","org.apache.kafka.common.serialization.StringDeserializer");
        properties.put("value.deserializer","org.apache.kafka.common.serialization.StringDeserializer");

        consumer = new KafkaConsumer<>(properties);
        consumer.subscribe(Arrays.asList("topic-user"));
    }

    @Override
    public void run() {
        this.connect();

        while(true) {
            try {
                ConsumerRecords<String, String> consumerRecords = this.consumer.poll(Duration.ofMillis(500));
                Iterator iterator = consumerRecords.iterator();
                while(iterator.hasNext()) {
                    ConsumerRecord<String, String> item = (ConsumerRecord)iterator.next();
                    this.handler(item.value());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void handler(String message) {
        this.consumer.commitAsync();
    }

}

继承AbstractConsumer，实现handler()方法，在里面进行消息的消费。

public class UserConsumer extends AbstractConsumer {

    public UserConsumer(String topic) {
        super(topic);
    }

    @Override
    public void handler(String message) {
        try {
            // 消费数据
            List<User> userList = JSON.parseObject(message, new TypeReference<List<User>>(){});

            if (!userList.isEmpty()) {
                for (User user : userList) {
                    System.out.println(user);
                }
            }

            this.consumer.commitAsync();
        }catch (Exception e) {
            this.consumer.commitAsync();
            e.printStackTrace();
        }

    }
}

消费者组，定义线程池

public class UserConsumerGroup {

    private List<Runnable> consumerThreadList = new ArrayList<>();

    public UserConsumerGroup() {
        consumerThreadList.add(new UserConsumer("topic-user"));
    }

    public void start() {
        ThreadFactory factory = r -> new Thread(r, "ThreadPool thread: UserConsumerGroup");
        // 核心线程池大小；最大线程池大小；线程最大空闲时间；时间单位；线程等待队列；线程创建工厂
        ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 200, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(3), factory);
        for (Runnable item : consumerThreadList) {
            executor.execute(item);
        }
        executor.shutdown();
    }
}

3. spring-kafka

SpringBoot 2.3.0，spring-kafka 2.5.0

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>

application.yml

spring:
  kafka:
    bootstrap-servers: 192.168.110.40:9092,192.168.110.40:9093,192.168.110.40:9094
    producer:
      acks: all
      retries: 0
      batch-size: 16384
      buffer-memory: 33554432
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer:
      group-id: spring-test
      enable-auto-commit: true
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      properties:
        auto.commit.interval.ms: 1000
        session.timeout.ms: 30000

生产者

@Component
public class Producer {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    /**
     * 同步
     * @param topic
     */
    public void syncSend(String topic){
        for (int i = 1; i <= 10; i++) {
            ListenableFuture<SendResult<String, String>> future = kafkaTemplate.send(topic, "test,test,test " + i);

            try {
                SendResult<String, String> sendResult = future.get();
                ProducerRecord<String, String> producerRecord = sendResult.getProducerRecord();
                System.out.printf("Sync ProducerRecord : topic = %s, partition = %d, toString() = %s\n",
                        producerRecord.topic(),producerRecord.partition(),producerRecord.toString());

                RecordMetadata recordMetadata = sendResult.getRecordMetadata();
                System.out.printf("Sync RecordMetadata : topic = %s, partition = %d, offset = %d, toString() = %s\n",
                        recordMetadata.topic(),recordMetadata.partition(),recordMetadata.offset(),recordMetadata.toString());
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 异步
     * @param topic
     */
    public void asyncSend(String topic){
        for (int i = 1; i <= 10; i++) {
            ListenableFuture<SendResult<String, String>> future = kafkaTemplate.send(topic, "test,test,test " + i);
            future.addCallback(new ListenableFutureCallback<SendResult<String, String>>() {
                @Override
                public void onFailure(Throwable ex) {
                    ex.printStackTrace();
                }

                @Override
                public void onSuccess(SendResult<String, String> result) {
                    ProducerRecord<String, String> producerRecord = result.getProducerRecord();
                    System.out.printf("Async ProducerRecord : topic = %s, partition = %d, toString() = %s\n",
                            producerRecord.topic(),producerRecord.partition(),producerRecord.toString());

                    RecordMetadata recordMetadata = result.getRecordMetadata();
                    System.out.printf("Async RecordMetadata : topic = %s, partition = %d, offset = %d, toString() = %s\n",
                            recordMetadata.topic(),recordMetadata.partition(),recordMetadata.offset(),recordMetadata.toString());
                }
            });
        }
    }

}

消费者，这个并发3，启动3个线程

@Component
public class Consumer {
	@KafkaListener(topics = "spring-topic", concurrency = "3")
	public void listen (ConsumerRecord<?, ?> record) {
		System.out.printf("消费 : topic = %s, partition = %d, offset = %d, value = %s\n",
				record.topic(),record.partition(),record.offset(),record.value());
	}
}

参考：
Kafka 官方文档
kafka-clients介绍
kafka-clients API文档 KafkaConsumer
创建多线程Kafka消费者
spring-kafka 官方文档

shpunishment
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Kafka的Java客户端
HRX98的博客
03-04 1642
Kafka的Java客户端-demo版 0. 订单类 package com.hao.entity; public class Order { private Long orderId; private int count; public Order(Long orderId, int count) { this.orderId = orderId; this.count = count; } public Order() {
Kafka客户端使用
Dustin_CDS的博客
03-04 1万+
Consumer客户端 1 消费者模型 在开始编码之前， 我们先回顾一下一些基本概念。 在Kafka中， 每个topic被分成一组称为Partitions的logs。 Producer向这些logs的末尾写入消息， Consumer则自己按自己的节奏读取log。 Kafka通过在一个Consumer Group中分配Partitions来伸缩topic的消费， Consumer Group...
kafka java 客户端
Pichairen
01-17 2035
参考：kafka——AdminClient API - 简书 1、AdminClient API <dependencies> <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka-clients</artifactId> <version>2.7
【Kafka】对 kafka 消费程序客户端进行监控采集
最新发布
Mrerlou的博客
07-30 825
对于 Kafka 组件而言，我们通常会对 kafka 服务端添加一些监控，来确保服务的稳定性，虽然有 kafka-exporter 来对消费者进行监控，但是指标很少，对于生产者和消费者更细粒度的监控就无法做到了。只能将监控部署在客户端上，这样我们就能拿到更加详细的监控数据。例如：对于消费者来说，我们可以获取到消费者重平衡次数，每次poll 数据的条数等等。这里梳理下如何对消费者添加 JMX 监控。
kafka的java客户端-生产者
拒绝熬夜啊的博客
06-29 1417
kafka的java客户端-生产者
Kafka使用Java客户端进行访问的示例代码
08-29
本篇文章主要介绍了Kafka使用Java客户端进行访问的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
kafka之java客户端实战
weixin_43134177的博客
01-13 1465
Producer可选的属性都可以由ProducerConfig类管理。比如ProducerConfig.BOOTSTRAP_SERVERS_CONFIG属性，显然就是指发送者要将消息发到哪个Kafka集群上。这是每个Producer必选的属性。在ProducerConfig中，对于大部分比较重要的属性，都配置了对应的DOC属性进行描述。Kafka的消息是一个Key-Value结构的消息。其中，key和value都可以是任意对象类型。
Kafka-Java客户端数据生产流程解析，从发送类型实现代码到序列化器实现代码！
2401_84415615的博客
04-19 1219
**自定义序列化器*/@Override@Overridetry {= null) {} else {= null) {} else {@Override使用自定义的序列化器Company company = Company.builder().name(“kafka”) .address(“北京”).build();
kafka：java集成 kafka(springboot集成、客户端集成)
积水成多，水到渠成
03-13 5515
对于java的kafka集成，一般选用springboot集成kafka，但可能由于对接方kafka老旧、kafka不安全等问题导致kafak版本与spring版本不兼容，这个时候就得自己根据kafka客户端api集成了。
Java中的几种Kafka客户端比较介绍
wdj_yyds的博客
01-23 3803
在这篇博客中，我介绍了在Java中定义Kafka消费者的各种方法。Spring、Micronaut、Vert.x和Akka Streams在引擎盖下使用kafka-clients库，并提供完整的功能集来消费Kafka消息。 Kafka 是一个著名的事件流平台。我们在很多项目中使用它。没什么不寻常的——工具很棒。各种框架和库提供与 Kafka 的集成。在这篇文章中，我想介绍其中一些 Java 语言，看看我们如何创建一个客户实例，用来读取Kafka消息： 连接到 Kafka 的第一种方法是使用kafka-.
【Kafka】2.在SpringBoot中使用官方原生java版Kafka客户端
yuhuofei的草屋
08-14 1172
使用官方原生java版Kafka客户端
java操作kafka
08-12
java操作kafka，实现生产者，消费者
kafka 客户端
12-11
kafka消息队列 监控界面 内含分区选择，topic选择，消息查看发送。操作简便。直接启动jar即可。
java kafka client_Kafka Java Client基本使用及整合SpringBoot
weixin_39704727的博客
02-16 497
kafka-clients添加依赖org.apache.kafkakafka-clients2.5.0消费者 Consumer代码上总体可以分为三部分：消费者的配置消费者的配置在 org.apache.kafka.clients.consumer.ConsumerConfig 类中都有列举包括每个配置项的文档说明创建消费者实例并订阅topic消费消息代码如下：// 1. 配置Properties ...
Kafka : Kafka入门教程和JAVA客户端使用
热门推荐
shangmingtao的博客
03-15 6万+
目录 目录 Kafka简介 环境介绍 术语介绍 消费模式 下载 集群安装配置 命令使用 JAVA实战 参考文献 Kafka简介 由Scala和Java编写,Kafka是一种高吞吐量的分布式发布订阅消息系统. 环境介绍 操作系统:centos6.5 kafka:1.0.1 zookeeper:3.4.6 术语介绍 Broker : Kafka集群包含一个或...
使用Kafka客户端(spring-kafka)的Java API操作Kafka的Topic
zhangbeizhen18的博客
06-17 4277
记录：458 场景：在Spring Boot微服务集成Kafka客户端spring-kafka-2.8.2操作Kafka的Topic的创建和删除。
kafka的java客户端_Kafka使用Java客户端进行访问-Go语言中文社区
weixin_42149153的博客
02-21 107
本文环境如下：操作系统：CentOS 6 64位JDK版本：1.8.0_171 64位Kafka版本：kafka_2.12-2.1.11. maven依赖包org.apache.kafkakafka_2.122.1.12. 生产者代码import org.apache.kafka.clients.producer.KafkaProducer;import org.apache.kafka.clie...
使用Kafka客户端(kafka-clients)的Java API操作Kafka的Topic
zhangbeizhen18的博客
06-17 3714
记录：460 场景：在Spring Boot微服务集成Kafka客户端kafka-clients-3.0.0操作Kafka的Topic的创建和删除。
Kafka学习 — 2 kafka生产者客户端（Java）_java 作为kafka客户端如何写
2401_84689803的博客
05-12 775
小编也是很有感触，如果一直都是在中小公司，没有接触过大型的互联网架构设计的话，只靠自己看书去提升可能一辈子都很难达到高级架构师的技术和认知高度。向厉害的人去学习是最有效减少时间摸索、精力浪费的方式。我们选择的这个行业就一直要持续的学习，又很吃青春饭。虽然大家可能经常见到说程序员年薪几十万，但这样的人毕竟不是大部份，要么是有名校光环，要么是在阿里华为这样的大企业。年龄一大，更有可能被裁。送给每一位想学习Java小伙伴，用来提升自己。本文已被。
kafka java客户端无法消费消息
05-28
如果 Kafka Java 客户端无法消费消息，你可以按照以下步骤逐一排查问题： 1. 检查 Kafka 服务器是否正常：请确保 Kafka ...同时，你也可以参考 Kafka Java 客户端的官方文档，以便更好地理解 Kafka 客户端的使用方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值