package de.juplo.kafka;
+import lombok.Value;
import lombok.extern.slf4j.Slf4j;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Primary;
+import org.springframework.kafka.listener.adapter.ConsumerRecordMetadata;
import org.springframework.kafka.support.serializer.JsonSerializer;
import org.springframework.kafka.test.context.EmbeddedKafka;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
import java.time.Duration;
+import java.time.LocalDateTime;
import java.util.*;
-import java.util.concurrent.ExecutionException;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
-import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public static final int PARTITIONS = 10;
- StringSerializer stringSerializer = new StringSerializer();
-
@Autowired
Serializer valueSerializer;
@Autowired
KafkaProducer<String, Bytes> kafkaProducer;
@Autowired
- org.apache.kafka.clients.consumer.Consumer<String, ClientMessage> kafkaConsumer;
- @Autowired
KafkaConsumer<Bytes, Bytes> offsetConsumer;
@Autowired
ApplicationProperties applicationProperties;
@Autowired
EndlessConsumer endlessConsumer;
@Autowired
- RecordHandler recordHandler;
+ MessageHandler<ClientMessage> clientMessageHandler;
+ @Autowired
+ MessageHandler<Greeting> greetingsHandler;
Map<TopicPartition, Long> oldOffsets;
Map<TopicPartition, Long> newOffsets;
- Set<ConsumerRecord<String, ClientMessage>> receivedRecords;
+ Set<Object> received;
/** Tests methods */
@Test
- void commitsCurrentOffsetsOnSuccess() throws ExecutionException, InterruptedException
+ void commitsCurrentOffsetsOnSuccess()
+ {
+ send100Messages((key, counter) -> serializeAsClientMessage(key, counter));
+
+ await("100 records received")
+ .atMost(Duration.ofSeconds(30))
+ .until(() -> received.size() == 100);
+
+ await("Offsets committed")
+ .atMost(Duration.ofSeconds(10))
+ .untilAsserted(() ->
+ {
+ checkSeenOffsetsForProgress();
+ compareToCommitedOffsets(newOffsets);
+ });
+
+ assertThat(endlessConsumer.isRunning())
+ .describedAs("Consumer should still be running")
+ .isTrue();
+ }
+
+
+ @Test
+ void mixedMessages()
{
- send100Messages((key, counter) -> serialize(key, counter));
+ send100Messages((key, counter) ->
+ counter%3 == 0
+ ? serializeAsGreeting(key)
+ : serializeAsClientMessage(key, counter));
await("100 records received")
.atMost(Duration.ofSeconds(30))
- .until(() -> receivedRecords.size() == 100);
+ .until(() -> received.size() == 100);
await("Offsets committed")
.atMost(Duration.ofSeconds(10))
{
send100Messages((key, counter) ->
counter == 77
- ? new Bytes(stringSerializer.serialize(TOPIC, "BOOM!"))
- : serialize(key, counter));
+ ? serializeString("BOOM!", "message")
+ : serializeAsClientMessage(key, counter));
await("99 records received")
.atMost(Duration.ofSeconds(30))
- .until(() -> receivedRecords.size() == 99);
+ .until(() -> received.size() == 99);
await("Offsets committed")
.atMost(Duration.ofSeconds(10))
@Test
void commitsOffsetOnProgramLogicErrorFoo()
{
- recordHandler.testHandler = (record) ->
+ clientMessageHandler.testHandler = (clientMessage, metadata) ->
{
- if (Integer.parseInt(record.value().message)%10 ==0)
- throw new RuntimeException("BOOM: " + record.value().message + "%10 == 0");
+ if (Integer.parseInt(clientMessage.message)%10 ==0)
+ throw new RuntimeException("BOOM: " + clientMessage.message + "%10 == 0");
};
- send100Messages((key, counter) -> serialize(key, counter));
+ send100Messages((key, counter) -> serializeAsClientMessage(key, counter));
await("80 records received")
.atMost(Duration.ofSeconds(30))
- .until(() -> receivedRecords.size() == 100);
+ .until(() -> received.size() == 100);
await("Offsets committed")
.atMost(Duration.ofSeconds(10))
}
- void send100Messages(BiFunction<Integer, Long, Bytes> messageGenerator)
+ void send100Messages(BiFunction<Integer, Long, BytesAndType> recordGenerator)
{
long i = 0;
{
for (int key = 0; key < 10; key++)
{
- Bytes value = messageGenerator.apply(key, ++i);
+ BytesAndType bat = recordGenerator.apply(key, ++i);
ProducerRecord<String, Bytes> record =
new ProducerRecord<>(
TOPIC,
partition,
Integer.toString(key%2),
- value);
+ bat.getValue());
- record.headers().add("__TypeId__", "message".getBytes());
+ record.headers().add("__TypeId__", bat.getType());
kafkaProducer.send(record, (metadata, e) ->
{
if (metadata != null)
}
}
- Bytes serialize(Integer key, Long value)
+ BytesAndType serializeAsClientMessage(Integer key, Long value)
{
ClientMessage message = new ClientMessage();
message.setClient(key.toString());
message.setMessage(value.toString());
+ return new BytesAndType(serialize(message), "message");
+ }
+
+ BytesAndType serializeAsGreeting(Integer key)
+ {
+ Greeting greeting = new Greeting();
+ greeting.setName(key.toString());
+ greeting.setWhen(LocalDateTime.now());
+ return new BytesAndType(serialize(greeting), "greeting");
+ }
+
+ BytesAndType serializeString(String message, String messageType)
+ {
+ return new BytesAndType(new Bytes(message.getBytes()), messageType);
+ }
+
+ Bytes serialize(Object message)
+ {
return new Bytes(valueSerializer.serialize(TOPIC, message));
}
@BeforeEach
public void init()
{
- recordHandler.testHandler = (record) -> {};
+ clientMessageHandler.testHandler = (clientMessage, metadata) -> {};
+ greetingsHandler.testHandler = (greeting, metadata) -> {};
oldOffsets = new HashMap<>();
newOffsets = new HashMap<>();
- receivedRecords = new HashSet<>();
+ received = new HashSet<>();
doForCurrentOffsets((tp, offset) ->
{
newOffsets.put(tp, offset - 1);
});
- recordHandler.captureOffsets =
- record ->
+ BiConsumer<?, ConsumerRecordMetadata> captureOffsets =
+ (clientMessage, metadata) ->
{
- receivedRecords.add(record);
- log.debug("TEST: Processing record #{}: {}", receivedRecords.size(), record.value());
+ received.add(clientMessage);
+ log.debug("TEST: Processing record #{}: {}", received.size(), clientMessage);
newOffsets.put(
- new TopicPartition(record.topic(), record.partition()),
- record.offset());
+ new TopicPartition(metadata.topic(), metadata.partition()), metadata.offset());
};
+ clientMessageHandler.captureOffsets =
+ (BiConsumer<ClientMessage, ConsumerRecordMetadata>)captureOffsets;
+ greetingsHandler.captureOffsets =
+ (BiConsumer<Greeting, ConsumerRecordMetadata>)captureOffsets;
+
endlessConsumer.start();
}
}
}
- public static class RecordHandler implements Consumer<ConsumerRecord<String, ClientMessage>>
+ public static class MessageHandler<T> implements BiConsumer<T, ConsumerRecordMetadata>
{
- Consumer<ConsumerRecord<String, ClientMessage>> captureOffsets;
- Consumer<ConsumerRecord<String, ClientMessage>> testHandler;
+ BiConsumer<T, ConsumerRecordMetadata> captureOffsets;
+ BiConsumer<T, ConsumerRecordMetadata> testHandler;
@Override
- public void accept(ConsumerRecord<String, ClientMessage> record)
+ public void accept(T message, ConsumerRecordMetadata metadata)
{
captureOffsets
.andThen(testHandler)
- .accept(record);
+ .accept(message, metadata);
}
}
{
@Primary
@Bean
- public Consumer<ConsumerRecord<String, ClientMessage>> testHandler()
+ public MessageHandler<ClientMessage> messageHandler()
{
- return new RecordHandler();
+ return new MessageHandler<>();
+ }
+
+ @Primary
+ @Bean
+ public MessageHandler<Greeting> greetingsHandler()
+ {
+ return new MessageHandler<>();
}
@Bean
return new KafkaConsumer<>(props);
}
}
+
+
+ @Value
+ static class BytesAndType
+ {
+ private final Bytes value;
+ private final byte[] type;
+
+
+ BytesAndType(Bytes value, String type)
+ {
+ this.value = value;
+ this.type = type.getBytes();
+ }
+ }
}
projects / demos / kafka / training / blobdiff