Support Functional Interface for Batch Message Listener

[Darshanbc]

Currently, in Java, default methods in functional interfaces cannot be overridden using lambda expressions. While functional interfaces are designed to simplify code using lambdas, default methods are excluded from this flexibility.

@FunctionalInterface
public interface MessageListener<T> {
    void onMessage(Message<T> message);

    default void onMessage(Collection<Message<T>> messages) {
        throw new UnsupportedOperationException("Batch not implemented by this MessageListener");
    }
}

If I want to override the
onMessage(Collection<Message<T>> messages)
method using a lambda, the following code is invalid

 
 MessageListener<String> listener = messages -> {
    messages.forEach(msg -> System.out.println(msg.getContent()));
};

Solution:
Have Separate Functional Interfaces:
Define separate interfaces for single and batch processing. However, this creates redundancy and bloats the codebase.

[shreyas957]

@Darshanbc You're correct that default methods in functional interfaces cannot be overridden using lambda expressions, as lambdas can only target the single abstract method of a functional interface. This is a design limitation in Java.

To address your specific use case, while avoiding redundancy or bloating the codebase with multiple interfaces, you can use an anonymous class to provide an implementation for the onMessage(Collection<Message> messages) method alongside the lambda for the single message handling:

MessageListener<String> listener = new MessageListener<>() {
    @Override
    public void onMessage(Message<String> message) {
        System.out.println(message.getContent());
    }

    @Override
    public void onMessage(Collection<Message<String>> messages) {
        messages.forEach(msg -> System.out.println(msg.getContent()));
    }
};

This approach avoids creating multiple interfaces while giving you flexibility to override the onMessage method for batch processing.

Java's current lambda behavior only targets the single abstract method (SAM) in a functional interface, so a direct workaround isn't possible without changes to the API design.
So either create second lambda expression or modify the default method to call another method that can be overridden with a lambda-friendly design. For example:

@FunctionalInterface
public interface MessageListener<T> {
    void onMessage(Message<T> message);

    default void onMessage(Collection<Message<T>> messages) {
        messages.forEach(this::handleSingleMessage);
    }

    default void defaultBehaviour(Message<T> message) {
        throw new UnsupportedOperationException("Single message handling not implemented");
}

CC : @maciejwalkowiak