Kafka基础篇

最新推荐文章于 2025-08-15 16:33:30 发布

原创最新推荐文章于 2025-08-15 16:33:30 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #servlet #jvm

kafka 专栏收录该内容

1 篇文章

订阅专栏

本文介绍了Kafka的基础应用，包括配置和Java实现。详细阐述了如何配置Kafka应用，创建生产者和消费者，设置bootstrap-servers参数，以及如何进行消息的序列化和反序列化。还提供了生产者和消费者的代码示例。

Kafka应用配置

<!-- kafka依赖 -->
<dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>2.0.0</version>
</dependency>
<!--kafka的⽇志组件依赖包 -->
<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-simple</artifactId>
        <version>1.7.25</version>
</dependency>
<!-- all in one 打包 -->
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-withdependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>assembly</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

Kafka应用Java实现

实现步骤

生产者

定义主题

构建生产者

设置bootstrap-servers参数

常用的KafkaProducer和KafkaConsumer用来连接Kafka集群的入口参数

指定类对key进行序列化

指定类对value进行序列化

创建生产者对象

发送消息

代码示例


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.header.internals.RecordHeader;
import org.apache.kafka.common.header.internals.RecordHeaders;
import org.apache.kafka.common.serialization.StringSerializer;

import java.nio.charset.StandardCharsets;
import java.util.Properties;

public class KafkaProducerUtil {
    public static void main(String[] args) {
        //定义了主题
        String topic="zhaoan";
        //创建生产者
        Properties props = new Properties();
        // bootstrap-servers
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "cluster1.hadoop:6667");
        // 指定类对key进行序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        // 指定类对value进行序列化
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        // 创建⽣产者对象
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);

        //添加额外的信息
        RecordHeaders headers=new RecordHeaders();
        headers.add(new RecordHeader("token","这是一个额外的数据".getBytes(StandardCharsets.UTF_8)));
        //发送消息
        producer.send(new ProducerRecord<String, String>(
                topic,
                null,
                args[0],
                args[1],
                headers
        ));
        producer.close();
    }

}

消费者

定义主题

构建消费者

设置bootstrap-servers参数

指定类对key进行反序列化

指定类对value进行反序列化

设置是否启用自动提交offset，默认true（可不写）

设置自动提交间隔时间（可不写）

创建消费者对象

订阅主题

拉取消息

代码示例

import org.apache.kafka.clients.consumer.ConsumerConfig;
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.Arrays;
import java.util.Properties;

public class KafkaConsumerUtil {
    public static void main(String[] args) {
        //定义主题
        String topic="zhaoan";

        //构建消费者
        Properties prop=new Properties();
        prop.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"cluster1:6667");
        prop.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        prop.put(ConsumerConfig.GROUP_ID_CONFIG,"job022");
        //是否启用自动提交offset，默认true
        prop.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
        //自动提交间隔时间1s
        prop.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,1000);
        //创建消费者对象
        KafkaConsumer<String,String> kafkaConsumer=new KafkaConsumer<String, String>(prop);
        //订阅主题
        kafkaConsumer.subscribe(Arrays.asList(topic));

        //拉取消息
        boolean flag=true;
        while(flag){
            ConsumerRecords<String,String> records=kafkaConsumer.poll(Duration.ofSeconds(1));
            records.forEach(item->{
                System.out.println("key\t\t"+item.key());
                System.out.println("value\t\t"+item.value());
                System.out.println("offset\t\t"+item.offset());
                System.out.println("timestamp\t"+item.timestamp());
                System.out.println("partition\t"+item.partition());
                System.out.println("==============header content=================");
                item.headers().forEach(header -> System.out.println(header.key()+":::"+new String(header.value())));
                System.out.println("--------------------------------------------");
            });
        }

        kafkaConsumer.close();
    }
}