diff --git a/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/transformer/XmlPayloadMarshallingTransformer.java b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/transformer/XmlPayloadMarshallingTransformer.java index fd83df37ee..e48f5187f3 100644 --- a/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/transformer/XmlPayloadMarshallingTransformer.java +++ b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/transformer/XmlPayloadMarshallingTransformer.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2008 the original author or authors. + * Copyright 2002-2009 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. @@ -21,21 +21,21 @@ import java.io.IOException; import javax.xml.parsers.ParserConfigurationException; import javax.xml.transform.Result; +import org.springframework.integration.core.Message; import org.springframework.integration.core.MessagingException; -import org.springframework.integration.transformer.AbstractPayloadTransformer; +import org.springframework.integration.transformer.AbstractTransformer; import org.springframework.integration.xml.result.DomResultFactory; import org.springframework.integration.xml.result.ResultFactory; import org.springframework.oxm.Marshaller; import org.springframework.util.Assert; /** - * An implementation of {@link PayloadTransformer} that delegates to an OXM - * {@link Marshaller}. + * An implementation of {@link AbstractTransformer} that delegates to an OXM {@link Marshaller}. * * @author Mark Fisher * @author Jonas Partner */ -public class XmlPayloadMarshallingTransformer extends AbstractPayloadTransformer { +public class XmlPayloadMarshallingTransformer extends AbstractTransformer { private final Marshaller marshaller; @@ -43,12 +43,15 @@ public class XmlPayloadMarshallingTransformer extends AbstractPayloadTransformer private final ResultTransformer resultTransformer; + private volatile boolean extractPayload = true; + + public XmlPayloadMarshallingTransformer(Marshaller marshaller, ResultTransformer resultTransformer) throws ParserConfigurationException { Assert.notNull(marshaller, "a marshaller is required"); this.marshaller = marshaller; this.resultTransformer = resultTransformer; - resultFactory = new DomResultFactory(); + this.resultFactory = new DomResultFactory(); } public XmlPayloadMarshallingTransformer(Marshaller marshaller) throws ParserConfigurationException { @@ -61,25 +64,36 @@ public class XmlPayloadMarshallingTransformer extends AbstractPayloadTransformer this.resultFactory = resultFactory; } + /** + * Specify whether the source Message's payload should be extracted prior + * to marshalling. This value is set to "true" by default. To send the + * Message itself as input to the Marshaller instead, set this to "false". + */ + public void setExtractPayload(boolean extractPayload) { + this.extractPayload = extractPayload; + } + @Override - public Object transformPayload(Object payload) { + public Object doTransform(Message message) { + Object source = (this.extractPayload) ? message.getPayload() : message; Object transformedPayload = null; - Result result = this.resultFactory.createResult(payload); + Result result = this.resultFactory.createResult(source); if (result == null) { throw new MessagingException( "Unable to marshal payload, ResultFactory returned null."); } try { - this.marshaller.marshal(payload, result); + this.marshaller.marshal(source, result); transformedPayload = result; - } catch (IOException e) { + } + catch (IOException e) { throw new MessagingException("Failed to marshal payload", e); } if (transformedPayload == null) { throw new MessagingException("Failed to transform payload"); } - if (resultTransformer != null) { - transformedPayload = resultTransformer.transformResult(result); + if (this.resultTransformer != null) { + transformedPayload = this.resultTransformer.transformResult(result); } return transformedPayload; } diff --git a/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/transformer/XmlPayloadMarshallingTransformerTests.java b/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/transformer/XmlPayloadMarshallingTransformerTests.java index ec3c6811d8..ae532e30a8 100644 --- a/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/transformer/XmlPayloadMarshallingTransformerTests.java +++ b/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/transformer/XmlPayloadMarshallingTransformerTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2008 the original author or authors. + * Copyright 2002-2009 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. @@ -17,6 +17,7 @@ package org.springframework.integration.xml.transformer; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertSame; import java.io.IOException; import java.util.ArrayList; @@ -26,6 +27,9 @@ import javax.xml.transform.Result; import javax.xml.transform.dom.DOMResult; import org.junit.Test; + +import org.springframework.integration.core.Message; +import org.springframework.integration.message.StringMessage; import org.springframework.integration.xml.result.StringResultFactory; import org.springframework.oxm.Marshaller; import org.springframework.oxm.XmlMappingException; @@ -39,39 +43,59 @@ public class XmlPayloadMarshallingTransformerTests { @Test public void testStringToStringResult() throws Exception { TestMarshaller marshaller = new TestMarshaller(); - XmlPayloadMarshallingTransformer transformer = new XmlPayloadMarshallingTransformer( - marshaller); + XmlPayloadMarshallingTransformer transformer = new XmlPayloadMarshallingTransformer(marshaller); transformer.setResultFactory(new StringResultFactory()); - Object result = transformer.transformPayload("world"); - assertEquals(StringResult.class, result.getClass()); - assertEquals("hello world", result.toString()); + Message resultMessage = transformer.transform(new StringMessage("world")); + Object resultPayload = resultMessage.getPayload(); + assertEquals(StringResult.class, resultPayload.getClass()); + assertEquals("hello world", resultPayload.toString()); assertEquals("world", marshaller.payloads.get(0)); } @Test public void testDefaultResultFactory() throws Exception { TestMarshaller marshaller = new TestMarshaller(); - XmlPayloadMarshallingTransformer transformer = new XmlPayloadMarshallingTransformer( - marshaller); - Object result = transformer.transformPayload("world"); - assertEquals(DOMResult.class, result.getClass()); + XmlPayloadMarshallingTransformer transformer = new XmlPayloadMarshallingTransformer(marshaller); + Message resultMessage = transformer.transform(new StringMessage("world")); + Object resultPayload = resultMessage.getPayload(); + assertEquals(DOMResult.class, resultPayload.getClass()); assertEquals("world", marshaller.payloads.get(0)); } + @Test + public void testMarshallingEntireMessage() throws Exception { + TestMarshaller marshaller = new TestMarshaller(); + XmlPayloadMarshallingTransformer transformer = new XmlPayloadMarshallingTransformer(marshaller); + transformer.setExtractPayload(false); + Message message = new StringMessage("test"); + transformer.transform(message); + assertEquals(0, marshaller.payloads.size()); + assertEquals(1, marshaller.messages.size()); + assertSame(message, marshaller.messages.get(0)); + } + + private static class TestMarshaller implements Marshaller { - private List payloads = new ArrayList(); + private final List> messages = new ArrayList>(); + + private final List payloads = new ArrayList(); @SuppressWarnings("unchecked") public boolean supports(Class clazz) { return true; } - public void marshal(Object originalPayload, Result result) - throws XmlMappingException, IOException { - payloads.add(originalPayload); + @SuppressWarnings("unchecked") + public void marshal(Object source, Result result) throws XmlMappingException, IOException { + if (source instanceof Message) { + this.messages.add((Message) source); + } + else { + this.payloads.add(source); + } if (result instanceof StringResult) { - ((StringResult) result).getWriter().write("hello world"); + ((StringResult) result).getWriter().write("hello " + source); } } diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/transformer/AbstractPayloadTransformer.java b/org.springframework.integration/src/main/java/org/springframework/integration/transformer/AbstractPayloadTransformer.java index 03399441c0..8a65bcbd9c 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/transformer/AbstractPayloadTransformer.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/transformer/AbstractPayloadTransformer.java @@ -17,32 +17,20 @@ package org.springframework.integration.transformer; import org.springframework.integration.core.Message; -import org.springframework.integration.message.MessageBuilder; /** - * A base class for {@link Transformer} implementations that modify - * the payload of a {@link Message}. If the return value is itself - * a Message, it will be used as the result. Otherwise, the return - * value will be used as the payload of the result Message. + * A base class for {@link Transformer} implementations that modify the payload + * of a {@link Message}. If the return value is itself a Message, it will be + * used as the result. Otherwise, the return value will be used as the payload + * of the result Message. * * @author Mark Fisher */ -public abstract class AbstractPayloadTransformer implements Transformer { +public abstract class AbstractPayloadTransformer extends AbstractTransformer { @SuppressWarnings("unchecked") - public final Message transform(Message message) { - try { - U result = this.transformPayload((T) message.getPayload()); - return (result instanceof Message) - ? MessageBuilder.fromMessage((Message) result).build() - : MessageBuilder.withPayload(result).copyHeaders(message.getHeaders()).build(); - } - catch (MessageTransformationException e) { - throw e; - } - catch (Exception e) { - throw new MessageTransformationException(message, "failed to transform message payload", e); - } + public final U doTransform(Message message) throws Exception { + return this.transformPayload((T) message.getPayload()); } protected abstract U transformPayload(T payload) throws Exception; diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/transformer/AbstractTransformer.java b/org.springframework.integration/src/main/java/org/springframework/integration/transformer/AbstractTransformer.java new file mode 100644 index 0000000000..80501e469d --- /dev/null +++ b/org.springframework.integration/src/main/java/org/springframework/integration/transformer/AbstractTransformer.java @@ -0,0 +1,49 @@ +/* + * Copyright 2002-2009 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; + +import org.springframework.integration.core.Message; +import org.springframework.integration.message.MessageBuilder; + +/** + * A base class for {@link Transformer} implementations. If the return value is + * itself a Message, it will be used as the result. Otherwise, the return value + * will be used as the payload of the result Message. + * + * @author Mark Fisher + */ +public abstract class AbstractTransformer implements Transformer { + + @SuppressWarnings("unchecked") + public final Message transform(Message message) { + try { + Object result = this.doTransform(message); + return (result instanceof Message) + ? MessageBuilder.fromMessage((Message) result).build() + : MessageBuilder.withPayload(result).copyHeaders(message.getHeaders()).build(); + } + catch (MessageTransformationException e) { + throw e; + } + catch (Exception e) { + throw new MessageTransformationException(message, "failed to transform message", e); + } + } + + protected abstract Object doTransform(Message message) throws Exception; + +}