Recoverycallback is running 2 times during retry message in spring kafka 2.2.0 - spring-boot

Question

I'm retrying message n times in main topic then after maxattempt exhausted publishing it in DLT topic. But when it gets exhausted calling recoverycallback where I'm throwing custom exception so that errorhandler handler the error using seektocurrenthandler and publish message in the DLT topic. But after n retries it goes in recoverycallback then throw the exception but instead of calling errorhandler it again retying n times calling recoverycallback then handle error in errorhandler. I have tried so many example but didn't work
It's flow like that...................
n retries-> recoverycallback -> again n retries -> recoverycallback ->errorhandler.
public class KafkaQueueConfiguration {
private static Logger log = LoggerFactory.getLogger(KafkaQueueConfiguration.class);
#Autowired
private StringRedisTemplate redisTemplate;
#Value("${bootstrap.ip}")
private String consumerBootstrap;
#Value("${group.id}")
private String consumerGroupId;
#Value("${consumer.offset.type}")
private String autoOffsetType;
#Value("${kafka.backoff.interval}")
private Long fixedInterval;
#Value("${kafka.maximum.poll.records}")
private Integer maxPollRecords;
#Value("${bank-notification-sasl-jaas-config}")
private String saslJaasConfig;
#Value("${bank-notification-json-type-mapping}")
private String jsonTypeMapping;
#Value("${bank-notification-dejson-delegate}")
private String deJsonDelegate;
#Value("${kafka.topics.bank.notification.dlt}")
private String dlqName;
#Value("${kafka-consumer-saslMechanism}")
private String saslMechanism;
#Value("${kafka-consumer-securityProtocol}")
private String securityProtocol;
#Value(("${heartbeat-interval-ms}"))
private String heartbeatInterval;
#Value(("${session-timeout-ms}"))
private String sessionTimeout;
#Value(("${max-poll-interval-ms}"))
private Integer maxPollInterval;
#Value(("${max-retry-attempt-ms}"))
private Integer maxRetryAttempts;
#Value(("${retry-interval-ms}"))
private long retryInterval;
#Bean
public Map<String, Object> consumerConfigs() {
Map<String, Object> props = new HashMap<>();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, consumerBootstrap);
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, ErrorHandlingDeserializer.class);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class);
props.put(ConsumerConfig.GROUP_ID_CONFIG, consumerGroupId);
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetType);
props.put(ConsumerConfig.RETRY_BACKOFF_MS_CONFIG,fixedInterval);
props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG,maxPollInterval);
props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG,maxPollRecords);
props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeout);
props.put(SaslConfigs.SASL_JAAS_CONFIG,saslJaasConfig);
props.put(JsonDeserializer.TYPE_MAPPINGS,jsonTypeMapping);
props.put(SaslConfigs.SASL_MECHANISM,saslMechanism);
props.put(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG,securityProtocol);
props.put(ErrorHandlingDeserializer.VALUE_DESERIALIZER_CLASS,deJsonDelegate);
props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG,heartbeatInterval);
props.put(SslConfigs.SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG ,SslConfigs.DEFAULT_SSL_ENDPOINT_IDENTIFICATION_ALGORITHM);
return props;
}
#Bean
public ConsumerFactory<Object, Object> consumerFactory() {
return new DefaultKafkaConsumerFactory<>(consumerConfigs());
}
#Bean
public ConcurrentKafkaListenerContainerFactory<Object, Object> kafkaListenerContainerFactory(
ConcurrentKafkaListenerContainerFactoryConfigurer configurer,
ConsumerFactory<Object, Object> kafkaConsumerFactory, KafkaTemplate<Object, Object> template) {
ConcurrentKafkaListenerContainerFactory<Object, Object> factory = new ConcurrentKafkaListenerContainerFactory<>();
factory.setConsumerFactory(consumerFactory());
factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL);
factory.getContainerProperties().setAckOnError(false);
factory.setRetryTemplate(retryTemplate());
factory.setRecoveryCallback((context->{
log.info("Recovery callback");
Acknowledgment ack= (Acknowledgment) context.getAttribute(RetryingMessageListenerAdapter.CONTEXT_ACKNOWLEDGMENT);
log.info("Manually committed..{}",countRecover);
log.info("RetryCount :: {} and last retry exception :: {}",context.getRetryCount(),context.getLastThrowable().getCause().getMessage());
log.info("Retry records :: {}",context.getAttribute(RetryingMessageListenerAdapter.CONTEXT_RECORD));
ConsumerRecord consumerRecord= (ConsumerRecord) context.getAttribute(RetryingMessageListenerAdapter.CONTEXT_RECORD);
EftTransactionDetail eftTransactionDetail= (EftTransactionDetail) consumerRecord.value();
log.info("Retrying records ::{}",eftTransactionDetail);
redisTemplate.opsForValue().setIfAbsent(BankNotificationsConstants.SMS_REDIS_PREFIX + eftTransactionDetail.getAtdEntryId(),eftTransactionDetail.getAtdEntryId());
ack.acknowledge();
throw new ValidationException(SystemTag.HG,context.getLastThrowable().getCause().getMessage(),context.getLastThrowable().getCause().getMessage());
}));
factory.setErrorHandler(errorHandler(publisher(template)));
configurer.configure(factory, kafkaConsumerFactory);
return factory;
}
#Bean
public SeekToCurrentErrorHandler errorHandler(DeadLetterPublishingRecoverer deadLetterPublishingRecoverer) {
return new SeekToCurrentErrorHandler(deadLetterPublishingRecoverer,0);//set maxfailure 0 attempts
}
#Bean
public DeadLetterPublishingRecoverer publisher(KafkaTemplate<Object, Object> template) {
return new DeadLetterPublishingRecoverer(template);
}
public RetryTemplate retryTemplate(){
RetryTemplate retryTemplate = new RetryTemplate();
retryTemplate.setRetryPolicy(new SimpleRetryPolicy(maxRetryAttempts));
FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
backOffPolicy.setBackOffPeriod(retryInterval);
retryTemplate.setBackOffPolicy(backOffPolicy);
return retryTemplate;
}
}