java kafa使用入门配置教程

Java Kafka 使用入门配置教程（2026最新）

这是一份从环境搭建、服务启动、Java客户端配置到消息收发的完整入门教程，覆盖原生Java API与Spring Boot两种主流用法，新手可直接跟着步骤操作。

一、环境准备（必做）

1. 安装JDK

Kafka基于JVM运行，需安装JDK 8及以上（推荐JDK 11+）。

• 检查：​​java -version​​
• 安装（CentOS）：​​sudo yum install -y java-1.8.0-openjdk-devel​​

2. 下载Kafka（3.8.0最新稳定版）

访问​​Apache Kafka官网​​，下载二进制包（非源码）：

• 推荐版本：​​kafka_2.13-3.8.0.tgz​​（2.13为Scala版本，不影响Java使用）
• 解压：​​tar -zxvf kafka_2.13-3.8.0.tgz -C /opt/​​
• 进入目录：​​cd /opt/kafka_2.13-3.8.0​​

二、启动Kafka服务（两种模式）

方式1：KRaft模式（Kafka 3.3+推荐，无需ZooKeeper）

1. 生成集群ID

./bin/kafka-storage.sh random-uuid
# 复制生成的UUID，如：8CL0dLW1T26t6O4h9n958Q

2. 格式化存储目录

./bin/kafka-storage.sh format -t 8CL0dLW1T26t6O4h9n958Q -c ./config/kraft/server.properties

3. 启动Kafka Broker

./bin/kafka-server-start.sh ./config/kraft/server.properties

方式2：ZooKeeper模式（传统方式，兼容旧版）

1. 启动ZooKeeper（Kafka自带）

./bin/zookeeper-server-start.sh ./config/zookeeper.properties

2. 启动Kafka Broker

./bin/kafka-server-start.sh ./config/server.properties

3. 验证服务

• Kafka默认端口：9092
• 检查端口占用：​​netstat -tuln | grep 9092​​

三、创建Topic（消息主题）

Topic是消息的分类容器，必须先创建才能收发消息。

命令行创建（推荐）

# Linux/Mac
./bin/kafka-topics.sh --create --topic test-topic --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1

# Windows
bin\windows\kafka-topics.bat --create --topic test-topic --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1

• ​​--topic​​：主题名（如​​test-topic​​）
• ​​--partitions​​：分区数（单机填1）
• ​​--replication-factor​​：副本数（单机填1）

查看Topic

./bin/kafka-topics.sh --list --bootstrap-server localhost:9092

四、原生Java API实现（不依赖Spring）

1. 添加Maven依赖

在​​pom.xml​​中加入Kafka客户端依赖：

<dependencies>
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>3.8.0</version> <!-- 与服务端版本一致 -->
    </dependency>
</dependencies>

2. 生产者（Producer）：发送消息

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
import java.util.concurrent.ExecutionException;

public class KafkaProducerDemo {
    public static void main(String[] args) {
        // 1. 配置生产者
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.ACKS_CONFIG, "all"); // 消息可靠性级别
        props.put(ProducerConfig.RETRIES_CONFIG, 3); // 重试次数

        // 2. 创建生产者实例
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);

        // 3. 构造消息（主题，键，值）
        ProducerRecord<String, String> record = new ProducerRecord<>("test-topic", "key-1", "Hello Kafka from Java!");

        // 4. 发送消息（异步+回调）
        producer.send(record, (metadata, exception) -> {
            if (exception == null) {
                System.out.println("消息发送成功：");
                System.out.println("主题：" + metadata.topic());
                System.out.println("分区：" + metadata.partition());
                System.out.println("偏移量：" + metadata.offset());
            } else {
                exception.printStackTrace();
            }
        });

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

3. 消费者（Consumer）：接收消息

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.serialization.StringDeserializer;
import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

public class KafkaConsumerDemo {
    public static void main(String[] args) {
        // 1. 配置消费者
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group"); // 消费者组ID
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest"); // 从头消费
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true"); // 自动提交偏移量

        // 2. 创建消费者实例
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);

        // 3. 订阅主题
        consumer.subscribe(Collections.singletonList("test-topic"));

        // 4. 循环拉取消息
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records) {
                System.out.println("收到消息：");
                System.out.println("键：" + record.key() + "，值：" + record.value());
                System.out.println("分区：" + record.partition() + "，偏移量：" + record.offset());
            }
        }
    }
}

五、Spring Boot整合Kafka（企业级常用）

1. 添加Spring Boot依赖

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

2. 配置application.yml

spring:
  kafka:
    bootstrap-servers: localhost:9092 # Kafka地址
    # 生产者配置
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
      acks: all
    # 消费者配置
    consumer:
      group-id: spring-boot-group
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      auto-offset-reset: earliest

3. 生产者代码

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class KafkaProducerService {
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public void sendMessage(String topic, String message) {
        kafkaTemplate.send(topic, message);
        System.out.println("Spring Boot发送消息：" + message + "到主题：" + topic);
    }
}

4. 消费者代码

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class KafkaConsumerService {
    // 监听test-topic主题
    @KafkaListener(topics = "test-topic", groupId = "spring-boot-group")
    public void consume(String message) {
        System.out.println("Spring Boot收到消息：" + message);
    }
}

5. 启动类测试

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class KafkaSpringBootApp {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(KafkaSpringBootApp.class, args);
        KafkaProducerService producer = context.getBean(KafkaProducerService.class);
        producer.sendMessage("test-topic", "Hello Spring Boot Kafka!");
    }
}

六、核心配置说明（关键参数）

生产者核心配置

参数	说明	推荐值
​​bootstrap.servers​​	Kafka集群地址	​​localhost:9092​​
​​key.serializer​​	键序列化器	​​StringSerializer​​
​​value.serializer​​	值序列化器	​​StringSerializer​​
​​acks​​	消息确认机制	​​all​​（最高可靠性）
​​retries​​	发送失败重试次数	​​3​​

消费者核心配置

参数	说明	推荐值
​​group.id​​	消费者组ID（同一组内负载均衡）	自定义，如​​test-group​​
​​auto.offset.reset​​	无偏移量时的消费策略	​​earliest​​​（从头）/​​latest​​（最新）
​​enable.auto.commit​​	是否自动提交偏移量	​​true​​（简单场景）

七、常见问题排查

1. 连接失败：检查Kafka是否启动、端口9092是否开放、防火墙是否拦截。
2. 消费不到消息：确认Topic存在、消费者组ID正确、​​auto.offset.reset​​配置合理。
3. 序列化异常：确保生产者与消费者的序列化/反序列化器一致。
4. 版本不兼容：Java客户端版本需与Kafka服务端版本一致（如3.8.0）。

---

需要我把以上代码整理成一个可直接运行的Maven项目模板，并附上启动脚本与测试用例吗？