diff --git a/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/config/XPathRouterParser.java b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/config/XPathRouterParser.java index 732b03b0a9..51c5f98e40 100644 --- a/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/config/XPathRouterParser.java +++ b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/config/XPathRouterParser.java @@ -22,8 +22,6 @@ import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser; import org.springframework.beans.factory.xml.ParserContext; import org.springframework.integration.ConfigurationException; -import org.springframework.integration.router.MultiChannelRouter; -import org.springframework.integration.router.SingleChannelRouter; import org.springframework.integration.xml.router.XPathMultiChannelNameResolver; import org.springframework.integration.xml.router.XPathSingleChannelNameResolver; import org.springframework.util.StringUtils; @@ -54,27 +52,19 @@ public class XPathRouterParser extends AbstractSingleBeanDefinitionParser { || (!StringUtils.hasText(xPathExpression) && !StringUtils.hasText(xPathExpressionRef))) { throw new ConfigurationException("Exactly one of 'xpath-expression' or 'xpath-expression-ref' is required."); } - - BeanDefinitionBuilder resolverDefinitionBuilder = null; if (multiChannel) { - builder.getBeanDefinition().setBeanClass(MultiChannelRouter.class); - resolverDefinitionBuilder = BeanDefinitionBuilder - .genericBeanDefinition(XPathMultiChannelNameResolver.class); + builder.getBeanDefinition().setBeanClass(XPathMultiChannelNameResolver.class); } else { - builder.getBeanDefinition().setBeanClass(SingleChannelRouter.class); - resolverDefinitionBuilder = BeanDefinitionBuilder - .genericBeanDefinition(XPathSingleChannelNameResolver.class); + builder.getBeanDefinition().setBeanClass(XPathSingleChannelNameResolver.class); } - if (StringUtils.hasText(xPathExpression)) { XPathExpression expression = XPathExpressionFactory.createXPathExpression(xPathExpression); - resolverDefinitionBuilder.addConstructorArgValue(expression); + builder.addConstructorArgValue(expression); } else { - resolverDefinitionBuilder.addConstructorArgReference(xPathExpressionRef); + builder.addConstructorArgReference(xPathExpressionRef); } - builder.addPropertyValue("channelNameResolver", resolverDefinitionBuilder.getBeanDefinition()); } } diff --git a/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/XPathMultiChannelNameResolver.java b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/XPathMultiChannelNameResolver.java index 3196b481f6..30d86bb8da 100644 --- a/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/XPathMultiChannelNameResolver.java +++ b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/XPathMultiChannelNameResolver.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2007 the original author or authors. + * 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. @@ -18,39 +18,41 @@ package org.springframework.integration.xml.router; import java.util.List; -import org.springframework.integration.message.Message; -import org.springframework.integration.router.MultiChannelNameResolver; -import org.springframework.util.Assert; -import org.springframework.xml.xpath.NodeMapper; -import org.springframework.xml.xpath.XPathExpression; import org.w3c.dom.DOMException; import org.w3c.dom.Node; +import org.springframework.integration.message.Message; +import org.springframework.integration.router.AbstractMultiChannelNameResolver; +import org.springframework.integration.xml.util.XPathUtils; +import org.springframework.util.Assert; +import org.springframework.xml.xpath.NodeMapper; +import org.springframework.xml.xpath.XPathExpression; + /** - * * @author Jonas Partner - * */ -public class XPathMultiChannelNameResolver extends AbstractXPathChannelNameResolver implements MultiChannelNameResolver { +public class XPathMultiChannelNameResolver extends AbstractMultiChannelNameResolver { private final XPathExpression xPathExpression; - private NodeMapper nodeMapper = new TextContentNodeMapper(); + private volatile NodeMapper nodeMapper = new TextContentNodeMapper(); + public XPathMultiChannelNameResolver(XPathExpression xPathExpression) { - Assert.notNull("XPAthExpression must be provided"); + Assert.notNull("XPathExpression must not be null"); this.xPathExpression = xPathExpression; } + public void setNodeMapper(NodeMapper nodeMapper) { - Assert.notNull(nodeMapper, "NodeMapper can not be null"); + Assert.notNull(nodeMapper, "NodeMapper must not be null"); this.nodeMapper = nodeMapper; } @SuppressWarnings("unchecked") - public String[] resolve(Message message) { - Node node = extractNode(message); - List channelNamesList = xPathExpression.evaluate(node, nodeMapper); + public String[] resolveChannelNames(Message message) { + Node node = XPathUtils.extractPayloadAsNode(message); + List channelNamesList = this.xPathExpression.evaluate(node, this.nodeMapper); return (String[]) channelNamesList.toArray(new String[channelNamesList.size()]); } diff --git a/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/XPathSingleChannelNameResolver.java b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/XPathSingleChannelNameResolver.java index fc1eeaad97..39a67ddfc9 100644 --- a/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/XPathSingleChannelNameResolver.java +++ b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/XPathSingleChannelNameResolver.java @@ -19,24 +19,26 @@ package org.springframework.integration.xml.router; import org.w3c.dom.Node; import org.springframework.integration.message.Message; -import org.springframework.integration.router.ChannelNameResolver; +import org.springframework.integration.router.AbstractSingleChannelNameResolver; +import org.springframework.integration.xml.util.XPathUtils; import org.springframework.util.Assert; import org.springframework.xml.xpath.XPathExpression; /** * @author Jonas Partner */ -public class XPathSingleChannelNameResolver extends AbstractXPathChannelNameResolver implements ChannelNameResolver { +public class XPathSingleChannelNameResolver extends AbstractSingleChannelNameResolver { private final XPathExpression xPathExpression; + public XPathSingleChannelNameResolver(XPathExpression xPathExpression) { Assert.notNull("XPathExpression must be provided"); this.xPathExpression = xPathExpression; } - public String resolve(Message message) { - Node node = extractNode(message); + public String resolveChannelName(Message message) { + Node node = XPathUtils.extractPayloadAsNode(message); return xPathExpression.evaluateAsString(node); } diff --git a/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/AbstractXPathChannelNameResolver.java b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/util/XPathUtils.java similarity index 65% rename from org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/AbstractXPathChannelNameResolver.java rename to org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/util/XPathUtils.java index 4d5ac85121..4560f3ee3b 100644 --- a/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/AbstractXPathChannelNameResolver.java +++ b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/util/XPathUtils.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2007 the original author or authors. + * 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. @@ -14,23 +14,27 @@ * limitations under the License. */ -package org.springframework.integration.xml.router; +package org.springframework.integration.xml.util; + +import org.w3c.dom.Node; import org.springframework.integration.message.Message; import org.springframework.integration.message.MessagingException; -import org.w3c.dom.Node; /** - * * @author Jonas Partner - * + * @author Mark Fisher */ -public class AbstractXPathChannelNameResolver { +public abstract class XPathUtils { - protected Node extractNode(Message message) { + /** + * Return the given Message's payload as a Node if possible, else an Exception will be thrown. + */ + public static Node extractPayloadAsNode(Message message) { if (!Node.class.isAssignableFrom(message.getPayload().getClass())) { - throw new MessagingException(message, "Payload does not implement org.w3c.dom.Node so can not be evaluated"); + throw new MessagingException(message, "payload is not assignable to [" + Node.class.getName() + "] so can not be evaluated"); } return (Node) message.getPayload(); } + } diff --git a/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathMultiChannelNameResolverTests.java b/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathMultiChannelNameResolverTests.java index 1b78f02136..8a738dc09e 100644 --- a/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathMultiChannelNameResolverTests.java +++ b/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathMultiChannelNameResolverTests.java @@ -34,24 +34,24 @@ import org.springframework.xml.xpath.XPathExpressionFactory; */ public class XPathMultiChannelNameResolverTests { - @SuppressWarnings("unchecked") @Test + @SuppressWarnings("unchecked") public void testSimpleSingleeAttribute() throws Exception { Document doc = XmlTestUtil.getDocumentForString(""); XPathExpression expression = XPathExpressionFactory.createXPathExpression("/doc/@type"); XPathMultiChannelNameResolver resolver = new XPathMultiChannelNameResolver(expression); - String[] channelNames = resolver.resolve(new GenericMessage(doc)); + String[] channelNames = resolver.resolveChannelNames(new GenericMessage(doc)); assertEquals("Wrong number of channels returend", 1, channelNames.length); assertEquals("Wrong channel name", "one", channelNames[0]); } - @SuppressWarnings("unchecked") @Test + @SuppressWarnings("unchecked") public void testMultipleNodeValues() throws Exception { Document doc = XmlTestUtil.getDocumentForString("bOnebTwo"); XPathExpression expression = XPathExpressionFactory.createXPathExpression("/doc/book"); XPathMultiChannelNameResolver resolver = new XPathMultiChannelNameResolver(expression); - String[] channelNames = resolver.resolve(new GenericMessage(doc)); + String[] channelNames = resolver.resolveChannelNames(new GenericMessage(doc)); assertEquals("Wrong number of channels returend", 2, channelNames.length); assertEquals("Wrong channel name", "bOne", channelNames[0]); assertEquals("Wrong channel name", "bTwo", channelNames[1]); @@ -61,7 +61,7 @@ public class XPathMultiChannelNameResolverTests { public void testNonNodePayload() throws Exception { XPathExpression expression = XPathExpressionFactory.createXPathExpression("/doc/@type"); XPathMultiChannelNameResolver resolver = new XPathMultiChannelNameResolver(expression); - resolver.resolve(new StringMessage("test")); + resolver.resolveChannelNames(new StringMessage("test")); } } diff --git a/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathSingleChannelNameResolverTests.java b/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathSingleChannelNameResolverTests.java index 534b7f3533..4a12621d7e 100644 --- a/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathSingleChannelNameResolverTests.java +++ b/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathSingleChannelNameResolverTests.java @@ -24,7 +24,6 @@ import org.w3c.dom.Document; import org.springframework.integration.message.GenericMessage; import org.springframework.integration.message.MessagingException; import org.springframework.integration.message.StringMessage; -import org.springframework.integration.xml.router.XPathSingleChannelNameResolver; import org.springframework.integration.xml.util.XmlTestUtil; import org.springframework.xml.xpath.XPathExpression; import org.springframework.xml.xpath.XPathExpressionFactory; @@ -34,13 +33,13 @@ import org.springframework.xml.xpath.XPathExpressionFactory; */ public class XPathSingleChannelNameResolverTests { - @SuppressWarnings("unchecked") @Test + @SuppressWarnings("unchecked") public void testSimpleDocType() throws Exception { Document doc = XmlTestUtil.getDocumentForString(""); XPathExpression expression = XPathExpressionFactory.createXPathExpression("/doc/@type"); XPathSingleChannelNameResolver resolver = new XPathSingleChannelNameResolver(expression); - String channelName = resolver.resolve(new GenericMessage(doc)); + String channelName = resolver.resolveChannelName(new GenericMessage(doc)); assertEquals("Wrong channel name", "one", channelName); } @@ -48,7 +47,7 @@ public class XPathSingleChannelNameResolverTests { public void testNonNodePayload() throws Exception { XPathExpression expression = XPathExpressionFactory.createXPathExpression("/doc/@type"); XPathSingleChannelNameResolver resolver = new XPathSingleChannelNameResolver(expression); - resolver.resolve(new StringMessage("test")); + resolver.resolveChannelName(new StringMessage("test")); } } diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/config/RouterParser.java b/org.springframework.integration/src/main/java/org/springframework/integration/config/RouterParser.java index 0ef4e0dbb9..b74522d9df 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/config/RouterParser.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/config/RouterParser.java @@ -17,7 +17,7 @@ package org.springframework.integration.config; import org.springframework.integration.endpoint.MessageEndpoint; -import org.springframework.integration.router.MethodInvokingRouter; +import org.springframework.integration.router.MethodInvokingChannelResolver; import org.springframework.integration.router.RouterEndpoint; /** @@ -34,7 +34,7 @@ public class RouterParser extends AbstractEndpointParser { @Override protected Class getMethodInvokingAdapterClass() { - return MethodInvokingRouter.class; + return MethodInvokingChannelResolver.class; } } diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/RouterAnnotationPostProcessor.java b/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/RouterAnnotationPostProcessor.java index d12ebce593..5a6ec8508b 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/RouterAnnotationPostProcessor.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/RouterAnnotationPostProcessor.java @@ -24,7 +24,7 @@ import org.springframework.integration.annotation.Router; import org.springframework.integration.bus.MessageBus; import org.springframework.integration.channel.MessageChannel; import org.springframework.integration.endpoint.AbstractEndpoint; -import org.springframework.integration.router.MethodInvokingRouter; +import org.springframework.integration.router.MethodInvokingChannelResolver; import org.springframework.integration.router.RouterEndpoint; import org.springframework.util.StringUtils; @@ -42,13 +42,13 @@ public class RouterAnnotationPostProcessor extends AbstractMethodAnnotationPostP @Override protected Object createMethodInvokingAdapter(Object bean, Method method, Router annotation) { - return new MethodInvokingRouter(bean, method); + return new MethodInvokingChannelResolver(bean, method); } @Override protected AbstractEndpoint createEndpoint(Object adapter) { - if (adapter instanceof MethodInvokingRouter) { - return new RouterEndpoint((MethodInvokingRouter) adapter); + if (adapter instanceof MethodInvokingChannelResolver) { + return new RouterEndpoint((MethodInvokingChannelResolver) adapter); } return null; } diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractChannelResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractChannelResolver.java new file mode 100644 index 0000000000..69c9d56005 --- /dev/null +++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractChannelResolver.java @@ -0,0 +1,56 @@ +/* + * 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.router; + +import java.util.Collection; + +import org.springframework.integration.ConfigurationException; +import org.springframework.integration.channel.ChannelRegistry; +import org.springframework.integration.channel.ChannelRegistryAware; +import org.springframework.integration.channel.MessageChannel; +import org.springframework.integration.message.Message; +import org.springframework.integration.message.MessagingException; + +/** + * @author Mark Fisher + */ +public abstract class AbstractChannelResolver implements ChannelResolver, ChannelRegistryAware { + + private volatile ChannelRegistry channelRegistry; + + + public void setChannelRegistry(ChannelRegistry channelRegistry) { + this.channelRegistry = channelRegistry; + } + + protected MessageChannel lookupChannel(String channelName, boolean required) { + MessageChannel channel = null; + if (channelName != null) { + if (this.channelRegistry == null) { + throw new ConfigurationException("unable to resolve channels, no ChannelRegistry available"); + } + channel = this.channelRegistry.lookupChannel(channelName); + } + if (channel == null && required) { + throw new MessagingException("unable to resolve channel '" + channelName + "'"); + } + return channel; + } + + public abstract Collection resolveChannels(Message message); + +} diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/MultiChannelNameResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractMultiChannelNameResolver.java similarity index 51% rename from org.springframework.integration/src/main/java/org/springframework/integration/router/MultiChannelNameResolver.java rename to org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractMultiChannelNameResolver.java index e8d68c6b0a..fa79e28f85 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/MultiChannelNameResolver.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractMultiChannelNameResolver.java @@ -16,15 +16,31 @@ package org.springframework.integration.router; +import java.util.ArrayList; +import java.util.Collection; + +import org.springframework.integration.channel.MessageChannel; import org.springframework.integration.message.Message; /** - * Strategy interface for content-based routing to multiple channel names. - * * @author Mark Fisher */ -public interface MultiChannelNameResolver { +public abstract class AbstractMultiChannelNameResolver extends AbstractChannelResolver { - String[] resolve(Message message); + @Override + public Collection resolveChannels(Message message) { + Collection channels = new ArrayList(); + String[] channelNames = this.resolveChannelNames(message); + if (channelNames == null) { + return null; + } + for (String channelName : channelNames) { + MessageChannel channel = this.lookupChannel(channelName, true); + channels.add(channel); + } + return channels; + } + + protected abstract String[] resolveChannelNames(Message message); } diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractRouter.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractRouter.java deleted file mode 100644 index ca1ddd1370..0000000000 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractRouter.java +++ /dev/null @@ -1,92 +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.router; - -import java.util.Collection; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -import org.springframework.integration.channel.ChannelRegistry; -import org.springframework.integration.channel.ChannelRegistryAware; -import org.springframework.integration.message.Message; -import org.springframework.integration.message.MessageDeliveryException; -import org.springframework.integration.message.MessageExchangeTemplate; -import org.springframework.integration.message.MessageTarget; -import org.springframework.integration.message.MessagingException; - -/** - * Base class for message router implementations. - * - * @author Mark Fisher - */ -public abstract class AbstractRouter implements Router, ChannelRegistryAware { - - protected final Log logger = LogFactory.getLog(this.getClass()); - - private volatile ChannelRegistry channelRegistry; - - private final MessageExchangeTemplate messageExchangeTemplate = new MessageExchangeTemplate(); - - - public void setChannelRegistry(ChannelRegistry channelRegistry) { - this.channelRegistry = channelRegistry; - } - - protected ChannelRegistry getChannelRegistry() { - return this.channelRegistry; - } - - public final boolean route(Message message) { - Collection results = this.resolveChannels(message); - if (results == null || results.isEmpty()) { - return false; - } - boolean sent = false; - for (Object channelOrName : results) { - MessageTarget target = null; - if (channelOrName == null) { - continue; - } - if (channelOrName instanceof MessageTarget) { - target = (MessageTarget) channelOrName; - } - else if (channelOrName instanceof String) { - if (this.channelRegistry == null) { - throw new MessagingException(message, "router has no ChannelRegistry"); - } - target = this.channelRegistry.lookupChannel((String) channelOrName); - } - else { - throw new MessagingException(message, "unsupported return type for router [" + channelOrName.getClass() + "]"); - } - if (target == null) { - throw new MessageDeliveryException(message, "unable to resolve channel for '" + channelOrName + "'"); - } - this.messageExchangeTemplate.send(message, target); - sent = true; - } - return sent; - } - - /** - * Subclasses must implement this method to return 0 or more MessageChannel - * instances or channel names to which the given Message should be routed. - */ - protected abstract Collection resolveChannels(Message message); - -} diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/MultiChannelResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelNameResolver.java similarity index 70% rename from org.springframework.integration/src/main/java/org/springframework/integration/router/MultiChannelResolver.java rename to org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelNameResolver.java index 0fa75155df..332f93fb91 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/MultiChannelResolver.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelNameResolver.java @@ -16,18 +16,20 @@ package org.springframework.integration.router; -import java.util.List; - import org.springframework.integration.channel.MessageChannel; import org.springframework.integration.message.Message; /** - * Strategy interface for content-based routing to multiple channels. - * * @author Mark Fisher */ -public interface MultiChannelResolver { +public abstract class AbstractSingleChannelNameResolver extends AbstractSingleChannelResolver { - List resolve(Message message); + @Override + protected MessageChannel resolveChannel(Message message) { + String channelName = this.resolveChannelName(message); + return this.lookupChannel(channelName, true); + } + + protected abstract String resolveChannelName(Message message); } diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/Router.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelResolver.java similarity index 60% rename from org.springframework.integration/src/main/java/org/springframework/integration/router/Router.java rename to org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelResolver.java index 89fdcca2f2..460032ee01 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/Router.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelResolver.java @@ -16,15 +16,23 @@ package org.springframework.integration.router; +import java.util.Collection; +import java.util.Collections; + +import org.springframework.integration.channel.MessageChannel; import org.springframework.integration.message.Message; /** - * Strategy interface for routing a Message to one or more channels. - * * @author Mark Fisher */ -public interface Router { +public abstract class AbstractSingleChannelResolver extends AbstractChannelResolver { - boolean route(Message message); + public Collection resolveChannels(Message message) { + MessageChannel channel = this.resolveChannel(message); + return (channel != null) ? + Collections.singletonList(channel) : null; + } + + protected abstract MessageChannel resolveChannel(Message message); } diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/ChannelNameResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/ChannelNameResolver.java deleted file mode 100644 index ce9f8314b6..0000000000 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/ChannelNameResolver.java +++ /dev/null @@ -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.router; - -import org.springframework.integration.message.Message; - -/** - * Strategy interface for content-based routing to a channel name. - * - * @author Mark Fisher - */ -public interface ChannelNameResolver { - - String resolve(Message message); - -} diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/ChannelResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/ChannelResolver.java index ba402e8159..30b3b1cfcd 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/ChannelResolver.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/ChannelResolver.java @@ -16,16 +16,18 @@ package org.springframework.integration.router; +import java.util.Collection; + import org.springframework.integration.channel.MessageChannel; import org.springframework.integration.message.Message; /** - * Strategy interface for content-based routing to a channel instance. + * Strategy interface for content-based routing. * * @author Mark Fisher */ public interface ChannelResolver { - MessageChannel resolve(Message message); + Collection resolveChannels(Message message); } diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingRouter.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingChannelResolver.java similarity index 59% rename from org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingRouter.java rename to org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingChannelResolver.java index 2831a8111f..96ce315def 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingRouter.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingChannelResolver.java @@ -27,25 +27,26 @@ import org.springframework.integration.ConfigurationException; import org.springframework.integration.channel.MessageChannel; import org.springframework.integration.message.Message; import org.springframework.integration.message.MessageMappingMethodInvoker; +import org.springframework.integration.message.MessagingException; /** - * A {@link Router} implementation that invokes the specified method - * on the given object. The method's return value may be a single - * MessageChannel instance, a single String to be interpreted as - * a channel name, or a Collection (or Array) of either type. + * A {@link ChannelResolver} implementation that invokes the specified method + * on the given object. The method's return value may be a single MessageChannel + * instance, a single String to be interpreted as a channel name, or a Collection + * (or Array) of either type. * * @author Mark Fisher */ -public class MethodInvokingRouter extends AbstractRouter implements InitializingBean { +public class MethodInvokingChannelResolver extends AbstractChannelResolver implements InitializingBean { private final MessageMappingMethodInvoker invoker; - public MethodInvokingRouter(Object object, Method method) { + public MethodInvokingChannelResolver(Object object, Method method) { this.invoker = new MessageMappingMethodInvoker(object, method); } - public MethodInvokingRouter(Object object, String methodName) { + public MethodInvokingChannelResolver(Object object, String methodName) { this.invoker = new MessageMappingMethodInvoker(object, methodName); } @@ -55,26 +56,30 @@ public class MethodInvokingRouter extends AbstractRouter implements Initializing } @Override - protected Collection resolveChannels(Message message) { + public final Collection resolveChannels(Message message) { Object result = this.invoker.invokeMethod(message); if (result == null) { return null; } - List channels = new ArrayList(); + List channels = new ArrayList(); if (result instanceof Collection) { - channels.addAll((Collection) result); + for (Object next : (Collection) result) { + this.addChannel(next, channels); + } } else if (result instanceof MessageChannel[]) { channels.addAll(Arrays.asList((MessageChannel[]) result)); } else if (result instanceof String[]) { - channels.addAll(Arrays.asList((String[]) result)); + for (String channelName : (String[]) result) { + this.addChannel(channelName, channels); + } } else if (result instanceof MessageChannel) { channels.add((MessageChannel) result); } else if (result instanceof String) { - channels.add(result); + this.addChannel((String) result, channels); } else { throw new ConfigurationException( @@ -83,4 +88,20 @@ public class MethodInvokingRouter extends AbstractRouter implements Initializing return channels; } + private void addChannel(Object channelOrName, List channels) { + if (channelOrName == null) { + return; + } + if (channelOrName instanceof MessageChannel) { + channels.add((MessageChannel) channelOrName); + } + else if (channelOrName instanceof String) { + MessageChannel channel = this.lookupChannel((String) channelOrName, true); + channels.add(channel); + } + else { + throw new MessagingException("unsupported return type for router [" + channelOrName.getClass() + "]"); + } + } + } diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/MultiChannelRouter.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/MultiChannelRouter.java deleted file mode 100644 index fa3addb3bb..0000000000 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/MultiChannelRouter.java +++ /dev/null @@ -1,68 +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.router; - -import java.util.Arrays; -import java.util.Collection; - -import org.springframework.beans.factory.InitializingBean; -import org.springframework.integration.ConfigurationException; -import org.springframework.integration.channel.MessageChannel; -import org.springframework.integration.message.Message; -import org.springframework.util.ObjectUtils; - -/** - * A router implementation for sending to potentially multiple {@link MessageChannel MessageChannels}. - * Requires either a {@link MultiChannelResolver} or {@link MultiChannelNameResolver} strategy instance. - * - * @author Mark Fisher - */ -public class MultiChannelRouter extends AbstractRouter implements InitializingBean { - - private volatile MultiChannelResolver channelResolver; - - private volatile MultiChannelNameResolver channelNameResolver; - - - public void setChannelResolver(MultiChannelResolver channelResolver) { - this.channelResolver = channelResolver; - } - - public void setChannelNameResolver(MultiChannelNameResolver channelNameResolver) { - this.channelNameResolver = channelNameResolver; - } - - public void afterPropertiesSet() { - if (!(this.channelResolver != null ^ this.channelNameResolver != null)) { - throw new ConfigurationException( - "exactly one of 'channelResolver' or 'channelNameResolver' must be provided"); - } - } - - @Override - public Collection resolveChannels(Message message) { - if (this.channelResolver != null) { - return this.channelResolver.resolve(message); - } - String[] channelNames = this.channelNameResolver.resolve(message); - if (ObjectUtils.isEmpty(channelNames)) { - return null; - } - return Arrays.asList(channelNames); - } - -} diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeRouter.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeChannelResolver.java similarity index 64% rename from org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeRouter.java rename to org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeChannelResolver.java index b86bcb8ed1..d3a245ca5c 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeRouter.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeChannelResolver.java @@ -24,39 +24,24 @@ import org.springframework.integration.message.Message; import org.springframework.util.Assert; /** - * A router implementation that resolves the {@link MessageChannel} based on the - * {@link Message Message's} payload type. + * A ChannelResolver implementation that resolves the {@link MessageChannel} based + * on the {@link Message Message's} payload type. * * @author Mark Fisher */ -public class PayloadTypeRouter extends SingleChannelRouter { +public class PayloadTypeChannelResolver extends AbstractSingleChannelResolver { private Map, MessageChannel> channelMappings = new ConcurrentHashMap, MessageChannel>(); - private MessageChannel defaultChannel; - - - public PayloadTypeRouter() { - this.setChannelResolver(new PayloadTypeChannelResolver()); - } - public void setChannelMappings(Map, MessageChannel> channelMappings) { Assert.notNull(channelMappings, "'channelMappings' must not be null"); this.channelMappings = channelMappings; } - public void setDefaultChannel(MessageChannel defaultChannel) { - this.defaultChannel = defaultChannel; - } - - - private class PayloadTypeChannelResolver implements ChannelResolver { - - public MessageChannel resolve(Message message) { - MessageChannel channel = channelMappings.get(message.getPayload().getClass()); - return channel != null ? channel : defaultChannel; - } + @Override + protected MessageChannel resolveChannel(Message message) { + return this.channelMappings.get(message.getPayload().getClass()); } } diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListChannelResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListChannelResolver.java new file mode 100644 index 0000000000..9ff2845792 --- /dev/null +++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListChannelResolver.java @@ -0,0 +1,71 @@ +/* + * 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.router; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.springframework.beans.factory.InitializingBean; +import org.springframework.integration.ConfigurationException; +import org.springframework.integration.channel.MessageChannel; +import org.springframework.integration.message.Message; + +/** + * A {@link ChannelResolver} implementation that routes to a statically + * configured list of recipients. The recipients are provided either as a list + * of {@link MessageChannel} instances or as a String array of channel names. + * For dynamic recipient lists, either implement {@link ChannelResolver} or + * extend the {@link AbstractMultiChannelNameResolver} base class. + * + * @author Mark Fisher + */ +public class RecipientListChannelResolver extends AbstractChannelResolver implements InitializingBean { + + private volatile List channels; + + private volatile String[] channelNames; + + + public void setChannels(List channels) { + this.channels = channels; + } + + public void setChannelNames(String[] channelNames) { + this.channelNames = channelNames; + } + + public void afterPropertiesSet() { + if ((this.channels != null && this.channelNames != null) + || (this.channels == null && this.channelNames == null)) { + throw new ConfigurationException("either 'channels' or 'channelNames' should be provided, but not both"); + } + } + + @Override + public Collection resolveChannels(Message message) { + if (this.channels == null && this.channelNames != null) { + List resolved = new ArrayList(); + for (String channelName : channelNames) { + resolved.add(this.lookupChannel(channelName, true)); + } + return resolved; + } + return this.channels; + } + +} diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListRouter.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListRouter.java deleted file mode 100644 index e6cb1ce18e..0000000000 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListRouter.java +++ /dev/null @@ -1,72 +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.router; - -import java.util.List; - -import org.springframework.integration.channel.MessageChannel; -import org.springframework.integration.message.Message; - -/** - * A simple extension of {@link MultiChannelRouter} that routes to a statically - * configured list of recipients. The recipients are provided either as a list - * of {@link MessageChannel} instances or as a String array of channel names. - * For dynamic recipient lists, implement either {@link MultiChannelResolver} or - * {@link MultiChannelNameResolver} and then explicitly configure an instance of - * {@link MultiChannelRouter}. - * - * @author Mark Fisher - */ -public class RecipientListRouter extends MultiChannelRouter { - - public void setChannelNames(String[] channelNames) { - this.setChannelNameResolver(new RecipientListChannelNameResolver(channelNames)); - } - - public void setChannels(List channels) { - this.setChannelResolver(new RecipientListChannelResolver(channels)); - } - - - private static class RecipientListChannelResolver implements MultiChannelResolver { - - private List channels; - - RecipientListChannelResolver(List channels) { - this.channels = channels; - } - - public List resolve(Message message) { - return this.channels; - } - } - - - private static class RecipientListChannelNameResolver implements MultiChannelNameResolver { - - private String[] channelNames; - - RecipientListChannelNameResolver(String[] channelNames) { - this.channelNames = channelNames; - } - - public String[] resolve(Message message) { - return this.channelNames; - } - } - -} diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageRouter.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageChannelResolver.java similarity index 53% rename from org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageRouter.java rename to org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageChannelResolver.java index 00a64eba62..45eb597bbf 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageRouter.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageChannelResolver.java @@ -24,52 +24,39 @@ import org.springframework.integration.message.Message; import org.springframework.util.Assert; /** - * A router implementation that resolves the {@link MessageChannel} for messages - * whose payload is an Exception. The channel resolution is based upon the most - * specific cause of the error for which a channel-mapping exists. + * A ChannelResolver implementation that resolves the {@link MessageChannel} for + * messages whose payload is an Exception. The channel resolution is based upon the + * most specific cause of the error for which a channel-mapping exists. * * @author Mark Fisher */ -public class RootCauseErrorMessageRouter extends SingleChannelRouter { +public class RootCauseErrorMessageChannelResolver extends AbstractSingleChannelResolver { private Map, MessageChannel> channelMappings = new ConcurrentHashMap, MessageChannel>(); - private MessageChannel defaultChannel; - - - public RootCauseErrorMessageRouter() { - this.setChannelResolver(new RootCauseResolver()); - } - public void setChannelMappings(Map, MessageChannel> channelMappings) { Assert.notNull(channelMappings, "'channelMappings' must not be null"); this.channelMappings = channelMappings; } - public void setDefaultChannel(MessageChannel defaultChannel) { - this.defaultChannel = defaultChannel; - } - - private class RootCauseResolver implements ChannelResolver { - - public MessageChannel resolve(Message message) { - MessageChannel channel = null; - Object payload = message.getPayload(); - if (payload != null && (payload instanceof Throwable)) { - Throwable mostSpecificCause = (Throwable) payload; - while (mostSpecificCause != null) { - MessageChannel mappedChannel = channelMappings.get(mostSpecificCause.getClass()); - if (mappedChannel != null) { - channel = mappedChannel; - } - mostSpecificCause = mostSpecificCause.getCause(); + @Override + protected MessageChannel resolveChannel(Message message) { + MessageChannel channel = null; + Object payload = message.getPayload(); + if (payload != null && (payload instanceof Throwable)) { + Throwable mostSpecificCause = (Throwable) payload; + while (mostSpecificCause != null) { + MessageChannel mappedChannel = this.channelMappings.get(mostSpecificCause.getClass()); + if (mappedChannel != null) { + channel = mappedChannel; } + mostSpecificCause = mostSpecificCause.getCause(); } - return channel != null ? channel : defaultChannel; } + return channel; } } diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/RouterEndpoint.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/RouterEndpoint.java index 6cf4c03787..50c6357d87 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/RouterEndpoint.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/RouterEndpoint.java @@ -16,12 +16,15 @@ package org.springframework.integration.router; +import java.util.Collection; + import org.springframework.integration.channel.ChannelRegistry; import org.springframework.integration.channel.ChannelRegistryAware; import org.springframework.integration.channel.MessageChannel; import org.springframework.integration.endpoint.AbstractEndpoint; import org.springframework.integration.message.Message; import org.springframework.integration.message.MessageDeliveryException; +import org.springframework.integration.message.MessageExchangeTemplate; import org.springframework.util.Assert; /** @@ -29,24 +32,26 @@ import org.springframework.util.Assert; */ public class RouterEndpoint extends AbstractEndpoint { - private final Router router; + private final ChannelResolver channelResolver; private volatile MessageChannel defaultOutputChannel; private volatile boolean resolutionRequired; + private final MessageExchangeTemplate messageExchangeTemplate = new MessageExchangeTemplate(); - public RouterEndpoint(Router router) { - Assert.notNull(router, "router must not be null"); - this.router = router; + + public RouterEndpoint(ChannelResolver channelResolver) { + Assert.notNull(channelResolver, "ChannelResolver must not be null"); + this.channelResolver = channelResolver; } @Override public void setChannelRegistry(ChannelRegistry channelRegistry) { super.setChannelRegistry(channelRegistry); - if (this.router instanceof ChannelRegistryAware) { - ((ChannelRegistryAware) this.router).setChannelRegistry(channelRegistry); + if (this.channelResolver instanceof ChannelRegistryAware) { + ((ChannelRegistryAware) this.channelResolver).setChannelRegistry(channelRegistry); } } @@ -74,7 +79,17 @@ public class RouterEndpoint extends AbstractEndpoint { @Override protected boolean sendInternal(Message message) { - boolean sent = this.router.route(message); + boolean sent = false; + Collection results = this.channelResolver.resolveChannels(message); + if (results != null) { + for (MessageChannel channel : results) { + if (channel != null) { + if (this.messageExchangeTemplate.send(message, channel)) { + sent = true; + } + } + } + } if (!sent) { if (this.defaultOutputChannel != null) { sent = this.getMessageExchangeTemplate().send(message, this.defaultOutputChannel); diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/SingleChannelRouter.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/SingleChannelRouter.java deleted file mode 100644 index 32b7c6ddd2..0000000000 --- a/org.springframework.integration/src/main/java/org/springframework/integration/router/SingleChannelRouter.java +++ /dev/null @@ -1,67 +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.router; - -import java.util.Collection; -import java.util.Collections; - -import org.springframework.beans.factory.InitializingBean; -import org.springframework.integration.ConfigurationException; -import org.springframework.integration.channel.MessageChannel; -import org.springframework.integration.message.Message; - -/** - * A router implementation for sending to at most one {@link MessageChannel}. - * Requires either a {@link ChannelResolver} or {@link ChannelNameResolver} - * strategy instance. - * - * @author Mark Fisher - */ -public class SingleChannelRouter extends AbstractRouter implements InitializingBean { - - private ChannelResolver channelResolver; - - private ChannelNameResolver channelNameResolver; - - - public void setChannelResolver(ChannelResolver channelResolver) { - this.channelResolver = channelResolver; - } - - public void setChannelNameResolver(ChannelNameResolver channelNameResolver) { - this.channelNameResolver = channelNameResolver; - } - - public void afterPropertiesSet() { - if (!(this.channelResolver != null ^ this.channelNameResolver != null)) { - throw new ConfigurationException( - "exactly one of 'channelResolver' or 'channelNameResolver' must be provided"); - } - } - - @Override - protected Collection resolveChannels(Message message) { - Object result = (this.channelResolver != null) - ? this.channelResolver.resolve(message) - : this.channelNameResolver.resolve(message); - if (result == null) { - return null; - } - return Collections.singletonList(result); - } - -} diff --git a/org.springframework.integration/src/test/java/org/springframework/integration/router/MethodInvokingRouterTests.java b/org.springframework.integration/src/test/java/org/springframework/integration/router/MethodInvokingRouterTests.java index ba19c4cf2d..b5ad6a2147 100644 --- a/org.springframework.integration/src/test/java/org/springframework/integration/router/MethodInvokingRouterTests.java +++ b/org.springframework.integration/src/test/java/org/springframework/integration/router/MethodInvokingRouterTests.java @@ -53,10 +53,11 @@ public class MethodInvokingRouterTests { channelRegistry.registerChannel(barChannel); SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean(); Method routingMethod = testBean.getClass().getMethod("routePayload", String.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - router.setChannelRegistry(channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setChannelRegistry(channelRegistry); Message message = new GenericMessage("bar"); - assertTrue(router.route(message)); + assertTrue(endpoint.send(message)); Message replyMessage = barChannel.receive(); assertNotNull(replyMessage); assertEquals(message, replyMessage); @@ -69,10 +70,11 @@ public class MethodInvokingRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); channelRegistry.registerChannel(barChannel); SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean(); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload"); - router.setChannelRegistry(channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload"); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setChannelRegistry(channelRegistry); Message message = new GenericMessage("bar"); - assertTrue(router.route(message)); + assertTrue(endpoint.send(message)); Message replyMessage = barChannel.receive(); assertNotNull(replyMessage); assertEquals(message, replyMessage); @@ -89,11 +91,12 @@ public class MethodInvokingRouterTests { channelRegistry.registerChannel(barChannel); SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean(); Method routingMethod = testBean.getClass().getMethod("routeByHeader", String.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - router.setChannelRegistry(channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setChannelRegistry(channelRegistry); Message message = MessageBuilder.fromPayload("bar") .setHeader("targetChannel", "foo").build(); - assertTrue(router.route(message)); + assertTrue(endpoint.send(message)); Message fooReply = fooChannel.receive(0); Message barReply = barChannel.receive(0); assertNotNull(fooReply); @@ -105,26 +108,29 @@ public class MethodInvokingRouterTests { public void failsWhenRequiredHeaderIsNotProvided() throws Exception { SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean(); Method routingMethod = testBean.getClass().getMethod("routeByHeader", String.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - router.route(new GenericMessage("testing")); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.send(new GenericMessage("testing")); } @Test public void channelNameResolutionByMessageConfiguredByMethodReference() throws Exception { SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean(); Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - this.doTestChannelNameResolutionByMessage(router); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestChannelNameResolutionByMessage(endpoint); } @Test public void channelNameResolutionByMessageConfiguredByMethodName() { SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean(); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage"); - this.doTestChannelNameResolutionByMessage(router); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage"); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestChannelNameResolutionByMessage(endpoint); } - private void doTestChannelNameResolutionByMessage(MethodInvokingRouter router) { + private void doTestChannelNameResolutionByMessage(RouterEndpoint endpoint) { QueueChannel fooChannel = new QueueChannel(); QueueChannel barChannel = new QueueChannel(); fooChannel.setBeanName("foo-channel"); @@ -132,19 +138,19 @@ public class MethodInvokingRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); channelRegistry.registerChannel(fooChannel); channelRegistry.registerChannel(barChannel); - router.setChannelRegistry(channelRegistry); + endpoint.setChannelRegistry(channelRegistry); Message fooMessage = new StringMessage("foo"); Message barMessage = new StringMessage("bar"); Message badMessage = new StringMessage("bad"); - assertTrue(router.route(fooMessage)); + assertTrue(endpoint.send(fooMessage)); Message result1 = fooChannel.receive(0); assertNotNull(result1); assertEquals("foo", result1.getPayload()); - assertTrue(router.route(barMessage)); + assertTrue(endpoint.send(barMessage)); Message result2 = barChannel.receive(0); assertNotNull(result2); assertEquals("bar", result2.getPayload()); - assertFalse(router.route(badMessage)); + assertFalse(endpoint.send(badMessage)); } @Test @@ -152,19 +158,21 @@ public class MethodInvokingRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry); Method routingMethod = testBean.getClass().getMethod("routePayload", String.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - this.doTestChannelInstanceResolutionByPayload(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestChannelInstanceResolutionByPayload(endpoint, channelRegistry); } @Test public void channelInstanceResolutionByPayloadConfiguredByMethodName() { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload"); - this.doTestChannelInstanceResolutionByPayload(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload"); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestChannelInstanceResolutionByPayload(endpoint, channelRegistry); } - private void doTestChannelInstanceResolutionByPayload(MethodInvokingRouter router, ChannelRegistry channelRegistry) { + private void doTestChannelInstanceResolutionByPayload(RouterEndpoint endpoint, ChannelRegistry channelRegistry) { Message fooMessage = new StringMessage("foo"); Message barMessage = new StringMessage("bar"); Message badMessage = new StringMessage("bad"); @@ -174,16 +182,16 @@ public class MethodInvokingRouterTests { barChannel.setBeanName("bar-channel"); channelRegistry.registerChannel(fooChannel); channelRegistry.registerChannel(barChannel); - router.setChannelRegistry(channelRegistry); - assertTrue(router.route(fooMessage)); + endpoint.setChannelRegistry(channelRegistry); + assertTrue(endpoint.send(fooMessage)); Message result1 = fooChannel.receive(0); assertNotNull(result1); assertEquals("foo", result1.getPayload()); - assertTrue(router.route(barMessage)); + assertTrue(endpoint.send(barMessage)); Message result2 = barChannel.receive(0); assertNotNull(result2); assertEquals("bar", result2.getPayload()); - assertFalse(router.route(badMessage)); + assertFalse(endpoint.send(badMessage)); } @Test @@ -191,38 +199,40 @@ public class MethodInvokingRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry); Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - this.doTestChannelInstanceResolutionByMessage(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestChannelInstanceResolutionByMessage(endpoint, channelRegistry); } @Test public void channelInstanceResolutionByMessageConfiguredByMethodName() { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage"); - this.doTestChannelInstanceResolutionByMessage(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage"); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestChannelInstanceResolutionByMessage(endpoint, channelRegistry); } - private void doTestChannelInstanceResolutionByMessage(MethodInvokingRouter router, ChannelRegistry channelRegistry) { + private void doTestChannelInstanceResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) { QueueChannel fooChannel = new QueueChannel(); QueueChannel barChannel = new QueueChannel(); fooChannel.setBeanName("foo-channel"); barChannel.setBeanName("bar-channel"); channelRegistry.registerChannel(fooChannel); channelRegistry.registerChannel(barChannel); - router.setChannelRegistry(channelRegistry); + endpoint.setChannelRegistry(channelRegistry); Message fooMessage = new StringMessage("foo"); Message barMessage = new StringMessage("bar"); Message badMessage = new StringMessage("bad"); - assertTrue(router.route(fooMessage)); + assertTrue(endpoint.send(fooMessage)); Message result1 = fooChannel.receive(0); assertNotNull(result1); assertEquals("foo", result1.getPayload()); - assertTrue(router.route(barMessage)); + assertTrue(endpoint.send(barMessage)); Message result2 = barChannel.receive(0); assertNotNull(result2); assertEquals("bar", result2.getPayload()); - assertFalse(router.route(badMessage)); + assertFalse(endpoint.send(badMessage)); } @Test @@ -230,44 +240,46 @@ public class MethodInvokingRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean(); Method routingMethod = testBean.getClass().getMethod("routePayload", String.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - this.doTestMultiChannelNameResolutionByPayload(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelNameResolutionByPayload(endpoint, channelRegistry); } @Test public void multiChannelNameResolutionByPayloadConfiguredByMethodName() { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean(); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload"); - this.doTestMultiChannelNameResolutionByPayload(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload"); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelNameResolutionByPayload(endpoint, channelRegistry); } - private void doTestMultiChannelNameResolutionByPayload(MethodInvokingRouter router, ChannelRegistry channelRegistry) { + private void doTestMultiChannelNameResolutionByPayload(RouterEndpoint endpoint, ChannelRegistry channelRegistry) { QueueChannel fooChannel = new QueueChannel(); QueueChannel barChannel = new QueueChannel(); fooChannel.setBeanName("foo-channel"); barChannel.setBeanName("bar-channel"); channelRegistry.registerChannel(fooChannel); channelRegistry.registerChannel(barChannel); - router.setChannelRegistry(channelRegistry); + endpoint.setChannelRegistry(channelRegistry); Message fooMessage = new StringMessage("foo"); Message barMessage = new StringMessage("bar"); Message badMessage = new StringMessage("bad"); - assertTrue(router.route(fooMessage)); + assertTrue(endpoint.send(fooMessage)); Message result1a = fooChannel.receive(0); Message result1b = barChannel.receive(0); assertNotNull(result1a); assertEquals("foo", result1a.getPayload()); assertNotNull(result1b); assertEquals("foo", result1b.getPayload()); - assertTrue(router.route(barMessage)); + assertTrue(endpoint.send(barMessage)); Message result2a = fooChannel.receive(0); Message result2b = barChannel.receive(0); assertNotNull(result2a); assertEquals("bar", result2a.getPayload()); assertNotNull(result2b); assertEquals("bar", result2b.getPayload()); - assertFalse(router.route(badMessage)); + assertFalse(endpoint.send(badMessage)); } @Test @@ -275,44 +287,46 @@ public class MethodInvokingRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean(); Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - this.doTestMultiChannelNameResolutionByMessage(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelNameResolutionByMessage(endpoint, channelRegistry); } @Test public void multiChannelNameResolutionByMessageConfiguredByMethodName() throws Exception { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean(); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage"); - this.doTestMultiChannelNameResolutionByMessage(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage"); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelNameResolutionByMessage(endpoint, channelRegistry); } - private void doTestMultiChannelNameResolutionByMessage(MethodInvokingRouter router, ChannelRegistry channelRegistry) { + private void doTestMultiChannelNameResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) { QueueChannel fooChannel = new QueueChannel(); QueueChannel barChannel = new QueueChannel(); fooChannel.setBeanName("foo-channel"); barChannel.setBeanName("bar-channel"); channelRegistry.registerChannel(fooChannel); channelRegistry.registerChannel(barChannel); - router.setChannelRegistry(channelRegistry); + endpoint.setChannelRegistry(channelRegistry); Message fooMessage = new StringMessage("foo"); Message barMessage = new StringMessage("bar"); Message badMessage = new StringMessage("bad"); - assertTrue(router.route(fooMessage)); + assertTrue(endpoint.send(fooMessage)); Message result1a = fooChannel.receive(0); assertNotNull(result1a); assertEquals("foo", result1a.getPayload()); Message result1b = barChannel.receive(0); assertNotNull(result1b); assertEquals("foo", result1b.getPayload()); - assertTrue(router.route(barMessage)); + assertTrue(endpoint.send(barMessage)); Message result2a = fooChannel.receive(0); assertNotNull(result2a); assertEquals("bar", result2a.getPayload()); Message result2b = barChannel.receive(0); assertNotNull(result2b); assertEquals("bar", result2b.getPayload()); - assertFalse(router.route(badMessage)); + assertFalse(endpoint.send(badMessage)); } @Test @@ -320,44 +334,46 @@ public class MethodInvokingRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean(); Method routingMethod = testBean.getClass().getMethod("routeMessageToArray", Message.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - this.doTestMultiChannelNameArrayResolutionByMessage(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelNameArrayResolutionByMessage(endpoint, channelRegistry); } @Test public void multiChannelNameArrayResolutionByMessageConfiguredByMethodName() { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean(); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessageToArray"); - this.doTestMultiChannelNameArrayResolutionByMessage(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessageToArray"); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelNameArrayResolutionByMessage(endpoint, channelRegistry); } - private void doTestMultiChannelNameArrayResolutionByMessage(MethodInvokingRouter router, ChannelRegistry channelRegistry) { + private void doTestMultiChannelNameArrayResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) { QueueChannel fooChannel = new QueueChannel(); QueueChannel barChannel = new QueueChannel(); fooChannel.setBeanName("foo-channel"); barChannel.setBeanName("bar-channel"); channelRegistry.registerChannel(fooChannel); channelRegistry.registerChannel(barChannel); - router.setChannelRegistry(channelRegistry); + endpoint.setChannelRegistry(channelRegistry); Message fooMessage = new StringMessage("foo"); Message barMessage = new StringMessage("bar"); Message badMessage = new StringMessage("bad"); - assertTrue(router.route(fooMessage)); + assertTrue(endpoint.send(fooMessage)); Message result1a = fooChannel.receive(0); assertNotNull(result1a); assertEquals("foo", result1a.getPayload()); Message result1b = barChannel.receive(0); assertNotNull(result1b); assertEquals("foo", result1b.getPayload()); - assertTrue(router.route(barMessage)); + assertTrue(endpoint.send(barMessage)); Message result2a = fooChannel.receive(0); assertNotNull(result2a); assertEquals("bar", result2a.getPayload()); Message result2b = barChannel.receive(0); assertNotNull(result2b); assertEquals("bar", result2b.getPayload()); - assertFalse(router.route(badMessage)); + assertFalse(endpoint.send(badMessage)); } @Test @@ -365,44 +381,46 @@ public class MethodInvokingRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry); Method routingMethod = testBean.getClass().getMethod("routePayload", String.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - this.doTestMultiChannelListResolutionByPayload(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelListResolutionByPayload(endpoint, channelRegistry); } @Test public void multiChannelListResolutionByPayloadConfiguredByMethodName() { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload"); - this.doTestMultiChannelListResolutionByPayload(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload"); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelListResolutionByPayload(endpoint, channelRegistry); } - private void doTestMultiChannelListResolutionByPayload(MethodInvokingRouter router, ChannelRegistry channelRegistry) { + private void doTestMultiChannelListResolutionByPayload(RouterEndpoint endpoint, ChannelRegistry channelRegistry) { QueueChannel fooChannel = new QueueChannel(); QueueChannel barChannel = new QueueChannel(); fooChannel.setBeanName("foo-channel"); barChannel.setBeanName("bar-channel"); channelRegistry.registerChannel(fooChannel); channelRegistry.registerChannel(barChannel); - router.setChannelRegistry(channelRegistry); + endpoint.setChannelRegistry(channelRegistry); Message fooMessage = new StringMessage("foo"); Message barMessage = new StringMessage("bar"); Message badMessage = new StringMessage("bad"); - assertTrue(router.route(fooMessage)); + assertTrue(endpoint.send(fooMessage)); Message result1a = fooChannel.receive(0); Message result1b = barChannel.receive(0); assertNotNull(result1a); assertEquals("foo", result1a.getPayload()); assertNotNull(result1b); assertEquals("foo", result1b.getPayload()); - assertTrue(router.route(barMessage)); + assertTrue(endpoint.send(barMessage)); Message result2a = fooChannel.receive(0); Message result2b = barChannel.receive(0); assertNotNull(result2a); assertEquals("bar", result2a.getPayload()); assertNotNull(result2b); assertEquals("bar", result2b.getPayload()); - assertFalse(router.route(badMessage)); + assertFalse(endpoint.send(badMessage)); } @Test @@ -410,44 +428,46 @@ public class MethodInvokingRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry); Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - this.doTestMultiChannelListResolutionByMessage(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelListResolutionByMessage(endpoint, channelRegistry); } @Test public void multiChannelListResolutionByMessageConfiguredByMethodName() { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage"); - this.doTestMultiChannelListResolutionByMessage(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage"); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelListResolutionByMessage(endpoint, channelRegistry); } - private void doTestMultiChannelListResolutionByMessage(MethodInvokingRouter router, ChannelRegistry channelRegistry) { + private void doTestMultiChannelListResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) { QueueChannel fooChannel = new QueueChannel(); QueueChannel barChannel = new QueueChannel(); fooChannel.setBeanName("foo-channel"); barChannel.setBeanName("bar-channel"); channelRegistry.registerChannel(fooChannel); channelRegistry.registerChannel(barChannel); - router.setChannelRegistry(channelRegistry); + endpoint.setChannelRegistry(channelRegistry); Message fooMessage = new StringMessage("foo"); Message barMessage = new StringMessage("bar"); Message badMessage = new StringMessage("bad"); - assertTrue(router.route(fooMessage)); + assertTrue(endpoint.send(fooMessage)); Message result1a = fooChannel.receive(0); Message result1b = barChannel.receive(0); assertNotNull(result1a); assertEquals("foo", result1a.getPayload()); assertNotNull(result1b); assertEquals("foo", result1b.getPayload()); - assertTrue(router.route(barMessage)); + assertTrue(endpoint.send(barMessage)); Message result2a = fooChannel.receive(0); Message result2b = barChannel.receive(0); assertNotNull(result2a); assertEquals("bar", result2a.getPayload()); assertNotNull(result2b); assertEquals("bar", result2b.getPayload()); - assertFalse(router.route(badMessage)); + assertFalse(endpoint.send(badMessage)); } @Test @@ -455,44 +475,46 @@ public class MethodInvokingRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry); Method routingMethod = testBean.getClass().getMethod("routeMessageToArray", Message.class); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod); - this.doTestMultiChannelArrayResolutionByMessage(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelArrayResolutionByMessage(endpoint, channelRegistry); } @Test public void multiChannelArrayResolutionByMessageConfiguredByMethodName() { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry); - MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessageToArray"); - this.doTestMultiChannelArrayResolutionByMessage(router, channelRegistry); + MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessageToArray"); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + this.doTestMultiChannelArrayResolutionByMessage(endpoint, channelRegistry); } - private void doTestMultiChannelArrayResolutionByMessage(MethodInvokingRouter router, ChannelRegistry channelRegistry) { + private void doTestMultiChannelArrayResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) { QueueChannel fooChannel = new QueueChannel(); QueueChannel barChannel = new QueueChannel(); fooChannel.setBeanName("foo-channel"); barChannel.setBeanName("bar-channel"); channelRegistry.registerChannel(fooChannel); channelRegistry.registerChannel(barChannel); - router.setChannelRegistry(channelRegistry); + endpoint.setChannelRegistry(channelRegistry); Message fooMessage = new StringMessage("foo"); Message barMessage = new StringMessage("bar"); Message badMessage = new StringMessage("bad"); - assertTrue(router.route(fooMessage)); + assertTrue(endpoint.send(fooMessage)); Message result1a = fooChannel.receive(0); Message result1b = barChannel.receive(0); assertNotNull(result1a); assertEquals("foo", result1a.getPayload()); assertNotNull(result1b); assertEquals("foo", result1b.getPayload()); - assertTrue(router.route(barMessage)); + assertTrue(endpoint.send(barMessage)); Message result2a = fooChannel.receive(0); Message result2b = barChannel.receive(0); assertNotNull(result2a); assertEquals("bar", result2a.getPayload()); assertNotNull(result2b); assertEquals("bar", result2b.getPayload()); - assertFalse(router.route(badMessage)); + assertFalse(endpoint.send(badMessage)); } diff --git a/org.springframework.integration/src/test/java/org/springframework/integration/router/MultiChannelRouterTests.java b/org.springframework.integration/src/test/java/org/springframework/integration/router/MultiChannelRouterTests.java index 14b344d3e8..9b7aaf0c23 100644 --- a/org.springframework.integration/src/test/java/org/springframework/integration/router/MultiChannelRouterTests.java +++ b/org.springframework.integration/src/test/java/org/springframework/integration/router/MultiChannelRouterTests.java @@ -24,13 +24,12 @@ import java.util.List; import org.junit.Test; -import org.springframework.integration.ConfigurationException; import org.springframework.integration.channel.ChannelRegistry; import org.springframework.integration.channel.DefaultChannelRegistry; import org.springframework.integration.channel.MessageChannel; import org.springframework.integration.channel.QueueChannel; import org.springframework.integration.message.Message; -import org.springframework.integration.message.MessageDeliveryException; +import org.springframework.integration.message.MessagingException; import org.springframework.integration.message.StringMessage; /** @@ -42,19 +41,17 @@ public class MultiChannelRouterTests { public void routeWithChannelResolver() { final QueueChannel channel1 = new QueueChannel(); final QueueChannel channel2 = new QueueChannel(); - MultiChannelResolver channelResolver = new MultiChannelResolver() { - public List resolve(Message message) { + AbstractChannelResolver channelResolver = new AbstractChannelResolver() { + public List resolveChannels(Message message) { List channels = new ArrayList(); channels.add(channel1); channels.add(channel2); return channels; } }; - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelResolver(channelResolver); - router.afterPropertiesSet(); + RouterEndpoint endpoint = new RouterEndpoint(channelResolver); Message message = new StringMessage("test"); - router.route(message); + endpoint.send(message); Message result1 = channel1.receive(25); assertNotNull(result1); assertEquals("test", result1.getPayload()); @@ -65,8 +62,8 @@ public class MultiChannelRouterTests { @Test public void routeWithChannelNameResolver() { - MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() { - public String[] resolve(Message message) { + AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() { + public String[] resolveChannelNames(Message message) { return new String[] {"channel1", "channel2"}; } }; @@ -77,12 +74,10 @@ public class MultiChannelRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); channelRegistry.registerChannel(channel1); channelRegistry.registerChannel(channel2); - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelNameResolver(channelNameResolver); - router.setChannelRegistry(channelRegistry); - router.afterPropertiesSet(); + RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver); + endpoint.setChannelRegistry(channelRegistry); Message message = new StringMessage("test"); - router.route(message); + endpoint.send(message); Message result1 = channel1.receive(25); assertNotNull(result1); assertEquals("test", result1.getPayload()); @@ -91,46 +86,30 @@ public class MultiChannelRouterTests { assertEquals("test", result2.getPayload()); } - @Test(expected = ConfigurationException.class) - public void configuringBothChannelResolverAndChannelNameResolverIsNotAllowed() { - MultiChannelResolver channelResolver = new MultiChannelResolver() { - public List resolve(Message message) { - return null; - } - }; - MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() { - public String[] resolve(Message message) { - return null; - } - }; - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelResolver(channelResolver); - router.setChannelNameResolver(channelNameResolver); - router.afterPropertiesSet(); - } - - @Test(expected = MessageDeliveryException.class) + @Test(expected = MessagingException.class) public void channelNameLookupFailure() { - MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() { - public String[] resolve(Message message) { + AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() { + public String[] resolveChannelNames(Message message) { return new String[] {"noSuchChannel"}; } }; ChannelRegistry channelRegistry = new DefaultChannelRegistry(); - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelNameResolver(channelNameResolver); - router.setChannelRegistry(channelRegistry); - router.afterPropertiesSet(); + RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver); + endpoint.setChannelRegistry(channelRegistry); Message message = new StringMessage("test"); - router.route(message); + endpoint.send(message); } - @Test(expected = ConfigurationException.class) - public void channelResolverIsRequired() { - ChannelRegistry channelRegistry = new DefaultChannelRegistry(); - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelRegistry(channelRegistry); - router.afterPropertiesSet(); + @Test(expected = MessagingException.class) + public void channelRegistryNotAvailable() { + AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() { + public String[] resolveChannelNames(Message message) { + return new String[] {"noSuchChannel"}; + } + }; + RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver); + Message message = new StringMessage("test"); + endpoint.send(message); } } diff --git a/org.springframework.integration/src/test/java/org/springframework/integration/router/PayloadTypeRouterTests.java b/org.springframework.integration/src/test/java/org/springframework/integration/router/PayloadTypeRouterTests.java index 79e38716f0..9c4ede3db5 100644 --- a/org.springframework.integration/src/test/java/org/springframework/integration/router/PayloadTypeRouterTests.java +++ b/org.springframework.integration/src/test/java/org/springframework/integration/router/PayloadTypeRouterTests.java @@ -24,6 +24,7 @@ import java.util.concurrent.ConcurrentHashMap; import org.junit.Test; +import org.springframework.integration.channel.DefaultChannelRegistry; import org.springframework.integration.channel.MessageChannel; import org.springframework.integration.channel.QueueChannel; import org.springframework.integration.message.GenericMessage; @@ -36,41 +37,67 @@ import org.springframework.integration.message.StringMessage; public class PayloadTypeRouterTests { @Test - public void testRoutingByPayloadType() { + public void resolveByPayloadType() { QueueChannel stringChannel = new QueueChannel(); QueueChannel integerChannel = new QueueChannel(); Map, MessageChannel> channelMappings = new ConcurrentHashMap, MessageChannel>(); channelMappings.put(String.class, stringChannel); channelMappings.put(Integer.class, integerChannel); - PayloadTypeRouter router = new PayloadTypeRouter(); - router.setChannelMappings(channelMappings); - router.afterPropertiesSet(); + PayloadTypeChannelResolver resolver = new PayloadTypeChannelResolver(); + resolver.setChannelMappings(channelMappings); Message message1 = new StringMessage("test"); Message message2 = new GenericMessage(123); - router.route(message1); - router.route(message2); - Message result1 = stringChannel.receive(25); - assertNotNull(result1); - assertEquals("test", result1.getPayload()); - Message result2 = integerChannel.receive(25); - assertNotNull(result2); - assertEquals(123, result2.getPayload()); + MessageChannel result1 = resolver.resolveChannel(message1); + MessageChannel result2 = resolver.resolveChannel(message2); + assertEquals(stringChannel, result1); + assertEquals(integerChannel, result2); } @Test - public void testRoutingToDefaultChannelWhenNoTypeMatches() { + public void resolveByPayloadTypeWithRouterEndpoint() { QueueChannel stringChannel = new QueueChannel(); - QueueChannel defaultChannel = new QueueChannel(); + QueueChannel integerChannel = new QueueChannel(); + stringChannel.setBeanName("stringChannel"); + integerChannel.setBeanName("integerChannel"); Map, MessageChannel> channelMappings = new ConcurrentHashMap, MessageChannel>(); channelMappings.put(String.class, stringChannel); - PayloadTypeRouter router = new PayloadTypeRouter(); - router.setChannelMappings(channelMappings); - router.setDefaultChannel(defaultChannel); - router.afterPropertiesSet(); + channelMappings.put(Integer.class, integerChannel); + DefaultChannelRegistry channelRegistry = new DefaultChannelRegistry(); + channelRegistry.registerChannel(stringChannel); + channelRegistry.registerChannel(integerChannel); + PayloadTypeChannelResolver resolver = new PayloadTypeChannelResolver(); + resolver.setChannelMappings(channelMappings); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setChannelRegistry(channelRegistry); Message message1 = new StringMessage("test"); Message message2 = new GenericMessage(123); - router.route(message1); - router.route(message2); + endpoint.send(message1); + endpoint.send(message2); + Message reply1 = stringChannel.receive(0); + Message reply2 = integerChannel.receive(0); + assertEquals("test", reply1.getPayload()); + assertEquals(123, reply2.getPayload()); + } + + @Test + public void routingToDefaultChannelWhenNoTypeMatches() { + QueueChannel stringChannel = new QueueChannel(); + stringChannel.setBeanName("stringChannel"); + QueueChannel defaultChannel = new QueueChannel(); + defaultChannel.setBeanName("defaultChannel"); + DefaultChannelRegistry channelRegistry = new DefaultChannelRegistry(); + channelRegistry.registerChannel(stringChannel); + channelRegistry.registerChannel(defaultChannel); + Map, MessageChannel> channelMappings = new ConcurrentHashMap, MessageChannel>(); + channelMappings.put(String.class, stringChannel); + PayloadTypeChannelResolver resolver = new PayloadTypeChannelResolver(); + resolver.setChannelMappings(channelMappings); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setDefaultOutputChannel(defaultChannel); + Message message1 = new StringMessage("test"); + Message message2 = new GenericMessage(123); + endpoint.send(message1); + endpoint.send(message2); Message result1 = stringChannel.receive(25); assertNotNull(result1); assertEquals("test", result1.getPayload()); diff --git a/org.springframework.integration/src/test/java/org/springframework/integration/router/RecipientListRouterTests.java b/org.springframework.integration/src/test/java/org/springframework/integration/router/RecipientListRouterTests.java index 05ee1739db..738119a2ba 100644 --- a/org.springframework.integration/src/test/java/org/springframework/integration/router/RecipientListRouterTests.java +++ b/org.springframework.integration/src/test/java/org/springframework/integration/router/RecipientListRouterTests.java @@ -19,8 +19,10 @@ package org.springframework.integration.router; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import org.junit.Test; @@ -38,6 +40,23 @@ import org.springframework.integration.message.StringMessage; */ public class RecipientListRouterTests { + @Test + public void resolveWithChannelList() { + QueueChannel channel1 = new QueueChannel(); + QueueChannel channel2 = new QueueChannel(); + List channels = new ArrayList(); + channels.add(channel1); + channels.add(channel2); + RecipientListChannelResolver resolver = new RecipientListChannelResolver(); + resolver.setChannels(channels); + resolver.afterPropertiesSet(); + Message message = new StringMessage("test"); + Collection resolved = resolver.resolveChannels(message); + assertEquals(2, resolved.size()); + assertTrue(resolved.contains(channel1)); + assertTrue(resolved.contains(channel2)); + } + @Test public void routeWithChannelList() { QueueChannel channel1 = new QueueChannel(); @@ -45,11 +64,12 @@ public class RecipientListRouterTests { List channels = new ArrayList(); channels.add(channel1); channels.add(channel2); - RecipientListRouter router = new RecipientListRouter(); - router.setChannels(channels); - router.afterPropertiesSet(); + RecipientListChannelResolver resolver = new RecipientListChannelResolver(); + resolver.setChannels(channels); + resolver.afterPropertiesSet(); + RouterEndpoint endpoint = new RouterEndpoint(resolver); Message message = new StringMessage("test"); - router.route(message); + endpoint.send(message); Message result1 = channel1.receive(25); assertNotNull(result1); assertEquals("test", result1.getPayload()); @@ -67,12 +87,13 @@ public class RecipientListRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); channelRegistry.registerChannel(channel1); channelRegistry.registerChannel(channel2); - RecipientListRouter router = new RecipientListRouter(); - router.setChannelNames(new String[] {"channel1", "channel2"}); - router.setChannelRegistry(channelRegistry); - router.afterPropertiesSet(); + RecipientListChannelResolver resolver = new RecipientListChannelResolver(); + resolver.setChannelNames(new String[] {"channel1", "channel2"}); + resolver.afterPropertiesSet(); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setChannelRegistry(channelRegistry); Message message = new StringMessage("test"); - router.route(message); + endpoint.send(message); Message result1 = channel1.receive(25); assertNotNull(result1); assertEquals("test", result1.getPayload()); @@ -90,12 +111,13 @@ public class RecipientListRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); channelRegistry.registerChannel(channel1); channelRegistry.registerChannel(channel2); - RecipientListRouter router = new RecipientListRouter(); - router.setChannelNames(new String[] {"channel1"}); - router.setChannelRegistry(channelRegistry); - router.afterPropertiesSet(); + RecipientListChannelResolver resolver = new RecipientListChannelResolver(); + resolver.setChannelNames(new String[] {"channel1"}); + resolver.afterPropertiesSet(); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setChannelRegistry(channelRegistry); Message message = new StringMessage("test"); - router.route(message); + endpoint.send(message); Message result1 = channel1.receive(25); assertNotNull(result1); assertEquals("test", result1.getPayload()); @@ -115,11 +137,11 @@ public class RecipientListRouterTests { ChannelRegistry channelRegistry = new DefaultChannelRegistry(); channelRegistry.registerChannel(channel1); channelRegistry.registerChannel(channel2); - RecipientListRouter router = new RecipientListRouter(); - router.setChannels(channels); - router.setChannelNames(new String[] {"channel1"}); - router.setChannelRegistry(channelRegistry); - router.afterPropertiesSet(); + RecipientListChannelResolver resolver = new RecipientListChannelResolver(); + resolver.setChannels(channels); + resolver.setChannelNames(new String[] {"channel1"}); + resolver.setChannelRegistry(channelRegistry); + resolver.afterPropertiesSet(); } } diff --git a/org.springframework.integration/src/test/java/org/springframework/integration/router/RootCauseErrorMessageRouterTests.java b/org.springframework.integration/src/test/java/org/springframework/integration/router/RootCauseErrorMessageRouterTests.java index 8e0a12053b..64cc4573f8 100644 --- a/org.springframework.integration/src/test/java/org/springframework/integration/router/RootCauseErrorMessageRouterTests.java +++ b/org.springframework.integration/src/test/java/org/springframework/integration/router/RootCauseErrorMessageRouterTests.java @@ -56,16 +56,16 @@ public class RootCauseErrorMessageRouterTests { RuntimeException middleCause = new RuntimeException(rootCause); MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause); ErrorMessage message = new ErrorMessage(error); - RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter(); + RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver(); Map, MessageChannel> channelMappings = new HashMap, MessageChannel>(); channelMappings.put(IllegalArgumentException.class, illegalArgumentChannel); channelMappings.put(RuntimeException.class, runtimeExceptionChannel); channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel); - router.setChannelMappings(channelMappings); - router.setDefaultChannel(defaultChannel); - router.afterPropertiesSet(); - router.route(message); + resolver.setChannelMappings(channelMappings); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setDefaultOutputChannel(defaultChannel); + endpoint.send(message); assertNotNull(illegalArgumentChannel.receive(1000)); assertNull(defaultChannel.receive(0)); assertNull(runtimeExceptionChannel.receive(0)); @@ -79,15 +79,15 @@ public class RootCauseErrorMessageRouterTests { RuntimeException middleCause = new RuntimeException(rootCause); MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause); ErrorMessage message = new ErrorMessage(error); - RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter(); + RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver(); Map, MessageChannel> channelMappings = new HashMap, MessageChannel>(); channelMappings.put(RuntimeException.class, runtimeExceptionChannel); channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel); - router.setChannelMappings(channelMappings); - router.setDefaultChannel(defaultChannel); - router.afterPropertiesSet(); - router.route(message); + resolver.setChannelMappings(channelMappings); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setDefaultOutputChannel(defaultChannel); + endpoint.send(message); assertNotNull(runtimeExceptionChannel.receive(1000)); assertNull(illegalArgumentChannel.receive(0)); assertNull(defaultChannel.receive(0)); @@ -101,14 +101,14 @@ public class RootCauseErrorMessageRouterTests { RuntimeException middleCause = new RuntimeException(rootCause); MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause); ErrorMessage message = new ErrorMessage(error); - RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter(); + RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver(); Map, MessageChannel> channelMappings = new HashMap, MessageChannel>(); channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel); - router.setChannelMappings(channelMappings); - router.setDefaultChannel(defaultChannel); - router.afterPropertiesSet(); - router.route(message); + resolver.setChannelMappings(channelMappings); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setDefaultOutputChannel(defaultChannel); + endpoint.send(message); assertNotNull(messageHandlingExceptionChannel.receive(1000)); assertNull(runtimeExceptionChannel.receive(0)); assertNull(illegalArgumentChannel.receive(0)); @@ -122,10 +122,10 @@ public class RootCauseErrorMessageRouterTests { RuntimeException middleCause = new RuntimeException(rootCause); MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause); ErrorMessage message = new ErrorMessage(error); - RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter(); - router.setDefaultChannel(defaultChannel); - router.afterPropertiesSet(); - router.route(message); + RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver(); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setDefaultOutputChannel(defaultChannel); + endpoint.send(message); assertNotNull(defaultChannel.receive(1000)); assertNull(runtimeExceptionChannel.receive(0)); assertNull(illegalArgumentChannel.receive(0)); @@ -139,13 +139,12 @@ public class RootCauseErrorMessageRouterTests { RuntimeException middleCause = new RuntimeException(rootCause); MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause); ErrorMessage message = new ErrorMessage(error); - RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter(); + RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver(); Map, MessageChannel> channelMappings = new HashMap, MessageChannel>(); channelMappings.put(MessageDeliveryException.class, messageDeliveryExceptionChannel); - router.setChannelMappings(channelMappings); - router.afterPropertiesSet(); - RouterEndpoint endpoint = new RouterEndpoint(router); + resolver.setChannelMappings(channelMappings); + RouterEndpoint endpoint = new RouterEndpoint(resolver); endpoint.setResolutionRequired(true); endpoint.send(message); } @@ -157,16 +156,16 @@ public class RootCauseErrorMessageRouterTests { RuntimeException middleCause = new RuntimeException(rootCause); MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause); Message message = new GenericMessage(error); - RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter(); + RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver(); Map, MessageChannel> channelMappings = new HashMap, MessageChannel>(); channelMappings.put(IllegalArgumentException.class, illegalArgumentChannel); channelMappings.put(RuntimeException.class, runtimeExceptionChannel); channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel); - router.setChannelMappings(channelMappings); - router.setDefaultChannel(defaultChannel); - router.afterPropertiesSet(); - router.route(message); + resolver.setChannelMappings(channelMappings); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setDefaultOutputChannel(defaultChannel); + endpoint.send(message); assertNotNull(illegalArgumentChannel.receive(1000)); assertNull(defaultChannel.receive(0)); assertNull(runtimeExceptionChannel.receive(0)); @@ -180,15 +179,15 @@ public class RootCauseErrorMessageRouterTests { RuntimeException middleCause = new RuntimeException(rootCause); MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause); ErrorMessage message = new ErrorMessage(error); - RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter(); + RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver(); Map, MessageChannel> channelMappings = new HashMap, MessageChannel>(); channelMappings.put(IllegalArgumentException.class, illegalArgumentChannel); channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel); - router.setChannelMappings(channelMappings); - router.setDefaultChannel(defaultChannel); - router.afterPropertiesSet(); - router.route(message); + resolver.setChannelMappings(channelMappings); + RouterEndpoint endpoint = new RouterEndpoint(resolver); + endpoint.setDefaultOutputChannel(defaultChannel); + endpoint.send(message); assertNotNull(illegalArgumentChannel.receive(1000)); assertNull(defaultChannel.receive(0)); assertNull(runtimeExceptionChannel.receive(0)); diff --git a/org.springframework.integration/src/test/java/org/springframework/integration/router/RouterEndpointTests.java b/org.springframework.integration/src/test/java/org/springframework/integration/router/RouterEndpointTests.java index ead82adfd4..9f81e8bccd 100644 --- a/org.springframework.integration/src/test/java/org/springframework/integration/router/RouterEndpointTests.java +++ b/org.springframework.integration/src/test/java/org/springframework/integration/router/RouterEndpointTests.java @@ -38,30 +38,24 @@ public class RouterEndpointTests { @Test public void nullChannelIgnoredByDefault() { - MultiChannelResolver channelResolver = new MultiChannelResolver() { - public List resolve(Message message) { + ChannelResolver channelResolver = new ChannelResolver() { + public List resolveChannels(Message message) { return null; } }; - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelResolver(channelResolver); - router.afterPropertiesSet(); - RouterEndpoint endpoint = new RouterEndpoint(router); + RouterEndpoint endpoint = new RouterEndpoint(channelResolver); Message message = new StringMessage("test"); assertFalse(endpoint.send(message)); } @Test(expected = MessageDeliveryException.class) public void nullChannelThrowsExceptionWhenResolutionRequired() { - MultiChannelResolver channelResolver = new MultiChannelResolver() { - public List resolve(Message message) { + ChannelResolver channelResolver = new ChannelResolver() { + public List resolveChannels(Message message) { return null; } }; - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelResolver(channelResolver); - router.afterPropertiesSet(); - RouterEndpoint endpoint = new RouterEndpoint(router); + RouterEndpoint endpoint = new RouterEndpoint(channelResolver); endpoint.setResolutionRequired(true); Message message = new StringMessage("test"); endpoint.send(message); @@ -69,30 +63,24 @@ public class RouterEndpointTests { @Test public void emptyChannelListIgnoredByDefault() { - MultiChannelResolver channelResolver = new MultiChannelResolver() { - public List resolve(Message message) { + ChannelResolver channelResolver = new ChannelResolver() { + public List resolveChannels(Message message) { return Collections.emptyList(); } }; - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelResolver(channelResolver); - router.afterPropertiesSet(); - RouterEndpoint endpoint = new RouterEndpoint(router); + RouterEndpoint endpoint = new RouterEndpoint(channelResolver); Message message = new StringMessage("test"); assertFalse(endpoint.send(message)); } @Test(expected = MessageDeliveryException.class) public void emptyChannelListThrowsExceptionWhenResolutionRequired() { - MultiChannelResolver channelResolver = new MultiChannelResolver() { - public List resolve(Message message) { + ChannelResolver channelResolver = new ChannelResolver() { + public List resolveChannels(Message message) { return Collections.emptyList(); } }; - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelResolver(channelResolver); - router.afterPropertiesSet(); - RouterEndpoint endpoint = new RouterEndpoint(router); + RouterEndpoint endpoint = new RouterEndpoint(channelResolver); endpoint.setResolutionRequired(true); Message message = new StringMessage("test"); endpoint.send(message); @@ -100,16 +88,13 @@ public class RouterEndpointTests { @Test public void nullChannelNameArrayIgnoredByDefault() { - MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() { - public String[] resolve(Message message) { + AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() { + public String[] resolveChannelNames(Message message) { return null; } }; ChannelRegistry channelRegistry = new DefaultChannelRegistry(); - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelNameResolver(channelNameResolver); - router.afterPropertiesSet(); - RouterEndpoint endpoint = new RouterEndpoint(router); + RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver); endpoint.setChannelRegistry(channelRegistry); Message message = new StringMessage("test"); assertFalse(endpoint.send(message)); @@ -117,16 +102,13 @@ public class RouterEndpointTests { @Test(expected = MessageDeliveryException.class) public void nullChannelNameArrayThrowsExceptionWhenResolutionRequired() { - MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() { - public String[] resolve(Message message) { + AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() { + public String[] resolveChannelNames(Message message) { return null; } }; ChannelRegistry channelRegistry = new DefaultChannelRegistry(); - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelNameResolver(channelNameResolver); - router.afterPropertiesSet(); - RouterEndpoint endpoint = new RouterEndpoint(router); + RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver); endpoint.setChannelRegistry(channelRegistry); endpoint.setResolutionRequired(true); Message message = new StringMessage("test"); @@ -136,16 +118,13 @@ public class RouterEndpointTests { @Test public void emptyChannelNameArrayIgnoredByDefault() { - MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() { - public String[] resolve(Message message) { + AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() { + public String[] resolveChannelNames(Message message) { return new String[] {}; } }; ChannelRegistry channelRegistry = new DefaultChannelRegistry(); - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelNameResolver(channelNameResolver); - router.afterPropertiesSet(); - RouterEndpoint endpoint = new RouterEndpoint(router); + RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver); endpoint.setChannelRegistry(channelRegistry); Message message = new StringMessage("test"); assertFalse(endpoint.send(message)); @@ -153,16 +132,13 @@ public class RouterEndpointTests { @Test(expected = MessageDeliveryException.class) public void emptyChannelNameArrayThrowsExceptionWhenResolutionRequired() { - MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() { - public String[] resolve(Message message) { + AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() { + public String[] resolveChannelNames(Message message) { return new String[] {}; } }; ChannelRegistry channelRegistry = new DefaultChannelRegistry(); - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelNameResolver(channelNameResolver); - router.afterPropertiesSet(); - RouterEndpoint endpoint = new RouterEndpoint(router); + RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver); endpoint.setChannelRegistry(channelRegistry); endpoint.setResolutionRequired(true); Message message = new StringMessage("test"); @@ -171,28 +147,30 @@ public class RouterEndpointTests { @Test(expected = MessagingException.class) public void testChannelRegistryIsRequiredWhenUsingChannelNameResolverWithSingleChannelRouter() { - ChannelNameResolver channelNameResolver = new ChannelNameResolver() { - public String resolve(Message message) { + AbstractSingleChannelNameResolver channelNameResolver = new AbstractSingleChannelNameResolver() { + public String resolveChannelName(Message message) { return "notImportant"; } }; - SingleChannelRouter router = new SingleChannelRouter(); - router.setChannelNameResolver(channelNameResolver); - RouterEndpoint endpoint = new RouterEndpoint(router); + RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver); endpoint.send(new StringMessage("this should fail")); } @Test(expected = MessagingException.class) public void testChannelRegistryIsRequiredWhenUsingChannelNameResolverWithMultiChannelRouter() { - MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() { - public String[] resolve(Message message) { + AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() { + public String[] resolveChannelNames(Message message) { return new String[] { "notImportant" }; } }; - MultiChannelRouter router = new MultiChannelRouter(); - router.setChannelNameResolver(channelNameResolver); - RouterEndpoint endpoint = new RouterEndpoint(router); + RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver); endpoint.send(new StringMessage("this should fail")); } + @Test(expected = IllegalArgumentException.class) + public void testChannelResolverMustNotBeNull() { + AbstractSingleChannelNameResolver channelNameResolver = null; + new RouterEndpoint(channelNameResolver); + } + } diff --git a/org.springframework.integration/src/test/java/org/springframework/integration/router/SingleChannelRouterTests.java b/org.springframework.integration/src/test/java/org/springframework/integration/router/SingleChannelRouterTests.java index 69be1b8a03..71ba59606d 100644 --- a/org.springframework.integration/src/test/java/org/springframework/integration/router/SingleChannelRouterTests.java +++ b/org.springframework.integration/src/test/java/org/springframework/integration/router/SingleChannelRouterTests.java @@ -22,13 +22,12 @@ import static org.junit.Assert.assertNotNull; import org.junit.Test; -import org.springframework.integration.ConfigurationException; import org.springframework.integration.channel.ChannelRegistry; import org.springframework.integration.channel.DefaultChannelRegistry; import org.springframework.integration.channel.MessageChannel; import org.springframework.integration.channel.QueueChannel; import org.springframework.integration.message.Message; -import org.springframework.integration.message.MessageDeliveryException; +import org.springframework.integration.message.MessagingException; import org.springframework.integration.message.StringMessage; /** @@ -39,16 +38,14 @@ public class SingleChannelRouterTests { @Test public void routeWithChannelResolver() { final QueueChannel channel = new QueueChannel(); - ChannelResolver channelResolver = new ChannelResolver() { - public MessageChannel resolve(Message message) { + AbstractSingleChannelResolver channelResolver = new AbstractSingleChannelResolver() { + public MessageChannel resolveChannel(Message message) { return channel; } }; - SingleChannelRouter router = new SingleChannelRouter(); - router.setChannelResolver(channelResolver); - router.afterPropertiesSet(); + RouterEndpoint endpoint = new RouterEndpoint(channelResolver); Message message = new StringMessage("test"); - router.route(message); + endpoint.send(message); Message result = channel.receive(25); assertNotNull(result); assertEquals("test", result.getPayload()); @@ -56,8 +53,8 @@ public class SingleChannelRouterTests { @Test public void routeWithChannelNameResolver() { - ChannelNameResolver channelNameResolver = new ChannelNameResolver() { - public String resolve(Message message) { + AbstractSingleChannelNameResolver channelNameResolver = new AbstractSingleChannelNameResolver() { + public String resolveChannelName(Message message) { return "testChannel"; } }; @@ -65,71 +62,39 @@ public class SingleChannelRouterTests { channel.setBeanName("testChannel"); ChannelRegistry channelRegistry = new DefaultChannelRegistry(); channelRegistry.registerChannel(channel); - SingleChannelRouter router = new SingleChannelRouter(); - router.setChannelNameResolver(channelNameResolver); - router.setChannelRegistry(channelRegistry); - router.afterPropertiesSet(); + RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver); + endpoint.setChannelRegistry(channelRegistry); Message message = new StringMessage("test"); - router.route(message); + endpoint.send(message); Message result = channel.receive(25); assertNotNull(result); assertEquals("test", result.getPayload()); } - @Test(expected = ConfigurationException.class) - public void configuringBothChannelResolverAndChannelNameResolverIsNotAllowed() { - ChannelResolver channelResolver = new ChannelResolver() { - public MessageChannel resolve(Message message) { - return new QueueChannel(); - } - }; - ChannelNameResolver channelNameResolver = new ChannelNameResolver() { - public String resolve(Message message) { - return ""; - } - }; - SingleChannelRouter router = new SingleChannelRouter(); - router.setChannelResolver(channelResolver); - router.setChannelNameResolver(channelNameResolver); - router.afterPropertiesSet(); - } - @Test public void nullChannelResult() { - ChannelResolver channelResolver = new ChannelResolver() { - public MessageChannel resolve(Message message) { + AbstractSingleChannelResolver channelResolver = new AbstractSingleChannelResolver() { + public MessageChannel resolveChannel(Message message) { return null; } }; - SingleChannelRouter router = new SingleChannelRouter(); - router.setChannelResolver(channelResolver); - router.afterPropertiesSet(); + RouterEndpoint endpoint = new RouterEndpoint(channelResolver); Message message = new StringMessage("test"); - assertFalse(router.route(message)); + assertFalse(endpoint.send(message)); } - @Test(expected = MessageDeliveryException.class) + @Test(expected = MessagingException.class) public void channelNameResolutionFailure() { - ChannelNameResolver channelNameResolver = new ChannelNameResolver() { - public String resolve(Message message) { + AbstractSingleChannelNameResolver channelNameResolver = new AbstractSingleChannelNameResolver() { + public String resolveChannelName(Message message) { return "noSuchChannel"; } }; ChannelRegistry channelRegistry = new DefaultChannelRegistry(); - SingleChannelRouter router = new SingleChannelRouter(); - router.setChannelNameResolver(channelNameResolver); - router.setChannelRegistry(channelRegistry); - router.afterPropertiesSet(); + RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver); + endpoint.setChannelRegistry(channelRegistry); Message message = new StringMessage("test"); - router.route(message); - } - - @Test(expected = ConfigurationException.class) - public void testChannelResolverIsRequired() { - ChannelRegistry channelRegistry = new DefaultChannelRegistry(); - SingleChannelRouter router = new SingleChannelRouter(); - router.setChannelRegistry(channelRegistry); - router.afterPropertiesSet(); + endpoint.send(message); } }