no.nav.common.kafka.consumer.util.KafkaConsumerClientBuilder Maven / Gradle / Ivy

Go to download
package no.nav.common.kafka.consumer.util;

import io.micrometer.core.instrument.MeterRegistry;
import no.nav.common.kafka.consumer.KafkaConsumerClient;
import no.nav.common.kafka.consumer.KafkaConsumerClientConfig;
import no.nav.common.kafka.consumer.TopicConsumer;
import no.nav.common.kafka.consumer.feilhandtering.KafkaConsumerRepository;
import no.nav.common.kafka.consumer.feilhandtering.StoreOnFailureTopicConsumer;
import org.apache.kafka.common.serialization.Serializer;

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

public class KafkaConsumerClientBuilder {

    private final Map> consumerMap = new HashMap<>();

    private final Map> consumersWithErrorHandlingMap = new HashMap<>();

    private Properties properties;

    private long pollDurationMs = -1;

    private KafkaConsumerRepository consumerRepository;

    private Serializer keySerializer;

    private Serializer valueSerializer;

    private boolean enableLogging;

    private MeterRegistry meterRegistry;

    private KafkaConsumerClientBuilder() {}

    public static  KafkaConsumerClientBuilder builder() {
        return new KafkaConsumerClientBuilder();
    }

    public KafkaConsumerClientBuilder withProps(Properties properties) {
        this.properties = properties;
        return this;
    }

    public KafkaConsumerClientBuilder withConsumer(String topic, TopicConsumer consumer) {
        consumerMap.put(topic, consumer);
        return this;
    }

    public KafkaConsumerClientBuilder withConsumers(Map> topicConsumers) {
        consumerMap.putAll(topicConsumers);
        return this;
    }

    public KafkaConsumerClientBuilder withStoreOnFailureConsumer(String topic, TopicConsumer topicConsumer) {
        consumersWithErrorHandlingMap.put(topic, topicConsumer);
        return this;
    }

    public KafkaConsumerClientBuilder withStoreOnFailureConsumers(Map> topicConsumers) {
        consumersWithErrorHandlingMap.putAll(topicConsumers);
        return this;
    }

    public KafkaConsumerClientBuilder withLogging() {
        this.enableLogging = true;
        return this;
    }

    public KafkaConsumerClientBuilder withMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        return this;
    }

    public KafkaConsumerClientBuilder withRepository(KafkaConsumerRepository consumerRepository) {
        this.consumerRepository = consumerRepository;
        return this;
    }

    public KafkaConsumerClientBuilder withSerializers(Serializer keySerializer, Serializer valueSerializer) {
        this.keySerializer = keySerializer;
        this.valueSerializer = valueSerializer;
        return this;
    }

    public KafkaConsumerClientBuilder withPollDuration(long pollDurationMs) {
        this.pollDurationMs = pollDurationMs;
        return this;
    }

    public KafkaConsumerClient build() {
        if (properties == null) {
            throw new IllegalStateException("Cannot build kafka consumer without properties");
        }

        if (!consumersWithErrorHandlingMap.isEmpty()) {
            if (consumerRepository == null) {
                throw new IllegalStateException("Consumer repository is required when using error handling");
            }

            if (keySerializer == null || valueSerializer == null) {
                throw new IllegalStateException("Key serializer and value serializer is required when using error handling");
            }
        }

        consumersWithErrorHandlingMap.forEach((topic, consumer) -> {
            consumerMap.put(topic, new StoreOnFailureTopicConsumer<>(consumer, consumerRepository, keySerializer, valueSerializer));
        });

        Map> extendedConsumers = new HashMap<>();

        consumerMap.forEach((topic, consumer) -> {
            TopicConsumerBuilder builder = TopicConsumerBuilder.builder();

            if (enableLogging) {
                builder.withLogging();
            }

            if (meterRegistry != null) {
                builder.withMetrics(meterRegistry);
            }

            builder.withConsumer(consumer);

            extendedConsumers.put(topic, builder.build());
        });

        KafkaConsumerClientConfig config = new KafkaConsumerClientConfig<>(properties, extendedConsumers);

        if (pollDurationMs >= 0) {
            config.setPollDurationMs(pollDurationMs);
        }

        return new KafkaConsumerClient<>(config);
    }

}