Spring/spring-integration
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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.

Browse Source
This commit is contained in:
Mark Fisher
2008-07-18 20:12:59 +00:00
parent 3a916b223d
commit b37a4d8f12
29 changed files with 312 additions and 431 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
org.springframework.integration/src/main/java/org/springframework/integration/transformer/MessageTransformer.java
View File

@@ -1,30 +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.transformer;
import org.springframework.integration.message.Message;
/**
* Base interface for message transformers.
*
* @author Mark Fisher
*/
public interface MessageTransformer {
Message<?> transform(Message<?> message);
}

61
org.springframework.integration/src/main/java/org/springframework/integration/transformer/MessageTransformerChain.java
View File

@@ -1,61 +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.transformer;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import org.springframework.integration.message.Message;
/**
* @author Mark Fisher
*/
public class MessageTransformerChain implements MessageTransformer {
private final List<MessageTransformer> transformers = new CopyOnWriteArrayList<MessageTransformer>();
/**
* Add a transformer to the end of the chain.
*/
public void add(MessageTransformer transformer) {
this.transformers.add(transformer);
}
/**
* Add a transformer to the chain at the specified index.
*/
public void add(int index, MessageTransformer transformer) {
this.transformers.add(index, transformer);
}
public void setTransformers(List<MessageTransformer> transformers) {
this.transformers.clear();
this.transformers.addAll(transformers);
}
public Message<?> transform(Message<?> message) {
for (MessageTransformer next : this.transformers) {
message = next.transform(message);
if (message == null) {
return null;
}
}
return message;
}
}

11
org.springframework.integration/src/main/java/org/springframework/integration/transformer/MessageTransformingChannelInterceptor.java
View File

@@ -19,22 +19,23 @@ package org.springframework.integration.transformer;
import org.springframework.integration.channel.ChannelInterceptor;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.interceptor.ChannelInterceptorAdapter;
import org.springframework.integration.handler.MessageHandler;
import org.springframework.integration.message.Message;
/**
* A {@link ChannelInterceptor} which invokes a {@link MessageTransformer}
* A {@link ChannelInterceptor} which invokes a {@link MessageHandler}
* when either sending-to or receiving-from a channel.
*
* @author Jonas Partner
*/
public class MessageTransformingChannelInterceptor extends ChannelInterceptorAdapter {
private final MessageTransformer transfomer;
private final MessageHandler transfomer;
private volatile boolean transformOnSend = true;
public MessageTransformingChannelInterceptor(MessageTransformer transformer) {
public MessageTransformingChannelInterceptor(MessageHandler transformer) {
this.transfomer = transformer;
}
@@ -50,7 +51,7 @@ public class MessageTransformingChannelInterceptor extends ChannelInterceptorAda
@Override
public Message<?> preSend(Message<?> message, MessageChannel channel) {
if (this.transformOnSend) {
message = this.transfomer.transform(message);
message = this.transfomer.handle(message);
}
return message;
}
@@ -58,7 +59,7 @@ public class MessageTransformingChannelInterceptor extends ChannelInterceptorAda
@Override
public Message<?> postReceive(Message<?> message, MessageChannel channel) {
if (!this.transformOnSend) {
message = this.transfomer.transform(message);
message = this.transfomer.handle(message);
}
return message;
}

36
org.springframework.integration/src/test/java/org/springframework/integration/transformer/MessageTransformingChannelInterceptorTests.java
View File

@@ -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;

61
org.springframework.integration/src/test/java/org/springframework/integration/transformer/config/AbstractPayloadTransformerParser.java Normal file
View File

@@ -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);
}