Java编程操作Kafka

码灵

已于 2023-08-14 15:20:33 修改

阅读量6.6k

点赞数 3

分类专栏： kafka二次笔记文章标签： java kafka 开发语言

于 2022-01-31 11:32:13 首次发布

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/h4241778/article/details/122758760

版权

kafka二次笔记专栏收录该内容

14 篇文章 3 订阅

订阅专栏

5.2 从Kafka的topic中消费消息

5. Java编程操作Kafka

5.1 同步生产消息到Kafka中

5.1.1 需求

接下来，我们将编写Java程序，将1-100的数字消息写入到Kafka中。

5.1.2 准备工作

5.1.2.1 导入Maven Kafka POM依赖

<repositories>
    <repository>
        <id>central</id>
        <url>http://maven.aliyun.com/nexus/content/groups/public//</url>
        <releases>
            <enabled>true</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
            <updatePolicy>always</updatePolicy>
            <checksumPolicy>fail</checksumPolicy>
        </snapshots>
    </repository>
</repositories>

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

    
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-io</artifactId>
        <version>1.3.2</version>
    </dependency>

    
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.6</version>
    </dependency>

    
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.16</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
    </plugins>
</build>

5.1.2.2 导入log4j.properties

将log4j.properties配置文件放入到resources文件夹中

log4j.rootLogger=INFO,stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p - %m%n

5.1.2.3 创建包和类

创建包cn.itcast.kafka，并创建KafkaProducerTest类。

5.1.3 代码开发

可以参考以下方式来编写第一个Kafka示例程序

参考以下文档：kafka 2.4.0 API

1 创建用于连接Kafka的Properties配置

Properties props = new Properties();

props.put("bootstrap.servers", "192.168.88.100:9092");

props.put("acks", "all");

props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");

props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

2 创建一个生产者对象KafkaProducer

3 调用send发送1-100消息到指定Topic test，并获取返回值Future，该对象封装了返回值

4 再调用一个Future.get()方法等待响应

5 关闭生产者

参考代码：

5.2 从Kafka的topic中消费消息

5.2.1 需求

从 test topic中，将消息都消费，并将记录的offset、key、value打印出来

5.2.2 准备工作

创建KafkaConsumerTest类

5.2.3 开发步骤

1 创建Kafka消费者配置

Properties props = new Properties();
props.setProperty("bootstrap.servers", "node1.itcast.cn:9092");
props.setProperty("group.id", "test");
props.setProperty("enable.auto.commit", "true");
props.setProperty("auto.commit.interval.ms", "1000");
props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

2 创建Kafka消费者

3 订阅要消费的主题

4 使用一个while循环，不断从Kafka的topic中拉取消息

5 将将记录（record）的offset、key、value都打印出来

参考代码

package xb.study.kafka.consumer;

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.time.Duration;
import java.util.Collections;
import java.util.Properties;

/**
 * 消费者
 */
public class ConsumerStart {
    private static final String brokerList="10.22.80.11:9092";
    private static final String topic="test";
    private static final String groupId="group.demo";
    public static void main(String[] args) {
        try {

            Properties props = new Properties();
            props.put(ConsumerConfig.GROUP_ID_CONFIG,groupId);//分组ID
            //props.put("bootstrap.servers", brokerList);
            props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, brokerList);//broker地址列表
            //props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
            props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());//反序列化器
            //props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
            props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
			//props.put("enable.auto.commit", "true"); // 打开自动提交offset
            //props.put("auto.commit.interval.ms", "1000"); // 设置自动提交offset的时间间隔，示例为每1秒提交一次
			//用户 密码
			// props.put("sasl.mechanism", "PLAIN");
            // props.put("security.protocol", "SASL_PLAINTEXT");
            // props.put("sasl.jaas.config", "org.apache.kafka.common.security.plain.PlainLoginModule required username=\"" + userName + "\" password=\"" + passwd + "\";");
            KafkaConsumer consumer= new KafkaConsumer<String,String>(props);
            consumer.subscribe(Collections.singletonList(topic));//topic列表
            while (true){
                ConsumerRecords<String,String> records=consumer.poll(Duration.ofMillis(3000));
                for(ConsumerRecord<String,String> record:records){
                    System.out.println(record.topic()+":"+record.offset()+":"+record.value());
                }

            }
        }catch (Exception e){
            e.printStackTrace();

        }
    }
}

指定分区消费

String topic = "foo";
TopicPartition partition0 = new TopicPartition(topic, 0);
TopicPartition partition1 = new TopicPartition(topic, 1);
consumer.assign(Arrays.asList(partition0, partition1)); // 只消费foo的分区0和分区1，不可以与subscribe方法同用

获取最早offset或者最新offset

TopicPartition partition = new TopicPartition("foo", 0);
// 获取foo的分区0的最早offset
long beginningOffset = consumer.beginningOffsets(Collections.singletonList(partition)).get(partition); 
// 获取foo的分区0的最新offset
long endOffset = consumer.endOffsets(Collections.singletonList(partition)).get(partition);

从某一个offset开始消费

TopicPartition partition = new TopicPartition("foo", 0);
long offset = args[0];

// 移动到指定offset
consumer.seek(partition, offset);
// 移动到最新offset
consumer.seekToEnd(Collections.singletonList(partition));
// 移动到最早offset
consumer.seekToBeginning(Collections.singletonList(partition));

参考官网API文档：

kafka 2.4.0 API

5.3 异步使用带有回调函数方法生产消息

如果我们想获取生产者消息是否成功，或者成功生产消息到Kafka中后，执行一些其他动作。此时，可以很方便地使用带有回调函数来发送消息。

需求：
1.在发送消息出现异常时，能够及时打印出异常信息
2.在发送消息成功时，打印Kafka的topic名字、分区id、offset

public class KafkaProducerTest {
    public static void main(String[] args) {
        // 1. 创建用于连接Kafka的Properties配置
        Properties props = new Properties();
        props.put("bootstrap.servers", "node1.itcast.cn:9092");
        props.put("acks", "all");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        // 2. 创建一个生产者对象KafkaProducer
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);

        // 3. 调用send发送1-100消息到指定Topic test
        for(int i = 0; i < 100; ++i) {
            // 一、同步方式
            // 获取返回值Future，该对象封装了返回值
            // Future<RecordMetadata> future = producer.send(new ProducerRecord<String, String>("test", null, i + ""));
            // 调用一个Future.get()方法等待响应
            // future.get();

            // 二、带回调函数异步方式
            producer.send(new ProducerRecord<String, String>("test", null, i + ""), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if(exception != null) {
                        System.out.println("发送消息出现异常");
                    }
                    else {
                        String topic = metadata.topic();
                        int partition = metadata.partition();
                        long offset = metadata.offset();

                        System.out.println("发送消息到Kafka中的名字为" + topic + "的主题，第" + partition + "分区，第" + offset + "条数据成功!");
                    }
                }
            });
        }

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

码灵

关注

3
点赞
踩
17

收藏

觉得还不错? 一键收藏
打赏
3
评论
Java编程操作Kafka

如果我们想获取生产者消息是否成功，或者成功生产消息到Kafka中后，执行一些其他动作。从 test topic中，将消息都消费，并将记录的offset、key、value打印出来。创建包cn.itcast.kafka，并创建KafkaProducerTest类。2.在发送消息成功时，打印Kafka的topic名字、分区id、offset。接下来，我们将编写Java程序，将1-100的数字消息写入到Kafka中。4 使用一个while循环，不断从Kafka的topic中拉取消息。2 创建Kafka消费者。
复制链接

扫一扫