org.springframework.cloud.stream.annotation

Annotation Type StreamListener

@Target(value={METHOD,ANNOTATION_TYPE})
 @Retention(value=RUNTIME)
 @MessageMapping
 @Documented
public @interface StreamListener

Annotation that marks a method to be a listener to inputs declared via EnableBinding (e.g. channels). Annotated methods are allowed to have flexible signatures, which determine how the method is invoked and how their return results are processed. This annotation can be applied for two separate classes of methods.

Declarative mode

A method is considered declarative if all its method parameter types and return type (if not void) are binding targets or conversion targets from binding targets via a registered StreamListenerParameterAdapter. Only declarative methods can have binding targets or conversion targets as arguments and return type. Declarative methods must specify what inputs and outputs correspond to their arguments and return type, and can do this in one of the following ways.

• By using either the Input or Output annotation for each of the parameters and the Output annotation on the method for the return type (if applicable). The use of annotations in this case is mandatory. In this case the StreamListener annotation must not specify a value.
• By setting an Input bound target as the annotation value of StreamListener and using SendTo
on the method for the return type (if applicable). In this case the method must have exactly one parameter, corresponding to an input.

An example of declarative method signature using the former idiom is as follows:

 
 @StreamListener
 public @Output("joined") Flux<String> join(
       &#64;Input("input1") Flux<String> input1,
       &#64;Input("input2") Flux<String> input2) {
   // ... join the two input streams via functional operators
 }
 
 

An example of declarative method signature using the latter idiom is as follows:

 
 @StreamListener(Processor.INPUT)
 @SendTo(Processor.OUTPUT)
 public Flux<String> convert(Flux<String> input) {
     return input.map(String::toUppercase);
 }
 
 

Declarative methods are invoked only once, when the context is refreshed.

Individual message handler mode

Non declarative methods are treated as message handler based, and are invoked for each incoming message received from that target. In this case, the method can have a flexible signature, as described by MessageMapping. If the method returns a Message, the result will be automatically sent to a binding target, as follows:

• A result of the type Message will be sent as-is
• All other results will become the payload of a Message

The output binding target where the return message is sent is determined by consulting in the following order:

• The MessageHeaders of the resulting message.
• The value set on the SendTo annotation, if present

An example of individual message handler signature is as follows:

 {@code

Author:

Marius Bogoevici, Ilayaperumal Gopinathan

See Also:

MessageMapping}, EnableBinding}, org.springframework.messaging.handler.annotation.SendTo}

Optional Element Summary

Optional Elements

Modifier and Type	Optional Element and Description
String	value The name of the binding target (e.g.

Element Detail

value

public abstract String value

The name of the binding target (e.g. channel) that the method subscribes to.

Default:

""