Spring boot ApacheKafka的Spring引导：未读取消息

我目前正在使用Kafka listener设置Spring启动应用程序。 我试图只编码消费者。对于producer，我现在正在从Kafka控制台手动发送消息。 我举了一个例子：

我尝试将其作为Spring启动应用程序运行，但看不到收到的任何消息。在我当地的卡夫卡主题中已经有一些信息

C:\software\kafka_2.11-0.10.1.0\kafka_2.11-0.10.1.0\kafka_2.11-0.10.1.0\bin\wind
ows>kafka-console-producer.bat --broker-list localhost:9092 --topic test
this is a message
testing again

我的Spring Boot应用程序是：

@EnableDiscoveryClient
@SpringBootApplication
public class KafkaApplication {

    /**
     * Run the application using Spring Boot and an embedded servlet engine.
     * 
     * @param args
     *            Program arguments - ignored.
     */
    public static void main(String[] args) {
        // Tell server to look for registration.properties or registration.yml
        System.setProperty("spring.config.name", "kafka-server");

        SpringApplication.run(KafkaApplication.class, args);
    }
}

卡夫卡的配置是：

package kafka;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.IntegerDeserializer;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;

import java.util.HashMap;
import java.util.Map;

@Configuration
@EnableKafka
public class KafkaConsumerConfig {
    @Bean
    KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory();
        factory.setConsumerFactory(consumerFactory());
        //factory.setConcurrency(1);
        //factory.getContainerProperties().setPollTimeout(3000);
        return factory;
    }

    @Bean
    public ConsumerFactory<String, String> consumerFactory() {
        return new DefaultKafkaConsumerFactory(consumerConfigs());
    }

    @Bean
    public Map<String, Object> consumerConfigs() {
        Map<String, Object> propsMap = new HashMap();
        propsMap.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        //propsMap.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        //propsMap.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "100");
        //propsMap.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, "15000");
        propsMap.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, IntegerDeserializer.class);
        propsMap.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        //propsMap.put(ConsumerConfig.GROUP_ID_CONFIG, "group1");
        //propsMap.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
        return propsMap;
    }

    @Bean
    public Listener listener() {
        return new Listener();
    }
}

卡夫卡套餐；
导入org.apache.kafka.clients.consumer.ConsumerConfig；
导入org.apache.kafka.common.serialization.IntegerDeserializer；
导入org.apache.kafka.common.serialization.StringDeserializer；
导入org.springframework.context.annotation.Bean；
导入org.springframework.context.annotation.Configuration；
导入org.springframework.kafka.annotation.EnableKafka；
导入org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory；
导入org.springframework.kafka.config.KafkaListenerContainerFactory；
导入org.springframework.kafka.core.ConsumerFactory；
导入org.springframework.kafka.core.DefaultKafkaConsumerFactory；
导入org.springframework.kafka.listener.ConcurrentMessageListenerContainer；
导入java.util.HashMap；
导入java.util.Map；
@配置
@使能卡夫卡
公共类卡夫卡消费者配置{
@豆子
KafkaListenerContainerFactory KafkaListenerContainerFactory（）{
ConcurrentKafkListenerContainerFactory=新ConcurrentKafkListenerContainerFactory（）；
setConsumerFactory（consumerFactory（））；
//工厂设置并发（1）；
//factory.getContainerProperties（）.setPollTimeout（3000）；
返回工厂；
}
@豆子
公共消费者工厂消费者工厂（）{
返回新的DefaultKafkanConsumerFactory（consumerConfigs（））；
}
@豆子
公共地图使用者配置（）{
Map propsMap=newhashmap（）；
propsMap.put（ConsumerConfig.BOOTSTRAP\u SERVERS\u CONFIG，“localhost:9092”）；
//propsMap.put（ConsumerConfig.ENABLE\u AUTO\u COMMIT\u CONFIG，false）；
//propsMap.put（ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG，“100”）；
//propsMap.put（ConsumerConfig.SESSION\u TIMEOUT\u MS\u CONFIG，“15000”）；
propsMap.put（ConsumerConfig.KEY\u反序列化器\u CLASS\u配置，IntegerDeserializer.CLASS）；
propsMap.put（ConsumerConfig.VALUE\u反序列化程序\u类\u配置，StringDeserializer.CLASS）；
//propsMap.put（ConsumerConfig.GROUP_ID_CONFIG，“group1”）；
//propsMap.put（ConsumerConfig.AUTO_OFFSET_RESET_CONFIG，“最早”）；
返回属性映射；
}
@豆子
公共侦听器（）{
返回新的侦听器（）；
}
}

卡夫卡的听众是：

package kafka;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import java.util.logging.Logger;

public class Listener {

    protected Logger logger = Logger.getLogger(Listener.class
            .getName());

    public CountDownLatch getCountDownLatch1() {
        return countDownLatch1;
    }

    private CountDownLatch countDownLatch1 = new CountDownLatch(1);

    @KafkaListener(topics = "test")
    public void listen(ConsumerRecord<?, ?> record) {
        logger.info("Received message: " + record);
        System.out.println("Received message: " + record);
        countDownLatch1.countDown();
    }
}

卡夫卡套餐；
导入org.apache.kafka.clients.consumer.ConsumerRecord；
导入org.springframework.kafka.annotation.KafkaListener；
导入java.io.BufferedWriter；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.util.concurrent.CountDownLatch；
导入java.util.logging.Logger；
公共类侦听器{
受保护的记录器=Logger.getLogger（Listener.class
.getName（））；
公共CountDownLatch getCountDownLatch1（）{
返回倒计时锁1；
}
专用倒计时闩锁倒计时闩锁1=新倒计时闩锁（1）；
@卡夫卡列斯汀（topics=“test”）
公共无效侦听（消费者记录记录）{
logger.info（“收到的消息：+记录”）；
System.out.println（“收到的消息：+记录”）；
倒计时锁1.倒计时（）；
}
}

---

这是我第一次尝试。如果我做错了什么，请告诉我。非常感谢您的帮助。

您没有设置ConsumerConfig.AUTO\u OFFSET\u RESET\u CONFIG，因此默认设置为“latest”。将其设置为“最早”，以便消费者将收到主题中已有的消息

---

ConsumerConfig.AUTO_OFFSET_RESET_CONFIG仅在使用者组没有主题分区的偏移量时生效。如果已使用“最新”设置运行使用者，则使用其他设置再次运行使用者不会更改偏移量。使用者必须使用不同的组，以便Kafka将为该组分配偏移量。

注意到dit注释掉使用者组.id属性

 //propsMap.put(ConsumerConfig.GROUP_ID_CONFIG, "group1");

让我们看看下面的文章是如何引用的：

标识此使用者所属的使用者组的唯一字符串。如果消费者使用subscribe（主题）使用组管理功能或基于Kafka的偏移管理策略，则需要此属性

---

试图取消对该行的注释，消费者成功了。

您需要使用

@Service

或

@Component

对侦听器类进行注释，以便Spring Boot可以加载Kafka侦听器

卡夫卡套餐；
导入org.apache.kafka.clients.consumer.ConsumerRecord；
导入org.springframework.kafka.annotation.KafkaListener；
导入java.io.BufferedWriter；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.util.concurrent.CountDownLatch；
导入java.util.logging.Logger；
@组成部分
公共类侦听器{
受保护的记录器=Logger.getLogger（Listener.class
.getName（））；
公共CountDownLatch getCountDownLatch1（）{
返回倒计时锁1；
}
专用倒计时闩锁倒计时闩锁1=新倒计时闩锁（1）；
@卡夫卡列斯汀（topics=“test”）
公共无效侦听（消费者记录记录）{
logger.info（“收到的消息：+记录”）；
System.out.println（“收到的消息：+记录”）；
倒计时锁1.倒计时（）；
}
}

问题出在哪里？消息未被读取。我在Listener.java中有以下命令，但没有打印输出：logger.info（“接收到的消息：“+record”）；System.out.println（“收到的消息：+记录”）；我也尝试过设置为最早，但没有效果。我正在运行一个示例程序，如下所示：context.addRout