Necessity of KafkaHandler on single method class

[vitorsalves]

Hi everyone,
Quick question, in a recent project i had to implement serval KafkaListener all with similar annotations and i wanted to combine them in to one (In my case it was @component, @ConditionalOnProperty and @KafkaListener). However even if all my classes only had a singular method i still had to add @KafkaHandler. While this isn't a huge issue, it does feel a bit redundant.

I understand very well the need of @KafkaHandler in a multimethod @KafkaListener, but in the case a singular method class it seems unnecessary. So i ask, is there a reason that in the case of a class-level annotated KafkaListener with only a singular method, KafkaHandler is still required?

[artembilan]

We will think about that , but why put @KafkaListener on the class level if you have only one method? That is kinda a goal of @KafkaHandler - have something common for multi-method case.

[vitorsalves]

I'll give an example to better illustrate what i mean:

Lets say i have multiple integration but they depend on a specific property:

@Component
@ConditionalOnProperty("property")
public class Topic1Listener {

    @KafkaListener(topics = "topic1", containerFactory = "containerFactory", errorHandler = "errorHandler")
    public void listen(String message) {
        System.out.println("Message received from topic 1: " + message);
    }
}

@Component
@ConditionalOnProperty("property")
public class Topic2Listener {

    @KafkaListener(topics = "topic2", containerFactory = "containerFactory", errorHandler = "errorHandler")
    public void listen(String message) {
        System.out.println("Message received from topic 2: " + message);
    }
}

The idea is to reduce the duplicate code and simplify the implementation of the listeners:

@Component
@KafkaListener(containerFactory = "containerFactory", errorHandler = "errorHandler")
@ConditionalOnProperty("property")
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface DefaultKafkaListener {

    @AliasFor(annotation = KafkaListener.class)
    String[] topics() default {};
}

@DefaultKafkaListener(topics = "topic1")
public class Topic1Listener {

    public void listen(String message) {
        System.out.println("Message received from topic 1: " + message);
    }
}

@DefaultKafkaListener(topics = "topic2")
public class Topic2Listener {

    public void listen(String message) {
        System.out.println("Message received from topic 2: " + message);
    }
}

However with how KafkaListenerAnnotationBeanPostProcessor works now, i have to always add @KafkaHandler:

@DefaultKafkaListener(topics = "topic1")
public class Topic1Listener {

    @KafkaHandler
    public void listen(String message) {
        System.out.println("Message received from topic 1: " + message);
    }
}

@DefaultKafkaListener(topics = "topic2")
public class Topic2Listener {

    @KafkaHandler
    public void listen(String message) {
        System.out.println("Message received from topic 2: " + message);
    }
}

Again this isn't a huge issue, but it does feel a bit redundant and doesn't allow the full benefit of composite annotations.

[artembilan]

Right. I see your point.

@sobychacko ,

WDYT if we make that @KafkaHandler parser to fallback to a single non-private method in the class?
Surely, that could be just a new feature for our 4.0.0.

[sobychacko]

That sounds like a reasonable thing to do in 4.0.0.

[vitorsalves]

Thank you both for the reply!

Do you need me to create a issue or will you guys handle it on your end?

[artembilan]

Done: #3807.

Most likely for the next 4.0.0 milestone.
Not sure when: April or May, or even June.
Either way this feature will be aimed for GA in November release train.

[artembilan]

Hi, @vitorsalves !

Please, take a look into this PR: #3865.

After working on a code and considering some scenarios, we decided to not accept this feature.
And rather go only existing single restriction where a @KafkaHandler is required to be explicit on the method purpose.
If we don't have an annotation on the method, even if it is a single one, there is no guarantee that the class won't be extended for more method or other purposes.
When we have an explicit @KafkaHandler, there is no way we could be confused.

Thanks for understanding!