Removed MessageTransformer due to the redundancy with MessageHandler (now that Messages are immutable). Refactored existing transformers to implement PayloadTransformer instead. All message handling is now the responsibility of the delegating PayloadTransformingMessageHandler. Also added the AbstractPaylaodTransformerParser from which all existing PayloadTransformer parsers now extend.

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

@@ -23,6 +23,7 @@ import org.junit.Test;
 
 import org.springframework.integration.channel.AbstractMessageChannel;
 import org.springframework.integration.channel.QueueChannel;
+import org.springframework.integration.handler.MessageHandler;
 import org.springframework.integration.message.Message;
 import org.springframework.integration.message.StringMessage;
 
@@ -31,52 +32,53 @@ import org.springframework.integration.message.StringMessage;
  */
 public class MessageTransformingChannelInterceptorTests {
 
-	AbstractMessageChannel channel; 
+	private AbstractMessageChannel channel; 
 
-	StringMessage message;
+	private StringMessage message;
 
-	TestTransformer transfomer;
+	private TestTransformer transformer;
 
-	MessageTransformingChannelInterceptor channelInterceptor;
+	private MessageTransformingChannelInterceptor channelInterceptor;
 
 
 	@Before
-	public void setUp(){
+	public void setUp() {
 		channel = new QueueChannel();
 		message = new StringMessage("test");
-		transfomer = new TestTransformer();
-		channelInterceptor = new MessageTransformingChannelInterceptor(transfomer);
+		transformer = new TestTransformer();
+		channelInterceptor = new MessageTransformingChannelInterceptor(transformer);
 		channel.addInterceptor(channelInterceptor);
 	}
 
+
 	@Test
 	public void testTransformOnReceive() {
 		channelInterceptor.setTransformOnSend(false);
 		channel.send(message);
-		assertFalse("Transfomrer on incorrectly invoked on send", transfomer.invoked);
+		assertFalse("Transformer incorrectly invoked on send", transformer.invoked);
 		Message<?> msg = channel.receive(1);
-		assertEquals("Wrong message",message, msg);
-		assertTrue("Transfomer not invoked on receive", transfomer.invoked);
+		assertEquals("Wrong message", message, msg);
+		assertTrue("Transformer not invoked on receive", transformer.invoked);
 	}
 
 	@Test
 	public void testTransformOnSend() {
 		channelInterceptor.setTransformOnSend(true);
 		channel.send(message);
-		assertTrue("Transfomrer not invoked on send", transfomer.invoked);
+		assertTrue("Transformer not invoked on send", transformer.invoked);
 		Message<?> msg = channel.receive(1);
-		assertEquals("Wrong message",message, msg);
-		assertEquals("Transfomer invoked on receive", 1, transfomer.invokedCount);
+		assertEquals("Wrong message", message, msg);
+		assertEquals("Transformer invoked on receive", 1, transformer.invokedCount);
 	}
 
 
-	private static class TestTransformer implements MessageTransformer {
+	private static class TestTransformer implements MessageHandler {
 
 		boolean invoked = false;
-		
+
 		int invokedCount = 0;
-		
-		public Message<?> transform(Message<?> message) {
+
+		public Message<?> handle(Message<?> message) {
 			invoked = true;
 			invokedCount++;
 			return message;

org.springframework.integration/src/test/java/org/springframework/integration/transformer/config/AbstractPayloadTransformerParser.java

@@ -0,0 +1,61 @@
+/*
+ * 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.transformer.config;
+
+import org.w3c.dom.Element;
+
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
+import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.integration.transformer.PayloadTransformer;
+import org.springframework.integration.transformer.PayloadTransformingMessageHandler;
+
+/**
+ * @author Mark Fisher
+ */
+public abstract class AbstractPayloadTransformerParser extends AbstractSingleBeanDefinitionParser {
+
+	@Override
+	protected boolean shouldGenerateId() {
+		return false;
+	}
+
+	@Override
+	protected boolean shouldGenerateIdAsFallback() {
+		return true;
+	}
+
+	@Override
+	protected Class<?> getBeanClass(Element element) {
+		return PayloadTransformingMessageHandler.class;
+	}
+
+	@Override
+	protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
+		BeanDefinitionBuilder transformerBuilder = BeanDefinitionBuilder.genericBeanDefinition(this.getTransformerClass());
+		this.parsePayloadTransformer(element, parserContext, transformerBuilder);
+		String transformerBeanName = BeanDefinitionReaderUtils.registerWithGeneratedName(
+				transformerBuilder.getBeanDefinition(), parserContext.getRegistry());
+		builder.addConstructorArgReference(transformerBeanName);
+	}
+
+	protected abstract Class<? extends PayloadTransformer<?, ?>> getTransformerClass();
+
+	protected abstract void parsePayloadTransformer(Element element, ParserContext parserContext, BeanDefinitionBuilder builder);
+
+}