Extracted message-to-args mapping logic from AbstractMessageHandler to MethodArgumentMessageMapper. Defined a separate abstract method in AbstractMessageHandler for post-processing a return value that is already a Message. DefaultMethodInvoker catches an IllegalArgumentException in case the Method instance no longer matches after a Proxy and "resets" the correct Method if it can be determined from the 'methodName' property. Replaced AnnotationMethodTransformerAdapter with TransformerMessageHandler.

org.springframework.integration/src/test/java/org/springframework/integration/handler/CorrelationIdTests.java

@@ -39,22 +39,22 @@ public class CorrelationIdTests {
 		Object correlationId = "123-ABC";
 		Message<String> message = MessageBuilder.fromPayload("test")
 				.setCorrelationId(correlationId).build();
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setObject(new TestBean());
-		adapter.setMethodName("upperCase");
-		adapter.afterPropertiesSet();
-		Message<?> reply = adapter.handle(message);
+		DefaultMessageHandler handler = new DefaultMessageHandler();
+		handler.setObject(new TestBean());
+		handler.setMethodName("upperCase");
+		handler.afterPropertiesSet();
+		Message<?> reply = handler.handle(message);
 		assertEquals(correlationId, reply.getHeaders().getCorrelationId());
 	}
 
 	@Test
 	public void testCorrelationIdCopiedFromMessageIdByDefault() {
 		Message<String> message = MessageBuilder.fromPayload("test").build();
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setObject(new TestBean());
-		adapter.setMethodName("upperCase");
-		adapter.afterPropertiesSet();
-		Message<?> reply = adapter.handle(message);
+		DefaultMessageHandler handler = new DefaultMessageHandler();
+		handler.setObject(new TestBean());
+		handler.setMethodName("upperCase");
+		handler.afterPropertiesSet();
+		Message<?> reply = handler.handle(message);
 		assertEquals(message.getHeaders().getId(), reply.getHeaders().getCorrelationId());
 	}
 
@@ -62,11 +62,11 @@ public class CorrelationIdTests {
 	public void testCorrelationIdCopiedFromMessageCorrelationIdIfAvailable() {
 		Message<String> message = MessageBuilder.fromPayload("test")
 				.setCorrelationId("correlationId").build();
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setObject(new TestBean());
-		adapter.setMethodName("upperCase");
-		adapter.afterPropertiesSet();
-		Message<?> reply = adapter.handle(message);
+		DefaultMessageHandler handler = new DefaultMessageHandler();
+		handler.setObject(new TestBean());
+		handler.setMethodName("upperCase");
+		handler.afterPropertiesSet();
+		Message<?> reply = handler.handle(message);
 		assertEquals(message.getHeaders().getCorrelationId(), reply.getHeaders().getCorrelationId());
 		assertTrue(message.getHeaders().getCorrelationId().equals(reply.getHeaders().getCorrelationId()));
 	}

org.springframework.integration/src/test/java/org/springframework/integration/handler/DefaultMessageHandlerAdapterTests.java

@@ -1,123 +0,0 @@
-/*
- * Copyright 2002-2008 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.integration.handler;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-
-import org.springframework.integration.message.Message;
-import org.springframework.integration.message.StringMessage;
-
-/**
- * @author Mark Fisher
- */
-public class DefaultMessageHandlerAdapterTests {
-
-	@Test
-	public void testPayloadAsMethodParameterAndObjectAsReturnValue() {
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setObject(new TestHandler());
-		adapter.setMethodName("acceptPayloadAndReturnObject");
-		adapter.afterPropertiesSet();
-		Message<?> result = adapter.handle(new StringMessage("testing"));
-		assertEquals("testing-1", result.getPayload());
-	}
-
-	@Test
-	public void testPayloadAsMethodParameterAndMessageAsReturnValue() {
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setObject(new TestHandler());
-		adapter.setMethodName("acceptPayloadAndReturnMessage");
-		adapter.afterPropertiesSet();
-		Message<?> result = adapter.handle(new StringMessage("testing"));
-		assertEquals("testing-2", result.getPayload());
-	}
-
-	@Test
-	public void testMessageAsMethodParameterAndObjectAsReturnValue() {
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setMethodExpectsMessage(true);
-		adapter.setObject(new TestHandler());
-		adapter.setMethodName("acceptMessageAndReturnObject");
-		adapter.afterPropertiesSet();
-		Message<?> result = adapter.handle(new StringMessage("testing"));
-		assertEquals("testing-3", result.getPayload());
-	}
-
-	@Test
-	public void testMessageAsMethodParameterAndMessageAsReturnValue() {
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setMethodExpectsMessage(true);
-		adapter.setObject(new TestHandler());
-		adapter.setMethodName("acceptMessageAndReturnMessage");
-		adapter.afterPropertiesSet();
-		Message<?> result = adapter.handle(new StringMessage("testing"));
-		assertEquals("testing-4", result.getPayload());
-	}
-
-	@Test
-	public void testMessageSubclassAsMethodParameterAndMessageAsReturnValue() {
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setMethodExpectsMessage(true);
-		adapter.setObject(new TestHandler());
-		adapter.setMethodName("acceptMessageSubclassAndReturnMessage");
-		adapter.afterPropertiesSet();
-		Message<?> result = adapter.handle(new StringMessage("testing"));
-		assertEquals("testing-5", result.getPayload());
-	}
-
-	@Test
-	public void testMessageSubclassAsMethodParameterAndMessageSubclassAsReturnValue() {
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setMethodExpectsMessage(true);
-		adapter.setObject(new TestHandler());
-		adapter.setMethodName("acceptMessageSubclassAndReturnMessageSubclass");
-		adapter.afterPropertiesSet();
-		Message<?> result = adapter.handle(new StringMessage("testing"));
-		assertEquals("testing-6", result.getPayload());
-	}
-
-
-	private static class TestHandler {
-
-		public String acceptPayloadAndReturnObject(String s) {
-			return s + "-1";
-		}
-
-		public Message<?> acceptPayloadAndReturnMessage(String s) {
-			return new StringMessage(s + "-2");
-		}
-
-		public String acceptMessageAndReturnObject(Message<?> m) {
-			return m.getPayload() + "-3";
-		}
-
-		public Message<?> acceptMessageAndReturnMessage(Message<?> m) {
-			return new StringMessage(m.getPayload() + "-4");
-		}
-
-		public Message<?> acceptMessageSubclassAndReturnMessage(StringMessage m) {
-			return new StringMessage(m.getPayload() + "-5");
-		}
-
-		public StringMessage acceptMessageSubclassAndReturnMessageSubclass(StringMessage m) {
-			return new StringMessage(m.getPayload() + "-6");
-		}
-	}
-
-}

org.springframework.integration/src/test/java/org/springframework/integration/handler/DefaultMessageHandlerTests.java

@@ -0,0 +1,264 @@
+/*
+ * Copyright 2002-2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.handler;
+
+import static org.junit.Assert.assertEquals;
+
+import java.lang.reflect.Method;
+import java.util.Map;
+import java.util.Properties;
+
+import org.junit.Test;
+
+import org.springframework.integration.annotation.Handler;
+import org.springframework.integration.handler.annotation.Header;
+import org.springframework.integration.message.GenericMessage;
+import org.springframework.integration.message.Message;
+import org.springframework.integration.message.MessageBuilder;
+import org.springframework.integration.message.MessagingException;
+import org.springframework.integration.message.StringMessage;
+
+/**
+ * @author Mark Fisher
+ */
+public class DefaultMessageHandlerTests {
+
+	@Test
+	public void payloadAsMethodParameterAndObjectAsReturnValue() {
+		DefaultMessageHandler handler = new DefaultMessageHandler();
+		handler.setObject(new TestHandler());
+		handler.setMethodName("acceptPayloadAndReturnObject");
+		handler.afterPropertiesSet();
+		Message<?> result = handler.handle(new StringMessage("testing"));
+		assertEquals("testing-1", result.getPayload());
+	}
+
+	@Test
+	public void payloadAsMethodParameterAndMessageAsReturnValue() {
+		DefaultMessageHandler handler = new DefaultMessageHandler();
+		handler.setObject(new TestHandler());
+		handler.setMethodName("acceptPayloadAndReturnMessage");
+		handler.afterPropertiesSet();
+		Message<?> result = handler.handle(new StringMessage("testing"));
+		assertEquals("testing-2", result.getPayload());
+	}
+
+	@Test
+	public void messageAsMethodParameterAndObjectAsReturnValue() {
+		DefaultMessageHandler handler = new DefaultMessageHandler();
+		handler.setObject(new TestHandler());
+		handler.setMethodName("acceptMessageAndReturnObject");
+		handler.afterPropertiesSet();
+		Message<?> result = handler.handle(new StringMessage("testing"));
+		assertEquals("testing-3", result.getPayload());
+	}
+
+	@Test
+	public void messageAsMethodParameterAndMessageAsReturnValue() {
+		DefaultMessageHandler handler = new DefaultMessageHandler();
+		handler.setObject(new TestHandler());
+		handler.setMethodName("acceptMessageAndReturnMessage");
+		handler.afterPropertiesSet();
+		Message<?> result = handler.handle(new StringMessage("testing"));
+		assertEquals("testing-4", result.getPayload());
+	}
+
+	@Test
+	public void messageSubclassAsMethodParameterAndMessageAsReturnValue() {
+		DefaultMessageHandler handler = new DefaultMessageHandler();
+		handler.setObject(new TestHandler());
+		handler.setMethodName("acceptMessageSubclassAndReturnMessage");
+		handler.afterPropertiesSet();
+		Message<?> result = handler.handle(new StringMessage("testing"));
+		assertEquals("testing-5", result.getPayload());
+	}
+
+	@Test
+	public void messageSubclassAsMethodParameterAndMessageSubclassAsReturnValue() {
+		DefaultMessageHandler handler = new DefaultMessageHandler();
+		handler.setObject(new TestHandler());
+		handler.setMethodName("acceptMessageSubclassAndReturnMessageSubclass");
+		handler.afterPropertiesSet();
+		Message<?> result = handler.handle(new StringMessage("testing"));
+		assertEquals("testing-6", result.getPayload());
+	}
+
+	@Test
+	public void payloadAndHeaderAnnotationMethodParametersAndObjectAsReturnValue() {
+		DefaultMessageHandler handler = new DefaultMessageHandler();
+		handler.setObject(new TestHandler());
+		handler.setMethodName("acceptPayloadAndHeaderAndReturnObject");
+		handler.afterPropertiesSet();
+		Message<?> request = MessageBuilder.fromPayload("testing")
+				.setHeader("number", new Integer(123)).build();
+		Message<?> result = handler.handle(request);
+		assertEquals("testing-123", result.getPayload());
+	}
+
+	@Test
+	public void messageOnlyWithAnnotatedMethod() throws Exception {
+		AnnotatedTestHandler handler = new AnnotatedTestHandler();
+		Method method = handler.getClass().getMethod("messageOnly", Message.class);
+		DefaultMessageHandler adapter = new DefaultMessageHandler();
+		adapter.setObject(handler);
+		adapter.setMethod(method);
+		Message<?> result = adapter.handle(new StringMessage("foo"));
+		assertEquals("foo", result.getPayload());
+	}
+
+	@Test
+	public void payloadWithAnnotatedMethod() throws Exception {
+		AnnotatedTestHandler handler = new AnnotatedTestHandler();
+		Method method = handler.getClass().getMethod("integerMethod", Integer.class);
+		DefaultMessageHandler adapter = new DefaultMessageHandler();
+		adapter.setObject(handler);
+		adapter.setMethod(method);
+		Message<?> result = adapter.handle(new GenericMessage<Integer>(new Integer(123)));
+		assertEquals(new Integer(123), result.getPayload());
+	}
+
+	@Test
+	public void convertedPayloadWithAnnotatedMethod() throws Exception {
+		AnnotatedTestHandler handler = new AnnotatedTestHandler();
+		Method method = handler.getClass().getMethod("integerMethod", Integer.class);
+		DefaultMessageHandler adapter = new DefaultMessageHandler();
+		adapter.setObject(handler);
+		adapter.setMethod(method);
+		Message<?> result = adapter.handle(new StringMessage("456"));
+		assertEquals(new Integer(456), result.getPayload());
+	}
+
+	@Test(expected = MessagingException.class)
+	public void conversionFailureWithAnnotatedMethod() throws Exception {
+		AnnotatedTestHandler handler = new AnnotatedTestHandler();
+		Method method = handler.getClass().getMethod("integerMethod", Integer.class);
+		DefaultMessageHandler adapter = new DefaultMessageHandler();
+		adapter.setObject(handler);
+		adapter.setMethod(method);
+		Message<?> result = adapter.handle(new StringMessage("foo"));
+		assertEquals(new Integer(123), result.getPayload());
+	}
+
+	@Test
+	public void messageAndHeaderWithAnnotatedMethod() throws Exception {
+		AnnotatedTestHandler handler = new AnnotatedTestHandler();
+		Method method = handler.getClass().getMethod("messageAndHeader", Message.class, Integer.class);
+		DefaultMessageHandler adapter = new DefaultMessageHandler();
+		adapter.setObject(handler);
+		adapter.setMethod(method);
+		Message<String> message = MessageBuilder.fromPayload("foo")
+				.setHeader("number", 42).build();
+		Message<?> result = adapter.handle(message);
+		assertEquals("foo-42", result.getPayload());
+	}
+
+	@Test
+	public void multipleHeadersWithAnnotatedMethod() throws Exception {
+		AnnotatedTestHandler handler = new AnnotatedTestHandler();
+		Method method = handler.getClass().getMethod("twoHeaders", String.class, Integer.class);
+		DefaultMessageHandler adapter = new DefaultMessageHandler();
+		adapter.setObject(handler);
+		adapter.setMethod(method);
+		Message<String> message = MessageBuilder.fromPayload("foo")
+				.setHeader("prop", "bar")
+				.setHeader("number", 42).build();
+		Message<?> result = adapter.handle(message);
+		assertEquals("bar-42", result.getPayload());
+	}
+
+
+	private static class TestHandler {
+
+		public String acceptPayloadAndReturnObject(String s) {
+			return s + "-1";
+		}
+
+		public Message<?> acceptPayloadAndReturnMessage(String s) {
+			return new StringMessage(s + "-2");
+		}
+
+		public String acceptMessageAndReturnObject(Message<?> m) {
+			return m.getPayload() + "-3";
+		}
+
+		public Message<?> acceptMessageAndReturnMessage(Message<?> m) {
+			return new StringMessage(m.getPayload() + "-4");
+		}
+
+		public Message<?> acceptMessageSubclassAndReturnMessage(StringMessage m) {
+			return new StringMessage(m.getPayload() + "-5");
+		}
+
+		public StringMessage acceptMessageSubclassAndReturnMessageSubclass(StringMessage m) {
+			return new StringMessage(m.getPayload() + "-6");
+		}
+
+		public String acceptPayloadAndHeaderAndReturnObject(String s, @Header("number") Integer n) {
+			return s + "-" + n;
+		}
+	}
+
+	private static class AnnotatedTestHandler {
+
+		@Handler
+		public String messageOnly(Message<?> message) {
+			return (String) message.getPayload();
+		}
+
+		@Handler
+		public String messageAndHeader(Message<?> message, @Header("number") Integer num) {
+			return (String) message.getPayload() + "-" + num.toString();
+		}
+
+		@Handler
+		public String twoHeaders(@Header String prop, @Header("number") Integer num) {
+			return prop + "-" + num.toString();
+		}
+
+		@Handler
+		public Integer optionalHeader(@Header(required=false) Integer num) {
+			return num;
+		}
+
+		@Handler
+		public Integer requiredHeader(@Header(value="num", required=true) Integer num) {
+			return num;
+		}
+
+		@Handler
+		public String optionalAndRequiredHeader(@Header(required=false) String prop, @Header(value="num", required=true) Integer num) {
+			return prop + num;
+		}
+
+		@Handler
+		public Properties propertiesMethod(Properties properties) {
+			return properties;
+		}
+
+		@Handler
+		@SuppressWarnings("unchecked")
+		public Map mapMethod(Map map) {
+			return map;
+		}
+
+		@Handler
+		public Integer integerMethod(Integer i) {
+			return i;
+		}
+	}
+
+}

org.springframework.integration/src/test/java/org/springframework/integration/handler/annotation/MethodArgumentMessageMapperTests.java

@@ -27,23 +27,20 @@ import java.util.Properties;
 import org.junit.Test;
 
 import org.springframework.integration.annotation.Handler;
-import org.springframework.integration.handler.DefaultMessageHandlerAdapter;
-import org.springframework.integration.message.GenericMessage;
 import org.springframework.integration.message.Message;
 import org.springframework.integration.message.MessageBuilder;
 import org.springframework.integration.message.MessageHandlingException;
-import org.springframework.integration.message.MessagingException;
 import org.springframework.integration.message.StringMessage;
 
 /**
  * @author Mark Fisher
  */
-public class AnnotationMethodMessageMapperTests {
+public class MethodArgumentMessageMapperTests {
 
 	@Test
 	public void testOptionalHeader() throws Exception {
 		Method method = TestHandler.class.getMethod("optionalHeader", Integer.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
+		MethodArgumentMessageMapper<String> mapper = new MethodArgumentMessageMapper<String>(method);
 		Object[] args = (Object[]) mapper.mapMessage(new StringMessage("foo"));
 		assertEquals(1, args.length);
 		assertNull(args[0]);
@@ -52,14 +49,14 @@ public class AnnotationMethodMessageMapperTests {
 	@Test(expected=MessageHandlingException.class)
 	public void testRequiredHeaderNotProvided() throws Exception {
 		Method method = TestHandler.class.getMethod("requiredHeader", Integer.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
+		MethodArgumentMessageMapper<String> mapper = new MethodArgumentMessageMapper<String>(method);
 		mapper.mapMessage(new StringMessage("foo"));
 	}
 
 	@Test
 	public void testRequiredHeaderProvided() throws Exception {
 		Method method = TestHandler.class.getMethod("requiredHeader", Integer.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
+		MethodArgumentMessageMapper<String> mapper = new MethodArgumentMessageMapper<String>(method);
 		Message<String> message = MessageBuilder.fromPayload("foo")
 				.setHeader("num", new Integer(123)).build(); 
 		Object[] args = (Object[]) mapper.mapMessage(message);
@@ -70,7 +67,7 @@ public class AnnotationMethodMessageMapperTests {
 	@Test(expected=MessageHandlingException.class)
 	public void testOptionalAndRequiredHeaderWithOnlyOptionalHeaderProvided() throws Exception {
 		Method method = TestHandler.class.getMethod("optionalAndRequiredHeader", String.class, Integer.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
+		MethodArgumentMessageMapper<String> mapper = new MethodArgumentMessageMapper<String>(method);
 		Message<String> message = MessageBuilder.fromPayload("foo")
 				.setHeader("prop", "bar").build(); 
 		mapper.mapMessage(message);
@@ -79,7 +76,7 @@ public class AnnotationMethodMessageMapperTests {
 	@Test
 	public void testOptionalAndRequiredHeaderWithOnlyRequiredHeaderProvided() throws Exception {
 		Method method = TestHandler.class.getMethod("optionalAndRequiredHeader", String.class, Integer.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
+		MethodArgumentMessageMapper<String> mapper = new MethodArgumentMessageMapper<String>(method);
 		Message<String> message = MessageBuilder.fromPayload("foo")
 				.setHeader("num", new Integer(123)).build(); 
 		Object[] args = (Object[]) mapper.mapMessage(message);
@@ -91,7 +88,7 @@ public class AnnotationMethodMessageMapperTests {
 	@Test
 	public void testOptionalAndRequiredHeaderWithBothHeadersProvided() throws Exception {
 		Method method = TestHandler.class.getMethod("optionalAndRequiredHeader", String.class, Integer.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
+		MethodArgumentMessageMapper<String> mapper = new MethodArgumentMessageMapper<String>(method);
 		Message<String> message = MessageBuilder.fromPayload("foo")
 				.setHeader("num", new Integer(123))
 				.setHeader("prop", "bar")
@@ -105,7 +102,7 @@ public class AnnotationMethodMessageMapperTests {
 	@Test
 	public void testPropertiesMethodWithNonPropertiesPayload() throws Exception {
 		Method method = TestHandler.class.getMethod("propertiesMethod", Properties.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
+		MethodArgumentMessageMapper<String> mapper = new MethodArgumentMessageMapper<String>(method);
 		Message<String> message = MessageBuilder.fromPayload("test")
 				.setHeader("prop1", "foo").setHeader("prop2", "bar").build();
 		Object[] args = (Object[]) mapper.mapMessage(message);
@@ -118,7 +115,7 @@ public class AnnotationMethodMessageMapperTests {
 	@Test
 	public void testPropertiesMethodWithPropertiesPayload() throws Exception {
 		Method method = TestHandler.class.getMethod("propertiesMethod", Properties.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
+		MethodArgumentMessageMapper<Properties> mapper = new MethodArgumentMessageMapper<Properties>(method);
 		Properties payload = new Properties();
 		payload.setProperty("prop1", "foo");
 		payload.setProperty("prop2", "bar");
@@ -135,7 +132,7 @@ public class AnnotationMethodMessageMapperTests {
 	@SuppressWarnings("unchecked")
 	public void testMapMethodWithNonMapPayload() throws Exception {
 		Method method = TestHandler.class.getMethod("mapMethod", Map.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
+		MethodArgumentMessageMapper<String> mapper = new MethodArgumentMessageMapper<String>(method);
 		Message<String> message = MessageBuilder.fromPayload("test")
 				.setHeader("attrib1", new Integer(123))
 				.setHeader("attrib2", new Integer(456)).build();
@@ -149,7 +146,7 @@ public class AnnotationMethodMessageMapperTests {
 	@SuppressWarnings("unchecked")
 	public void testMapMethodWithMapPayload() throws Exception {
 		Method method = TestHandler.class.getMethod("mapMethod", Map.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
+		MethodArgumentMessageMapper<Map<String,Integer>> mapper = new MethodArgumentMessageMapper<Map<String,Integer>>(method);
 		Map<String, Integer> payload = new HashMap<String, Integer>();
 		payload.put("attrib1", new Integer(123));
 		payload.put("attrib2", new Integer(456));
@@ -163,89 +160,6 @@ public class AnnotationMethodMessageMapperTests {
 		assertEquals(new Integer(456), result.get("attrib2"));
 	}
 
-	@Test
-	public void testMessageOnlyWithAdapter() throws Exception {
-		TestHandler handler = new TestHandler();
-		Method method = handler.getClass().getMethod("messageOnly", Message.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setObject(handler);
-		adapter.setMethod(method);
-		adapter.setMessageMapper(mapper);
-		Message<?> result = adapter.handle(new StringMessage("foo"));
-		assertEquals("foo", result.getPayload());
-	}
-
-	@Test
-	public void testPayloadWithAdapter() throws Exception {
-		TestHandler handler = new TestHandler();
-		Method method = handler.getClass().getMethod("integerMethod", Integer.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setObject(handler);
-		adapter.setMethod(method);
-		adapter.setMessageMapper(mapper);
-		Message<?> result = adapter.handle(new GenericMessage<Integer>(new Integer(123)));
-		assertEquals(new Integer(123), result.getPayload());
-	}
-
-	@Test
-	public void testConvertedPayloadWithAdapter() throws Exception {
-		TestHandler handler = new TestHandler();
-		Method method = handler.getClass().getMethod("integerMethod", Integer.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setObject(handler);
-		adapter.setMethod(method);
-		adapter.setMessageMapper(mapper);
-		Message<?> result = adapter.handle(new StringMessage("456"));
-		assertEquals(new Integer(456), result.getPayload());
-	}
-
-	@Test(expected=MessagingException.class)
-	public void testConversionFailureWithAdapter() throws Exception {
-		TestHandler handler = new TestHandler();
-		Method method = handler.getClass().getMethod("integerMethod", Integer.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setObject(handler);
-		adapter.setMethod(method);
-		adapter.setMessageMapper(mapper);
-		Message<?> result = adapter.handle(new StringMessage("foo"));
-		assertEquals(new Integer(123), result.getPayload());
-	}
-
-	@Test
-	public void testMessageAndHeaderWithAdapter() throws Exception {
-		TestHandler handler = new TestHandler();
-		Method method = handler.getClass().getMethod("messageAndHeader", Message.class, Integer.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setObject(handler);
-		adapter.setMethod(method);
-		adapter.setMessageMapper(mapper);
-		Message<String> message = MessageBuilder.fromPayload("foo")
-				.setHeader("number", 42).build();
-		Message<?> result = adapter.handle(message);
-		assertEquals("foo-42", result.getPayload());
-	}
-
-	@Test
-	public void testMultipleHeadersWithAdapter() throws Exception {
-		TestHandler handler = new TestHandler();
-		Method method = handler.getClass().getMethod("twoHeaders", String.class, Integer.class);
-		AnnotationMethodMessageMapper mapper = new AnnotationMethodMessageMapper(method);
-		DefaultMessageHandlerAdapter adapter = new DefaultMessageHandlerAdapter();
-		adapter.setObject(handler);
-		adapter.setMethod(method);
-		adapter.setMessageMapper(mapper);
-		Message<String> message = MessageBuilder.fromPayload("foo")
-				.setHeader("prop", "bar")
-				.setHeader("number", 42).build();
-		Message<?> result = adapter.handle(message);
-		assertEquals("bar-42", result.getPayload());
-	}
-
 
 	private static class TestHandler {
 
@@ -294,7 +208,7 @@ public class AnnotationMethodMessageMapperTests {
 		public Integer integerMethod(Integer i) {
 			return i;
 		}
-
 	}
 
+
 }

org.springframework.integration/src/test/java/org/springframework/integration/transformer/TransformerMessageHandlerTests.java

@@ -36,84 +36,95 @@ import org.springframework.integration.message.StringMessage;
 /**
  * @author Mark Fisher
  */
-public class AnnotationMethodTransformerAdapterTests {
+public class TransformerMessageHandlerTests {
 
 	@Test
-	public void testSimplePayload() throws Exception {
+	public void simplePayload() throws Exception {
 		TestBean testBean = new TestBean();
-		AnnotationMethodTransformerAdapter adapter = new AnnotationMethodTransformerAdapter();
-		adapter.setObject(testBean);
-		adapter.setMethod(testBean.getClass().getMethod("exclaim", String.class));
+		TransformerMessageHandler handler = new TransformerMessageHandler();
+		handler.setObject(testBean);
+		handler.setMethod(testBean.getClass().getMethod("exclaim", String.class));
 		Message<?> message = new StringMessage("foo");
-		Message<?> result = adapter.handle(message);
+		Message<?> result = handler.handle(message);
 		assertEquals("FOO!", result.getPayload());
 	}
 
 	@Test
-	public void testTypeConversion() throws Exception {
+	public void typeConversion() throws Exception {
 		TestBean testBean = new TestBean();
-		AnnotationMethodTransformerAdapter adapter = new AnnotationMethodTransformerAdapter();
-		adapter.setObject(testBean);
-		adapter.setMethod(testBean.getClass().getMethod("exclaim", String.class));
+		TransformerMessageHandler handler = new TransformerMessageHandler();
+		handler.setObject(testBean);
+		handler.setMethod(testBean.getClass().getMethod("exclaim", String.class));
 		Message<?> message = new GenericMessage<Integer>(123);
-		Message<?> result = adapter.handle(message);
+		Message<?> result = handler.handle(message);
 		assertEquals("123!", result.getPayload());
 	}
 
-	@Test(expected=MessagingException.class)
-	public void testTypeConversionFailure() throws Exception {
+	@Test(expected = MessagingException.class)
+	public void typeConversionFailure() throws Exception {
 		TestBean testBean = new TestBean();
-		AnnotationMethodTransformerAdapter adapter = new AnnotationMethodTransformerAdapter();
-		adapter.setObject(testBean);
-		adapter.setMethod(testBean.getClass().getMethod("exclaim", String.class));
+		TransformerMessageHandler handler = new TransformerMessageHandler();
+		handler.setObject(testBean);
+		handler.setMethod(testBean.getClass().getMethod("exclaim", String.class));
 		Message<?> message = new GenericMessage<Date>(new Date());
-		adapter.handle(message);
+		handler.handle(message);
 	}
 
 	@Test
-	public void testHeaderAnnotation() throws Exception {
+	public void headerAnnotation() throws Exception {
 		TestBean testBean = new TestBean();
-		AnnotationMethodTransformerAdapter adapter = new AnnotationMethodTransformerAdapter();
-		adapter.setObject(testBean);
-		adapter.setMethod(testBean.getClass().getMethod("headerTest", String.class, Integer.class));
+		TransformerMessageHandler handler = new TransformerMessageHandler();
+		handler.setObject(testBean);
+		handler.setMethod(testBean.getClass().getMethod("headerTest", String.class, Integer.class));
 		Message<String> message = MessageBuilder.fromPayload("foo")
 				.setHeader("number", 123).build();
-		Message<?> result = adapter.handle(message);
+		Message<?> result = handler.handle(message);
 		assertEquals("foo123", result.getPayload());
 	}
 
-	@Test(expected=MessageHandlingException.class)
-	public void testHeaderValueNotProvided() throws Exception {
+	@Test(expected = MessageHandlingException.class)
+	public void headerValueNotProvided() throws Exception {
 		TestBean testBean = new TestBean();
-		AnnotationMethodTransformerAdapter adapter = new AnnotationMethodTransformerAdapter();
-		adapter.setObject(testBean);
-		adapter.setMethod(testBean.getClass().getMethod("headerTest", String.class, Integer.class));
+		TransformerMessageHandler handler = new TransformerMessageHandler();
+		handler.setObject(testBean);
+		handler.setMethod(testBean.getClass().getMethod("headerTest", String.class, Integer.class));
 		Message<String> message = MessageBuilder.fromPayload("foo")
 				.setHeader("wrong", 123).build();
-		adapter.handle(message);
+		handler.handle(message);
 	}
 
 	@Test
-	public void testOptionalHeaderAnnotation() throws Exception {
+	public void optionalHeaderAnnotation() throws Exception {
 		TestBean testBean = new TestBean();
-		AnnotationMethodTransformerAdapter adapter = new AnnotationMethodTransformerAdapter();
-		adapter.setObject(testBean);
-		adapter.setMethod(testBean.getClass().getMethod("optionalHeaderTest", String.class, Integer.class));
+		TransformerMessageHandler handler = new TransformerMessageHandler();
+		handler.setObject(testBean);
+		handler.setMethod(testBean.getClass().getMethod("optionalHeaderTest", String.class, Integer.class));
+		Message<String> message = MessageBuilder.fromPayload("foo").setHeader("number", 99).build();
+		Message<?> result = handler.handle(message);
+		assertEquals("foo99", result.getPayload());
+	}
+
+	@Test
+	public void optionalHeaderValueNotProvided() throws Exception {
+		TestBean testBean = new TestBean();
+		TransformerMessageHandler handler = new TransformerMessageHandler();
+		handler.setObject(testBean);
+		handler.setMethod(testBean.getClass().getMethod("optionalHeaderTest", String.class, Integer.class));
 		Message<String> message = MessageBuilder.fromPayload("foo").build();
-		Message<?> result = adapter.handle(message);
+		Message<?> result = handler.handle(message);
 		assertEquals("foonull", result.getPayload());
 	}
 
 	@Test
-	public void testHeaderEnricher() throws Exception {
+	public void headerEnricher() throws Exception {
 		TestBean testBean = new TestBean();
-		AnnotationMethodTransformerAdapter adapter = new AnnotationMethodTransformerAdapter();
-		adapter.setObject(testBean);
-		adapter.setMethod(testBean.getClass().getMethod("propertyEnricherTest", String.class));
+		TransformerMessageHandler handler = new TransformerMessageHandler();
+		handler.setObject(testBean);
+		handler.setMethod(testBean.getClass().getMethod("propertyEnricherTest", String.class));
 		Message<String> message = MessageBuilder.fromPayload("test")
 				.setHeader("prop1", "bad")
 				.setHeader("prop3", "baz").build();
-		Message<?> result = adapter.handle(message);
+		Message<?> result = handler.handle(message);
 		assertEquals("test", result.getPayload());
 		assertEquals("foo", result.getHeaders().get("prop1"));
 		assertEquals("bar", result.getHeaders().get("prop2"));
@@ -122,16 +133,16 @@ public class AnnotationMethodTransformerAdapterTests {
 
 	@Test
 	@SuppressWarnings("unchecked")
-	public void testPropertiesPayload() throws Exception {
+	public void propertiesPayload() throws Exception {
 		TestBean testBean = new TestBean();
-		AnnotationMethodTransformerAdapter adapter = new AnnotationMethodTransformerAdapter();
-		adapter.setObject(testBean);
-		adapter.setMethod(testBean.getClass().getMethod("propertyPayloadTest", Properties.class));
+		TransformerMessageHandler handler = new TransformerMessageHandler();
+		handler.setObject(testBean);
+		handler.setMethod(testBean.getClass().getMethod("propertyPayloadTest", Properties.class));
 		Properties props = new Properties();
 		props.setProperty("prop1", "bad");
 		props.setProperty("prop3", "baz");
 		Message<Properties> message = new GenericMessage<Properties>(props);
-		Message<Properties> result = (Message<Properties>) adapter.handle(message);
+		Message<Properties> result = (Message<Properties>) handler.handle(message);
 		assertEquals(Properties.class, result.getPayload().getClass());
 		Properties payload = result.getPayload();
 		assertEquals("foo", payload.getProperty("prop1"));