Type resolution with deep generic hierarchies is incorrect

[ferblaca]

Describe the issue
When using Spring Cloud Stream with Kafka (Spring Boot 3.5.7, Spring Cloud 2025.0.0), consumer bindings that utilize generic types fail to process messages if the bean is defined as a concrete implementation class rather than as the functional interface type (Consumer<T>, Consumer<Message<T>>, etc.). This issue affects both batch and single (default) consumption modes, though the specific errors differ between modes.

Working vs. Failing Pattern

✅ Working pattern – Bean declared as functional interface:

@Bean
public Consumer<List<ProductCompleteDTO>> productBatchListConsumer2() {
    return new GenericBatchListConsumer<>("productBatchListConsumer2");
}

❌ Failing pattern – Bean declared as concrete implementation:

@Bean
public GenericBatchListConsumer<ProductCompleteDTO> productBatchListConsumer() {
    return new GenericBatchListConsumer<>("productBatchListConsumer");
}

Detailed Observations

Considering the consumer beans defined in the ConfigurationApp class of the sample repository:

Single Mode Behavior:

• productConsumer defined as GenericConsumer<ProductCompleteDTO>: ✅ Works correctly
• productConsumer2 defined as Consumer<ProductCompleteDTO>: ✅ Works correctly
• productMessageConsumer defined as GenericMessageConsumer<ProductCompleteDTO>: ❌ Fails with class cast error
• productMessageConsumer2 defined as Consumer<Message<ProductCompleteDTO>>: ✅ Works correctly

Batch Mode Behavior:

• productBatchListConsumer defined as GenericBatchListConsumer<ProductCompleteDTO>: ❌ Fails with conversion error
• productBatchListConsumer2 defined as Consumer<List<ProductCompleteDTO>>: ✅ Works correctly
• productBatchListMessageConsumer defined as GenericBatchMessageListConsumer<ProductCompleteDTO>: ❌ Fails with conversion error
• productBatchListMessageConsumer2 defined as Consumer<Message<List<ProductCompleteDTO>>>: ✅ Works correctly

Note

The common factor in all failing cases is the combination of Bean declared as a concrete implementation class (not interface)

Note

In the case of the productConsumer definition, which is declared as a concrete implementation GenericConsumer<ProductCompleteDTO>, it does work correctly. This is the only case observed that works with a concrete implementation class.

Error Examples

Batch Mode Error (attempting to convert List to single DTO):

Caused by: org.springframework.core.convert.ConversionFailedException: Failed to convert from type [java.util.ArrayList<?>] to type [com.example.demoStreamKafka.dto.ProductCompleteDTO] for value [[...]]
    at org.springframework.core.convert.support.ConversionUtils.invokeConverter(ConversionUtils.java:47)
    at org.springframework.cloud.function.context.catalog.SimpleFunctionRegistry$FunctionInvocationWrapper.convertNonMessageInputIfNecessary(SimpleFunctionRegistry.java:1312)

Single Mode Error (attempting to cast DTO to Message):

Caused by: java.lang.ClassCastException: class com.example.demoStreamKafka.dto.ProductCompleteDTO cannot be cast to class org.springframework.messaging.Message
    at com.example.demoStreamKafka.consumer.GenericMessageConsumer.accept(GenericMessageConsumer.java:9)
    at org.springframework.cloud.function.context.catalog.SimpleFunctionRegistry$FunctionInvocationWrapper.invokeConsumer(SimpleFunctionRegistry.java:1056)

To Reproduce

1. Clone the sample project: https://github.com/ferblaca/demoStreamGenerics/tree/upgrade_to_2025_0_0
2. Start the project (Kafka in KRaft mode via Docker Compose will launch automatically)
3. Observe the logs for conversion and class cast exceptions in the failing consumer bindings

Expected behavior

All consumer bindings using generic types should work consistently.

Thank you in advance!

[sobychacko]

@ferblaca Do you think this is caused by regression? If that is the case, could you try debugging and find out what is causing the regression? Thanks!

[ferblaca]

Hi @sobychacko,

thank you very much for your quick response.

I haven't been able to investigate much further yet, but I will.

This issue seems to have happened in the past and was apparently fixed. Specifically, it now seems to only be affecting Batch mode.

[sobychacko]

Looking at the other issue you mentioned, @olegz might have fixed this before. Let's see if he has any insights on this.

[ferblaca]

Hi @sobychacko,

I kept reviewing this and I see that for consumers with generics in single-mode there are also errors during consumption, specifically for the implementation public class GenericMessageConsumer<T> implements Consumer<Message<T>> {.

I will update the issue to reflect this behavior.

[ferblaca]

Hi @sobychacko ,

I have updated the issue to clarify that there are also problems with non-batch consumers using generics. I have tried to make it as clear as possible, although it is a little complex.

If there have been previous issues with defining consumers using generics, and similar problems still persist (even if the failure modes have changed), it might be advisable to mention in the documentation that this type of implementation is not recommended. Alternatively, if generics are to be used, it would be helpful to provide clear guidance or best practices on how to define them correctly, so that teams can avoid these issues in their projects

[olegz]

I was able to reproduce it, so let me see what is going on

[olegz]

It is most likely a regression after refactoring FunctionTypeUtils a while back. Basically it does not recognise that thsi function is a Message function via isMessage

[olegz]

Actually I am now wondering if it ever worked give n the type complexity this case presents - the long hierarchy of generics . . .
I believe i have a way of making it work, but still curious . . .

[olegz]

Transferring this to s-c-functions as the issue is really with Type resolution and is actually related to spring-projects/spring-framework#33887

I already have a fix, just need a bit more testing . Should be merged tomorrow