org.springframework.integration.handler
Class ArgumentArrayMessageMapper
java.lang.Object
org.springframework.integration.handler.ArgumentArrayMessageMapper
- All Implemented Interfaces:
- BeanFactoryAware, InboundMessageMapper<Object[]>
public class ArgumentArrayMessageMapper
- extends Object
- implements InboundMessageMapper<Object[]>, BeanFactoryAware
A Message Mapper implementation that supports mapping from a Message
to an argument array when invoking handler methods, and mapping to a
Message from an argument array when invoking gateway methods.
When mapping from a Message, the method parameters are matched
against the Message, its payload as well as its headers. A message or
payload parameter must not be annotated, and there can be at most one of
these. In certain special cases, more than one non-annotated parameter can
be used (more on this later), but there should always be at most one
parameter that is expecting the message or its payload.
If a method parameter is annotated with @Header
, the
annotation's value will be used as a header name. If such an annotation
contains no value, then the parameter name will be used as long as the
information is available in the class file (requires compilation with debug
settings for parameter names).
In addition a Map or Properties parameter can receive multiple message
headers. In the case of a Map argument, all headers will be passed, but in
the case of a Properties argument, only the headers with String-typed values
will be passed. These parameters can be labeled explicitly with the
@Headers
annotation, or matched implicitly by using a non-
ambiguous method signature. There can be as many parameters annotated with
@Header
as necessary, but typically there should be only one parameter
expecting multiple headers (with or without the @Headers
annotation).
If a Map or Properties object is expected, and the payload is not itself
assignable to that type or capable of being converted to that type, then
the MessageHeaders' values will be passed in the case of a Map-typed
parameter, or the MessageHeaders' String-based values will be passed in the
case of a Properties-typed parameter. In these cases multiple unannotated
parameters are legal. If, however, the actual payload type is a Map or
Properties instance, then this ambiguity cannot be resolved. For that
reason, it is highly recommended to use the explicit
Headers @Headers
annotation whenever possible.
Some examples of legal method signatures:
public void dealWith(Object payload);
public void dealWith(Message message);
public void dealWith(@Header String myHeader, Object payload);
public void dealWith(@Header String myHeader, @Header String anotherHeader);
public void dealWith(@Headers Map headers, Object payload);
public void dealWith(@Headers Properties headers, Map payload);
public void dealWith(Properties headers, Object payload);
Some examples of illegal method signatures:
public void dealWith(Object payload, String payload);
public void dealWith(Message message, Object payload);
public void dealWith(Properties headers, Map payload);
- Since:
- 2.0
- Author:
- Mark Fisher, Iwein Fuld, Oleg Zhurakousky
Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
ArgumentArrayMessageMapper
public ArgumentArrayMessageMapper(Method method)
ArgumentArrayMessageMapper
public ArgumentArrayMessageMapper(Method method,
Map<String,Object> staticHeaders)
setPayloadExpression
public void setPayloadExpression(String expressionString)
setBeanFactory
public void setBeanFactory(BeanFactory beanFactory)
- Specified by:
setBeanFactory
in interface BeanFactoryAware
toMessage
public Message<?> toMessage(Object[] arguments)
- Specified by:
toMessage
in interface InboundMessageMapper<Object[]>
Copyright © 2010. All Rights Reserved.