Java 客户端访问 Kafka

Java 客户端访问 Kafka

1,依赖引入

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

2,消息生产端代码

package com.example.kafkademo.producer;

import com.example.kafkademo.constant.Constant;
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.common.serialization.StringSerializer;

import java.util.Properties;
import java.util.Random;

/**
 * @author lwc
 */
public class ProducerClass {

    public static void main(String[] args) throws Exception{
        Properties props = new Properties();
        //kafka地址,多个地址用逗号分割
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "81.69.233.xxx:9092");
        props.put(ProducerConfig.ACKS_CONFIG, "0");
        props.put(ProducerConfig.RETRIES_CONFIG, 3);
        props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG, 300);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        props.put(ProducerConfig.LINGER_MS_CONFIG, 10);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(props);
        while (true){
            String msg = "Hello," + new Random().nextInt(100);
            ProducerRecord<String, String> record = new ProducerRecord<String, String>(Constant.topic, msg);
            kafkaProducer.send(record);
            System.out.println("消息发送成功:" + msg);
            Thread.sleep(100);
        }
    }
}


消息生产端参数说明:

//消息持久化参数
props.put(ProducerConfig.ACKS_CONFIG, "1");

/**
0 :producer 不需要等到任何broker确认,就可以继续发送下一条消息,性能最高,容易丢失消息
1 :等待leader成功将数据存入log,但是不需要等待所有follower成功写入,就可以继续发送下一条消息,这种情况存在follower 没把消息成功写入,leader节点又挂掉了,这个时候会丢失消息
-1 或 all: 需要等待 min.insync.replicas (默认为1,推荐配置大于等于2) 这个参数配置的副本个数都成功写入日志,这种策略会保证只要有一个备份存活就不会丢失数据,这是最强的数据保证,
一般是金融级别跟钱打交道的场景才会使用这种配置。
**/
//失败重试机制配置
props.put(ProducerConfig.RETRIES_CONFIG, 3);
//重试间隔设置
props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG, 300);

/**
消息发送失败,默认100ms重试一次,重试可以保证消息的可靠性.
但缺点是可能会造成消息的重复发送,需要在消费端做好幂等性
**/
//设置发送消息的本地缓冲区,消息会先发送到本地缓冲区,提高消息发送性能,默认值是33554432 == 32MB
props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384)

/**
设置批量发送消息的大小,默认值 16384 == 16k 
本地缓存满了16k,kafka 会从本地缓存拉起消息,批量一起发到broker
**/
//设置满足10ms立刻发送消息,没必要要等本地缓存满了16k才能发送消息到broker
props.put(ProducerConfig.LINGER_MS_CONFIG, 10);
//将发送的key序列化成字节数组
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
//将发送的消息value从字符串序列成字节数组
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);

3,消息消费端代码

package com.example.kafkademo.consumer;

import com.example.kafkademo.constant.Constant;
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.common.serialization.StringDeserializer;

import java.util.Collections;
import java.util.Properties;

/**
 * @author lwc
 */
public class ConSumerClass {

    private final static String CONSUMER_GROUP_NAME = "testGroup";

    public static void main(String[] args) {
        Properties props = new Properties();
        //kafka地址,多个地址用逗号分割
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "81.69.233.xxx:9092");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
		props.put(ConsumerConfig.GROUP_ID_CONFIG, CONSUMER_GROUP_NAME);
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");
		props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 1000);
        props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 10 * 1000);
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 500);
        props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, 30 * 1000);
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);
       	// 订阅消息
        kafkaConsumer.subscribe(Collections.singletonList(Constant.topic));
        while (true) {
            ConsumerRecords<String, String> records = kafkaConsumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(String.format("topic:%s,offset:%d,消息:%s", //
                        record.topic(), record.offset(), record.value()));
            }
        }
    }
}

消息消费端参数说明:

//消息消费组
props.put(ConsumerConfig.GROUP_ID_CONFIG, CONSUMER_GROUP_NAME);
//消息自动提交offset,默认为true
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
//自动提交offset间隔时间
props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");

props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 1000);
//brober多久没感知到consumer的心跳,就会将其踢出消费组,对应消费的Partition也会重新分配给其他的consumer,默认是10秒
props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 10 * 1000);
//一次poll消息的条数,如果消费者的性能很高,这个参数能设大一些
props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 500);
//两次poll都超过这个时间,brober 会将消费者踢出消费组并将Partition分配给其它的消费者
props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, 30 * 1000);
### 回答1: 可以使用Kafka提供的Java客户端API来实现多线程消费Kafka消息。具体步骤如下: 1. 创建Kafka消费者实例,设置消费者配置参数,如bootstrap.servers、group.id等。 2. 创建多个消费线程,每个线程都创建一个Kafka消费者实例并订阅相同的Kafka主题。 3. 在每个消费线程中,使用Kafka消费者实例的poll()方法从Kafka主题中拉取消息。 4. 处理拉取到的消息,可以将消息放入线程安全的队列中,由其他线程进行处理。 5. 在消费线程中,使用Kafka消费者实例的commitSync()方法提交消费偏移量,确保消息被成功处理。 6. 在主线程中,等待所有消费线程完成消费任务后,关闭Kafka消费者实例。 示例代码如下: ```java public class KafkaConsumerDemo { private static final String TOPIC_NAME = "test-topic"; private static final int NUM_THREADS = 3; public static void main(String[] args) { Properties props = new Properties(); props.put("bootstrap.servers", "localhost:9092"); props.put("group.id", "test-group"); props.put("enable.auto.commit", "false"); props.put("auto.offset.reset", "earliest"); props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); ExecutorService executorService = Executors.newFixedThreadPool(NUM_THREADS); for (int i = 0; i < NUM_THREADS; i++) { executorService.execute(() -> { KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props); consumer.subscribe(Collections.singleton(TOPIC_NAME)); while (true) { ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100)); for (ConsumerRecord<String, String> record : records) { // 处理消息 System.out.printf("Thread: %s, offset: %d, key: %s, value: %s\n", Thread.currentThread().getName(), record.offset(), record.key(), record.value()); } consumer.commitSync(); } }); } Runtime.getRuntime().addShutdownHook(new Thread(() -> { executorService.shutdownNow(); })); } } ``` 上面的示例代码创建了3个消费线程,每个线程都创建了一个Kafka消费者实例,并订阅了名为test-topic的Kafka主题。在每个消费线程中,使用poll()方法从Kafka主题中拉取消息,并处理消息。在消费线程中,使用commitSync()方法提交消费偏移量。在主线程中,通过addShutdownHook()方法注册了一个钩子函数,用于在程序退出时关闭线程池。 ### 回答2: Java多线程消费Kafka是一种常见的消息消费方式,适用于需要高性能和高并发处理消息的场景。下面是一个简单的示例代码,用于演示Java多线程消费Kafka的基本思路。 1. 首先,我们需要引入KafkaJava客户端依赖包,例如Apache Kafka提供的`kafka-clients`库。 2. 然后,我们创建一个消费者线程类`ConsumerThread`,实现`Runnable`接口,该类的主要功能是从Kafka主题订阅消息并进行处理。 3. 在`ConsumerThread`类的构造函数中,我们可以传入一些配置参数,例如Kafka的服务器地址、消费者组ID以及要消费的主题等。 4. 在`run()`方法中,我们可以实例化一个Kafka消费者对象,并设置消费者的配置参数。然后,通过`consumer.subscribe()`方法订阅指定的主题。 5. 在一个无限循环中,通过`consumer.poll()`方法从Kafka中拉取消息。拉取到的消息会被封装成一个`ConsumerRecords`对象。 6. 迭代`ConsumerRecords`对象,并逐条处理每条消息。处理的逻辑可以根据业务需求自定义,例如将消息保存到数据库、进行计算或者发送到其他系统等。 7. 最后,记得在合适的时候关闭消费者对象,释放资源。 使用多线程消费Kafka能够提高消息消费的效率和并发性。可以考虑将消费者线程实例化为一个线程池,并指定线程数,以实现并发处理。 需要注意的是,在多线程消费Kafka的场景下,可能会出现消息顺序不一致的情况。因此,需要根据业务需求来判断是否需要保持消息的顺序性。 ### 回答3: Java中可以使用Apache Kafka客户端库来实现多线程消费Kafka。多线程消费可以提高消费速度和并发性。 首先,我们需要创建一个Kafka消费者对象,指定要消费的主题和Kafka集群的地址。然后,我们可以使用该消费者对象来订阅要消费的主题。 接下来,我们可以创建多个线程来同时消费Kafka消息。每个线程都可以创建一个新的消费者实例,并在每个线程中运行一个消费循环,以接收并处理从Kafka中获取的消息。 在消费循环中,我们可以使用一个无限循环来持续地消费Kafka消息。在每次循环中,我们可以使用消费者对象的poll方法来获取一批新的消息。然后,我们可以遍历这批消息并进行相应的处理。 在处理消息的过程中,我们需要确保每个线程都能处理自己所接收到的消息,并且要考虑到线程安全性。可以使用锁或其他线程同步机制来保证多个线程之间的数据访问的一致性和互斥性。 此外,在处理消息的过程中,我们还可以对消息进行一些后续的处理,比如将消息保存到数据库、发送到其他系统或进行其他的业务逻辑操作。 最后,当需要停止消费线程时,我们可以调用消费者对象的close方法来关闭消费者。这将会释放消费者所占用的资源,并停止消费。 综上所述,通过创建多线程来消费Kafka消息可以提高消费速度和并发性,从而更好地满足高并发场景下的需求。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

不像程序猿的程序员

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

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

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

打赏作者

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

抵扣说明:

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

余额充值