Question

我正在使用kafka-spring-test版本2.0.1.RELEASE（最新版本）中的EmbeddedKafka。我有非常简单的测试，只运行一次测试时可以正常工作。 但每当我一个接一个地运行它们（所以只运行整个测试类），然后第二个失败 - 消费者没有收到任何消息。

public class KafkaControllerTest {

    private static final String FOO_TOPIC = "fooTopic";

    @Rule
    public KafkaEmbedded embeddedKafka = new KafkaEmbedded(1, true, FOO_TOPIC);

    MessageConsumer msgConsumerFoo = mock(MessageConsumer.class);

    @Before
    public void before() {
        assertTrue(embeddedKafka.getBrokerAddresses().length == 1);
        KafkaController controller = new KafkaController(
                embeddedKafka.getBrokerAddress(0).toString(),
                new Consumer(FOO_TOPIC, msgConsumerFoo));
        MockMvcBuilders.standaloneSetup(controller).build();
    }

    @Test
    public void kafkaFirstTest() throws Exception {
        sendMessage(FOO_TOPIC, "foo message");

        verify(msgConsumerFoo).consume(any());
    }

    @Test
    public void kafkaSecondTest() throws Exception {
        sendMessage(FOO_TOPIC, "foo2 message");

        verify(msgConsumerFoo).consume(any());
    }

    void sendMessage(String topic, String notification) throws ExecutionException, InterruptedException {
        Map<String, Object> props = KafkaTestUtils.producerProps(embeddedKafka);
        Producer<Integer, String> producer = new DefaultKafkaProducerFactory<Integer, String>(props).createProducer();
        producer.send(new ProducerRecord<>(topic, notification)).get();
    }
}

测试类的代码：

public class KafkaController {

    public KafkaController(String brokerAddress, Consumer... consumers) {
        for (Consumer consumer : consumers) {
            addTopicListener(brokerAddress, consumer.topic, consumer.messageConsumer);
        }
    }

    private void addTopicListener(String brokerAddress, String topic, MessageConsumer consumer) {
        HashMap<String, Object> consumerConfig = new HashMap<>();
        consumerConfig.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, brokerAddress);
        consumerConfig.put(ConsumerConfig.GROUP_ID_CONFIG, UUID.randomUUID().toString());
        DefaultKafkaConsumerFactory<String, String> cf = new DefaultKafkaConsumerFactory<>(
                consumerConfig,
                new StringDeserializer(),
                new StringDeserializer());

        ContainerProperties containerProperties = new ContainerProperties(topic);
        containerProperties.setMessageListener((MessageListener<String, String>) data -> {
            consumer.consume(data.value());
        });
        ConcurrentMessageListenerContainer container = new ConcurrentMessageListenerContainer<>(cf, containerProperties);
        container.start();
    }

    public interface MessageConsumer {
        void consume(String message);
    }

    public static class Consumer {
        private final String topic;
        private final MessageConsumer messageConsumer;

        public Consumer(String topic, MessageConsumer messageConsumer) {
            this.topic = topic;
            this.messageConsumer = messageConsumer;
        }
    }
}

我认为问题是由KafkaEmbedded引起的，因为使用本地Kafka实例测试的消费者正常工作。

有什么我想念的吗？我没有发现任何可能有用的消费者财产。

Kafka-spring-test doc说：

通常建议将规则用作@ClassRule，以避免在测试之间启动/停止代理（并为每个测试使用不同的主题）。

但是，我尝试将KafkaEmbedded作为@ClassRule并在测试中使用不同的主题，但仍然没有。

此问题与异步性有关，因为在第二次测试中添加延迟有助于：

@Test
public void kafkaSecondTest() throws Exception {
    Thread.sleep(1000);
    sendMessage(FOO_TOPIC, "foo2 message");
    Thread.sleep(1000);

    verify(msgConsumerFoo).consume(any());
}

是的，只有在发送消息之前和之后都添加Thread.sleep(1000)时，它才会起作用。

那么如何检查KafkaEmbedded或其他组件是否已准备好发送/使用消息？

Answer 1

您可能需要设置auto.offset.reset=earliest（ConsumerConfig.AUTO_OFFSET_RESET_CONFIG）。否则，您可以在容器完全启动之前发送消息。

当然，如果你使用相同的主题，第二个消费者应该得到2条消息。

另外，我建议在每次测试结束时停止容器。调试日志记录也应该有所帮助。

修改

另一种方法是在测试中发送消息之前使用ContainerTestUtils.waitForAssignment();我们在框架测试中做了很多。

EmbeddedKafka在后续测试延迟后向消费者发送消息

1 个答案: