namespaces) {
- super(pathExpression, namespaces);
- }
-
- /**
- * @see AbstractXPathChannelNameResolver#AbstractXPathChannelNameResolver(String,
- * String, String)
- */
- public XPathSingleChannelNameResolver(String pathExpression, String prefix, String namespace) {
- super(pathExpression, prefix, namespace);
- }
-
- /**
- * @see AbstractXPathChannelNameResolver#AbstractXPathChannelNameResolver(String)
- */
- public XPathSingleChannelNameResolver(String pathExpression) {
- super(pathExpression);
- }
-
- /**
- * @see AbstractXPathChannelNameResolver#AbstractXPathChannelNameResolver(XPathExpression)
- */
- public XPathSingleChannelNameResolver(XPathExpression pathExpression) {
- super(pathExpression);
- }
-
- /**
- * Evaluates the payload using {@link XPathExpression#evaluateAsString(Node)}
- * @throws MessagingException if the {@link XPathExpression} evaluates to empty string
- */
- public String[] resolveChannelNames(Message message) {
- Node node = getConverter().convertToNode(message.getPayload());
- String result = getXPathExpresion().evaluateAsString(node);
- if(result.equals("")){
- throw new MessagingException(message,"XPath expression evaluated to empty string");
- }
- return new String[] { result };
- }
-
-}
diff --git a/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/XPathSingleChannelRouter.java b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/XPathSingleChannelRouter.java
new file mode 100644
index 0000000000..752b3e816f
--- /dev/null
+++ b/org.springframework.integration.xml/src/main/java/org/springframework/integration/xml/router/XPathSingleChannelRouter.java
@@ -0,0 +1,88 @@
+/*
+ * 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.xml.router;
+
+import java.util.Map;
+
+import org.w3c.dom.Node;
+
+import org.springframework.integration.message.Message;
+import org.springframework.integration.message.MessagingException;
+import org.springframework.integration.xml.DefaultXmlPayloadConverter;
+import org.springframework.integration.xml.XmlPayloadConverter;
+import org.springframework.xml.xpath.XPathExpression;
+
+/**
+ * Router that evaluates the payload using {@link XPathExpression#evaluateAsString(Node)}
+ * to extract a channel name. The payload is extracted as a node using the
+ * provided {@link XmlPayloadConverter} with {@link DefaultXmlPayloadConverter}
+ * being the default.
+ *
+ * The provided {@link XPathExpression} must evaluate to a non-empty String.
+ *
+ * @author Jonas Partner
+ */
+public class XPathSingleChannelRouter extends AbstractXPathRouter {
+
+ /**
+ * @see AbstractXPathRouter#AbstractXPathChannelNameResolver(String, Map)
+ */
+ public XPathSingleChannelRouter(String expression, Map namespaces) {
+ super(expression, namespaces);
+ }
+
+ /**
+ * @see AbstractXPathRouter#AbstractXPathChannelNameResolver(String, String, String)
+ */
+ public XPathSingleChannelRouter(String expression, String prefix, String namespace) {
+ super(expression, prefix, namespace);
+ }
+
+ /**
+ * @see AbstractXPathRouter#AbstractXPathChannelNameResolver(String)
+ */
+ public XPathSingleChannelRouter(String expression) {
+ super(expression);
+ }
+
+ /**
+ * @see AbstractXPathRouter#AbstractXPathChannelNameResolver(XPathExpression)
+ */
+ public XPathSingleChannelRouter(XPathExpression expression) {
+ super(expression);
+ }
+
+
+ /**
+ * Evaluates the payload using {@link XPathExpression#evaluateAsString(Node)}
+ *
+ * @throws MessagingException if the {@link XPathExpression} evaluates to
+ * an empty string
+ */
+ public String[] resolveChannelNames(Message message) {
+ Node node = getConverter().convertToNode(message.getPayload());
+ String result = getXPathExpression().evaluateAsString(node);
+ if ("".equals(result)) {
+ throw new MessagingException(message,"XPath expression must not be empty");
+ }
+ if (result == null) {
+ return null;
+ }
+ return new String[] { result };
+ }
+
+}
diff --git a/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/config/XPathRouterParserTests.java b/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/config/XPathRouterParserTests.java
index 9fe8512baa..0bdb923e4d 100644
--- a/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/config/XPathRouterParserTests.java
+++ b/org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/config/XPathRouterParserTests.java
@@ -19,11 +19,12 @@ package org.springframework.integration.xml.config;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
+import org.w3c.dom.Document;
+
import org.springframework.integration.message.GenericMessage;
-import org.springframework.integration.xml.router.XPathSingleChannelNameResolver;
+import org.springframework.integration.xml.router.XPathSingleChannelRouter;
import org.springframework.integration.xml.util.XmlTestUtil;
import org.springframework.test.context.ContextConfiguration;
-import org.w3c.dom.Document;
/**
* @author Jonas Partner
@@ -35,25 +36,21 @@ public class XPathRouterParserTests {
public void testSimpleStringExpression() throws Exception {
Document doc = XmlTestUtil.getDocumentForString("outputOne");
GenericMessage docMessage = new GenericMessage(doc);
-
- TestXmlApplicationContext ctx = TestXmlApplicationContextHelper.getTestAppContext("");
- XPathSingleChannelNameResolver router = (XPathSingleChannelNameResolver) ctx.getBean("router");
-
+ TestXmlApplicationContext ctx = TestXmlApplicationContextHelper.getTestAppContext(
+ "");
+ XPathSingleChannelRouter router = (XPathSingleChannelRouter) ctx.getBean("router");
String[] channelNames = router.resolveChannelNames(docMessage);
assertEquals("Wrong number of channel names returned", 1, channelNames.length);
assertEquals("Wrong channel name", "outputOne", channelNames[0]);
-
}
@Test
public void testNamespacedStringExpression() throws Exception {
Document doc = XmlTestUtil.getDocumentForString("outputOne");
GenericMessage docMessage = new GenericMessage(doc);
-
- TestXmlApplicationContext ctx =
- TestXmlApplicationContextHelper.getTestAppContext("");
- XPathSingleChannelNameResolver router = (XPathSingleChannelNameResolver) ctx.getBean("router");
-
+ TestXmlApplicationContext ctx = TestXmlApplicationContextHelper.getTestAppContext(
+ "");
+ XPathSingleChannelRouter router = (XPathSingleChannelRouter) ctx.getBean("router");
String[] channelNames = router.resolveChannelNames(docMessage);
assertEquals("Wrong number of channel names returned", 1, channelNames.length);
assertEquals("Wrong channel name", "outputOne", channelNames[0]);
@@ -61,19 +58,15 @@ public class XPathRouterParserTests {
@Test
public void testStringExpressionWithNestedNamespaceMap() throws Exception {
- Document doc = XmlTestUtil
- .getDocumentForString("outputOne");
+ Document doc = XmlTestUtil.getDocumentForString(
+ "outputOne");
GenericMessage docMessage = new GenericMessage(doc);
-
StringBuffer buffer = new StringBuffer(
" ");
- buffer
- .append("");
+ buffer.append("");
buffer.append("");
-
TestXmlApplicationContext ctx = TestXmlApplicationContextHelper.getTestAppContext(buffer.toString());
- XPathSingleChannelNameResolver router = (XPathSingleChannelNameResolver) ctx.getBean("router");
-
+ XPathSingleChannelRouter router = (XPathSingleChannelRouter) ctx.getBean("router");
String[] channelNames = router.resolveChannelNames(docMessage);
assertEquals("Wrong number of channel names returned", 1, channelNames.length);
assertEquals("Wrong channel name", "outputOne", channelNames[0]);
@@ -81,24 +74,18 @@ public class XPathRouterParserTests {
@Test
public void testStringExpressionWithReferenceToNamespaceMap() throws Exception {
- Document doc = XmlTestUtil
- .getDocumentForString("outputOne");
+ Document doc = XmlTestUtil.getDocumentForString(
+ "outputOne");
GenericMessage docMessage = new GenericMessage(doc);
StringBuffer buffer = new StringBuffer(
"");
- buffer
- .append("")
- .append("");
-
+ buffer.append("");
+ buffer.append("");
TestXmlApplicationContext ctx = TestXmlApplicationContextHelper.getTestAppContext(buffer.toString());
- XPathSingleChannelNameResolver router = (XPathSingleChannelNameResolver) ctx.getBean("router");
-
+ XPathSingleChannelRouter router = (XPathSingleChannelRouter) ctx.getBean("router");
String[] channelNames = router.resolveChannelNames(docMessage);
assertEquals("Wrong number of channel names returned", 1, channelNames.length);
assertEquals("Wrong channel name", "outputOne", channelNames[0]);
}
-
-
-
}
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/XPathMultiChannelRouterTests.java
similarity index 69%
rename from org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathMultiChannelNameResolverTests.java
rename to org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathMultiChannelRouterTests.java
index e4531a6c25..554a832a87 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/XPathMultiChannelRouterTests.java
@@ -19,28 +19,29 @@ package org.springframework.integration.xml.router;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
import org.springframework.integration.message.GenericMessage;
import org.springframework.integration.message.MessagingException;
import org.springframework.integration.message.StringMessage;
import org.springframework.integration.xml.util.XmlTestUtil;
import org.springframework.xml.xpath.XPathExpression;
import org.springframework.xml.xpath.XPathExpressionFactory;
-import org.w3c.dom.Document;
-import org.w3c.dom.Node;
/**
* @author Jonas Partner
*/
-public class XPathMultiChannelNameResolverTests {
+public class XPathMultiChannelRouterTests {
@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.resolveChannelNames(new GenericMessage(doc));
- assertEquals("Wrong number of channels returend", 1, channelNames.length);
+ XPathMultiChannelRouter router = new XPathMultiChannelRouter(expression);
+ String[] channelNames = router.resolveChannelNames(new GenericMessage(doc));
+ assertEquals("Wrong number of channels returned", 1, channelNames.length);
assertEquals("Wrong channel name", "one", channelNames[0]);
}
@@ -49,20 +50,20 @@ public class XPathMultiChannelNameResolverTests {
public void testMultipleNodeValues() throws Exception {
Document doc = XmlTestUtil.getDocumentForString("bOnebTwo");
XPathExpression expression = XPathExpressionFactory.createXPathExpression("/doc/book");
- XPathMultiChannelNameResolver resolver = new XPathMultiChannelNameResolver(expression);
- String[] channelNames = resolver.resolveChannelNames(new GenericMessage(doc));
- assertEquals("Wrong number of channels returend", 2, channelNames.length);
+ XPathMultiChannelRouter router = new XPathMultiChannelRouter(expression);
+ String[] channelNames = router.resolveChannelNames(new GenericMessage(doc));
+ assertEquals("Wrong number of channels returned", 2, channelNames.length);
assertEquals("Wrong channel name", "bOne", channelNames[0]);
assertEquals("Wrong channel name", "bTwo", channelNames[1]);
}
-
+
@Test
@SuppressWarnings("unchecked")
public void testMultipleNodeValuesAsString() throws Exception {
XPathExpression expression = XPathExpressionFactory.createXPathExpression("/doc/book");
- XPathMultiChannelNameResolver resolver = new XPathMultiChannelNameResolver(expression);
- String[] channelNames = resolver.resolveChannelNames(new GenericMessage("bOnebTwo"));
- assertEquals("Wrong number of channels returend", 2, channelNames.length);
+ XPathMultiChannelRouter router = new XPathMultiChannelRouter(expression);
+ String[] channelNames = router.resolveChannelNames(new GenericMessage("bOnebTwo"));
+ assertEquals("Wrong number of channels returned", 2, channelNames.length);
assertEquals("Wrong channel name", "bOne", channelNames[0]);
assertEquals("Wrong channel name", "bTwo", channelNames[1]);
}
@@ -70,17 +71,17 @@ public class XPathMultiChannelNameResolverTests {
@Test(expected = MessagingException.class)
public void testNonNodePayload() throws Exception {
XPathExpression expression = XPathExpressionFactory.createXPathExpression("/doc/@type");
- XPathMultiChannelNameResolver resolver = new XPathMultiChannelNameResolver(expression);
- resolver.resolveChannelNames(new StringMessage("test"));
+ XPathMultiChannelRouter router = new XPathMultiChannelRouter(expression);
+ router.resolveChannelNames(new StringMessage("test"));
}
@Test
public void testNodePayload() throws Exception {
- XPathMultiChannelNameResolver resolver = new XPathMultiChannelNameResolver("./three/text()");
+ XPathMultiChannelRouter router = new XPathMultiChannelRouter("./three/text()");
Document testDocument = XmlTestUtil.getDocumentForString("bobdave");
- String[] channelNames = resolver.resolveChannelNames(new GenericMessage(testDocument.getElementsByTagName("two").item(0)));
+ String[] channelNames = router.resolveChannelNames(new GenericMessage(testDocument.getElementsByTagName("two").item(0)));
assertEquals("bob",channelNames[0]);
assertEquals("dave",channelNames[1]);
}
-
+
}
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/XPathSingleChannelRouterTests.java
similarity index 70%
rename from org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathSingleChannelNameResolverTests.java
rename to org.springframework.integration.xml/src/test/java/org/springframework/integration/xml/router/XPathSingleChannelRouterTests.java
index e7e10d6d55..95f4667c72 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/XPathSingleChannelRouterTests.java
@@ -19,58 +19,59 @@ package org.springframework.integration.xml.router;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
import org.springframework.integration.message.GenericMessage;
import org.springframework.integration.message.MessagingException;
import org.springframework.integration.message.StringMessage;
import org.springframework.integration.xml.util.XmlTestUtil;
import org.springframework.xml.xpath.XPathExpression;
import org.springframework.xml.xpath.XPathExpressionFactory;
-import org.w3c.dom.Document;
-import org.w3c.dom.Node;
/**
* @author Jonas Partner
*/
-public class XPathSingleChannelNameResolverTests {
+public class XPathSingleChannelRouterTests {
@Test
public void testSimpleDocType() throws Exception {
Document doc = XmlTestUtil.getDocumentForString("");
XPathExpression expression = XPathExpressionFactory.createXPathExpression("/doc/@type");
- XPathSingleChannelNameResolver resolver = new XPathSingleChannelNameResolver(expression);
- String channelName = resolver.resolveChannelNames(new GenericMessage(doc))[0];
+ XPathSingleChannelRouter router = new XPathSingleChannelRouter(expression);
+ String channelName = router.resolveChannelNames(new GenericMessage(doc))[0];
assertEquals("Wrong channel name", "one", channelName);
}
@Test
public void testSimpleStringDoc() throws Exception {
XPathExpression expression = XPathExpressionFactory.createXPathExpression("/doc/@type");
- XPathSingleChannelNameResolver resolver = new XPathSingleChannelNameResolver(expression);
- String channelName = resolver.resolveChannelNames(new GenericMessage(""))[0];
+ XPathSingleChannelRouter router = new XPathSingleChannelRouter(expression);
+ String channelName = router.resolveChannelNames(new GenericMessage(""))[0];
assertEquals("Wrong channel name", "one", channelName);
}
@Test(expected = MessagingException.class)
public void testNonNodePayload() throws Exception {
XPathExpression expression = XPathExpressionFactory.createXPathExpression("/doc/@type");
- XPathSingleChannelNameResolver resolver = new XPathSingleChannelNameResolver(expression);
- resolver.resolveChannelNames(new StringMessage("test"));
+ XPathSingleChannelRouter router = new XPathSingleChannelRouter(expression);
+ router.resolveChannelNames(new StringMessage("test"));
}
@Test
public void testNodePayload() throws Exception {
- XPathSingleChannelNameResolver resolver = new XPathSingleChannelNameResolver("./three/text()");
+ XPathSingleChannelRouter router = new XPathSingleChannelRouter("./three/text()");
Document testDocument = XmlTestUtil.getDocumentForString("bob");
- String[] channelNames = resolver.resolveChannelNames(new GenericMessage(testDocument
- .getElementsByTagName("two").item(0)));
+ String[] channelNames = router.resolveChannelNames(new GenericMessage(
+ testDocument.getElementsByTagName("two").item(0)));
assertEquals("bob", channelNames[0]);
}
-
+
@Test(expected=MessagingException.class)
public void testEvaluationReturnsEmptyString() throws Exception {
- XPathSingleChannelNameResolver resolver = new XPathSingleChannelNameResolver("/yellow");
+ XPathSingleChannelRouter router = new XPathSingleChannelRouter("/yellow");
Document testDocument = XmlTestUtil.getDocumentForString("bob");
- resolver.resolveChannelNames(new GenericMessage(testDocument));
-
+ router.resolveChannelNames(new GenericMessage(testDocument));
}
+
}
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 15b0a76123..c3fb700171 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
@@ -22,8 +22,7 @@ import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.integration.annotation.Router;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.message.MessageConsumer;
-import org.springframework.integration.router.MethodInvokingChannelResolver;
-import org.springframework.integration.router.RouterEndpoint;
+import org.springframework.integration.router.MethodInvokingRouter;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
@@ -41,8 +40,7 @@ public class RouterAnnotationPostProcessor extends AbstractMethodAnnotationPostP
@Override
protected MessageConsumer createConsumer(Object bean, Method method, Router annotation) {
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(bean, method);
- RouterEndpoint router = new RouterEndpoint(resolver);
+ MethodInvokingRouter router = new MethodInvokingRouter(bean, method);
String defaultOutputChannelName = annotation.defaultOutputChannel();
if (StringUtils.hasText(defaultOutputChannelName)) {
MessageChannel defaultOutputChannel = this.channelRegistry.lookupChannel(defaultOutputChannelName);
diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/config/xml/RouterParser.java b/org.springframework.integration/src/main/java/org/springframework/integration/config/xml/RouterParser.java
index cd7a39aee1..435f052832 100644
--- a/org.springframework.integration/src/main/java/org/springframework/integration/config/xml/RouterParser.java
+++ b/org.springframework.integration/src/main/java/org/springframework/integration/config/xml/RouterParser.java
@@ -19,9 +19,12 @@ package org.springframework.integration.config.xml;
import org.w3c.dom.Element;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
import org.springframework.beans.factory.xml.ParserContext;
-import org.springframework.integration.router.MethodInvokingChannelResolver;
-import org.springframework.integration.router.RouterEndpoint;
+import org.springframework.integration.router.BeanNameChannelMapping;
+import org.springframework.integration.router.MethodInvokingRouter;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
/**
* Parser for the <router/> element.
@@ -32,10 +35,19 @@ public class RouterParser extends AbstractConsumerEndpointParser {
@Override
protected BeanDefinitionBuilder parseConsumer(Element element, ParserContext parserContext) {
- String adapterBeanName = this.parseAdapter(element, parserContext, MethodInvokingChannelResolver.class);
- BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(RouterEndpoint.class);
- builder.addConstructorArgReference(adapterBeanName);
- builder.addPropertyReference("channelRegistry", MessageBusParser.MESSAGE_BUS_BEAN_NAME);
+ String ref = element.getAttribute(REF_ATTRIBUTE);
+ Assert.hasText(ref, "The '" + REF_ATTRIBUTE + "' attribute is required.");
+ BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MethodInvokingRouter.class);
+ builder.addConstructorArgReference(ref);
+ if (StringUtils.hasText(element.getAttribute(METHOD_ATTRIBUTE))) {
+ String method = element.getAttribute(METHOD_ATTRIBUTE);
+ builder.addConstructorArgValue(method);
+ }
+ BeanDefinitionBuilder channelMappingBuilder =
+ BeanDefinitionBuilder.genericBeanDefinition(BeanNameChannelMapping.class);
+ String channelMappingBeanName = BeanDefinitionReaderUtils.registerWithGeneratedName(
+ channelMappingBuilder.getBeanDefinition(), parserContext.getRegistry());
+ builder.addPropertyReference("channelMapping", channelMappingBeanName);
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "default-output-channel");
return builder;
}
diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractChannelMappingMessageRouter.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractChannelMappingMessageRouter.java
new file mode 100644
index 0000000000..75a97e8927
--- /dev/null
+++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractChannelMappingMessageRouter.java
@@ -0,0 +1,104 @@
+/*
+ * 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 org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.integration.channel.MessageChannel;
+import org.springframework.integration.message.Message;
+import org.springframework.integration.message.MessagingException;
+import org.springframework.util.Assert;
+
+/**
+ * A base class for router implementations that return only
+ * the channel name(s) rather than {@link MessageChannel} instances.
+ *
+ * @author Mark Fisher
+ */
+public abstract class AbstractChannelMappingMessageRouter extends AbstractMessageRouter implements BeanFactoryAware, InitializingBean {
+
+ private volatile ChannelMapping channelMapping;
+
+ private volatile String prefix;
+
+ private volatile String suffix;
+
+ private volatile BeanFactory beanFactory;
+
+
+ public void setChannelMapping(ChannelMapping channelMapping) {
+ this.channelMapping = channelMapping;
+ }
+
+ public void setPrefix(String prefix) {
+ this.prefix = prefix;
+ }
+
+ public void setSuffix(String suffix) {
+ this.suffix = suffix;
+ }
+
+ public void setBeanFactory(BeanFactory beanFactory) {
+ this.beanFactory = beanFactory;
+ }
+
+ public void afterPropertiesSet() {
+ if (this.channelMapping == null) {
+ Assert.notNull(beanFactory, "either a ChannelMapping or BeanFactory is required");
+ this.channelMapping = new BeanNameChannelMapping(this.beanFactory);
+ }
+ }
+
+ @Override
+ protected final Collection resolveChannels(Message message) {
+ this.afterPropertiesSet();
+ Collection channels = new ArrayList();
+ String[] channelNames = this.resolveChannelNames(message);
+ if (channelNames == null) {
+ return null;
+ }
+ for (String channelName : channelNames) {
+ if (channelName != null) {
+ Assert.state(this.channelMapping != null,
+ "unable to resolve channels, no ChannelMapping available");
+ if (this.prefix != null) {
+ channelName = this.prefix + channelName;
+ }
+ if (this.suffix != null) {
+ channelName = channelName + suffix;
+ }
+ MessageChannel channel = this.channelMapping.getChannel(channelName);
+ if (channel == null) {
+ throw new MessagingException(message,
+ "unable to resolve channel '" + channelName + "'");
+ }
+ channels.add(channel);
+ }
+ }
+ return channels;
+ }
+
+ /**
+ * Subclasses must implement this method to return the channel name(s).
+ */
+ protected abstract String[] resolveChannelNames(Message message);
+
+}
diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractChannelNameResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractChannelNameResolver.java
deleted file mode 100644
index 7576b5960e..0000000000
--- a/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractChannelNameResolver.java
+++ /dev/null
@@ -1,70 +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.ArrayList;
-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.message.Message;
-import org.springframework.integration.message.MessagingException;
-import org.springframework.util.Assert;
-
-/**
- * A base class for {@link ChannelResolver} implementations that return only
- * the channel name(s) rather than {@link MessageChannel} instances.
- *
- * @author Mark Fisher
- */
-public abstract class AbstractChannelNameResolver implements ChannelResolver, ChannelRegistryAware {
-
- private ChannelRegistry channelRegistry;
-
-
- public void setChannelRegistry(ChannelRegistry channelRegistry) {
- this.channelRegistry = channelRegistry;
- }
-
- public final Collection resolveChannels(Message message) {
- Collection channels = new ArrayList();
- String[] channelNames = this.resolveChannelNames(message);
- if (channelNames == null) {
- return null;
- }
- for (String channelName : channelNames) {
- if (channelName != null) {
- Assert.state(this.channelRegistry != null,
- "unable to resolve channels, no ChannelRegistry available");
- MessageChannel channel = this.channelRegistry.lookupChannel(channelName);
- if (channel == null) {
- throw new MessagingException(message,
- "unable to resolve chnanel '" + channelName + "'");
- }
- channels.add(channel);
- }
- }
- return channels;
- }
-
- /**
- * Subclasses must implement this method to return the channel name(s).
- */
- protected abstract String[] resolveChannelNames(Message message);
-
-}
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/AbstractMessageRouter.java
similarity index 76%
rename from org.springframework.integration/src/main/java/org/springframework/integration/router/RouterEndpoint.java
rename to org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractMessageRouter.java
index 0543bdb6e9..f20d1e89a9 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/AbstractMessageRouter.java
@@ -18,21 +18,18 @@ 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.channel.MessageChannelTemplate;
import org.springframework.integration.endpoint.AbstractMessageConsumer;
import org.springframework.integration.message.Message;
import org.springframework.integration.message.MessageDeliveryException;
-import org.springframework.util.Assert;
/**
+ * Base class for Message Routers.
+ *
* @author Mark Fisher
*/
-public class RouterEndpoint extends AbstractMessageConsumer implements ChannelRegistryAware {
-
- private final ChannelResolver channelResolver;
+public abstract class AbstractMessageRouter extends AbstractMessageConsumer {
private volatile MessageChannel defaultOutputChannel;
@@ -41,18 +38,12 @@ public class RouterEndpoint extends AbstractMessageConsumer implements ChannelRe
private final MessageChannelTemplate channelTemplate = new MessageChannelTemplate();
- public RouterEndpoint(ChannelResolver channelResolver) {
- Assert.notNull(channelResolver, "ChannelResolver must not be null");
- this.channelResolver = channelResolver;
- }
-
-
- public void setChannelRegistry(ChannelRegistry channelRegistry) {
- if (this.channelResolver instanceof ChannelRegistryAware) {
- ((ChannelRegistryAware) this.channelResolver).setChannelRegistry(channelRegistry);
- }
- }
-
+ /**
+ * Set the default channel where Messages should be sent if channel
+ * resolution fails to return any channels. If no default channel is
+ * provided, the router will either drop the Message or throw an Exception
+ * depending on the value of {@link #resolutionRequired}.
+ */
public void setDefaultOutputChannel(MessageChannel defaultOutputChannel) {
this.defaultOutputChannel = defaultOutputChannel;
}
@@ -78,7 +69,7 @@ public class RouterEndpoint extends AbstractMessageConsumer implements ChannelRe
@Override
protected void onMessageInternal(Message message) {
boolean sent = false;
- Collection results = this.channelResolver.resolveChannels(message);
+ Collection results = this.resolveChannels(message);
if (results != null) {
for (MessageChannel channel : results) {
if (channel != null) {
@@ -99,4 +90,10 @@ public class RouterEndpoint extends AbstractMessageConsumer implements ChannelRe
}
}
+ /**
+ * Subclasses must implement this method to return the target channels for
+ * a given Message.
+ */
+ protected abstract Collection resolveChannels(Message message);
+
}
diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelNameResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelNameRouter.java
similarity index 84%
rename from org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelNameResolver.java
rename to org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelNameRouter.java
index b4b5e68d40..7ffe83f53d 100644
--- a/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelNameResolver.java
+++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelNameRouter.java
@@ -21,9 +21,10 @@ import org.springframework.integration.message.Message;
/**
* @author Mark Fisher
*/
-public abstract class AbstractSingleChannelNameResolver extends AbstractChannelNameResolver {
+public abstract class AbstractSingleChannelNameRouter extends AbstractChannelMappingMessageRouter {
- public final String[] resolveChannelNames(Message message) {
+ @Override
+ protected final String[] resolveChannelNames(Message message) {
String channelName = this.resolveChannelName(message);
return (channelName != null) ? new String[] { channelName } : null;
}
diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelRouter.java
similarity index 80%
rename from org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelResolver.java
rename to org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelRouter.java
index d9dd2587f2..2c157b1bfa 100644
--- a/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelResolver.java
+++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelRouter.java
@@ -25,12 +25,12 @@ import org.springframework.integration.message.Message;
/**
* @author Mark Fisher
*/
-public abstract class AbstractSingleChannelResolver implements ChannelResolver {
+public abstract class AbstractSingleChannelRouter extends AbstractMessageRouter {
- public Collection resolveChannels(Message message) {
+ @Override
+ protected final Collection resolveChannels(Message message) {
MessageChannel channel = this.resolveChannel(message);
- return (channel != null) ?
- Collections.singletonList(channel) : null;
+ 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/BeanNameChannelMapping.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/BeanNameChannelMapping.java
new file mode 100644
index 0000000000..3b1daa57eb
--- /dev/null
+++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/BeanNameChannelMapping.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2002-2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.router;
+
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.integration.channel.MessageChannel;
+import org.springframework.util.Assert;
+
+/**
+ * An implementation of the ChannelMapping strategy that retrieves a
+ * MessageChannel instance from the {@link BeanFactory} using the provided
+ * name.
+ *
+ * @author Mark Fisher
+ */
+public class BeanNameChannelMapping implements ChannelMapping, BeanFactoryAware {
+
+ private volatile BeanFactory beanFactory;
+
+
+ /**
+ * Constructor for use within a context where the BeanFactory will be
+ * injected via the {@link #setBeanFactory(BeanFactory)} callback method.
+ */
+ public BeanNameChannelMapping() {
+ }
+
+ /**
+ * Constructor for programmatic creation from within other components that
+ * already have access to the {@link BeanFactory}.
+ */
+ public BeanNameChannelMapping(BeanFactory beanFactory) {
+ this.beanFactory = beanFactory;
+ }
+
+
+ public void setBeanFactory(BeanFactory beanFactory) {
+ this.beanFactory = beanFactory;
+ }
+
+ public MessageChannel getChannel(String name) {
+ Assert.state(this.beanFactory != null, "beanFactory must not be null");
+ return (MessageChannel) this.beanFactory.getBean(name, MessageChannel.class);
+ }
+
+}
diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/ChannelMapping.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/ChannelMapping.java
new file mode 100644
index 0000000000..245cabce41
--- /dev/null
+++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/ChannelMapping.java
@@ -0,0 +1,30 @@
+/*
+ * 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.channel.MessageChannel;
+
+/**
+ * Strategy for mapping from a name to a {@link MessageChannel}.
+ *
+ * @author Mark Fisher
+ */
+public interface ChannelMapping {
+
+ MessageChannel getChannel(String name);
+
+}
diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingChannelResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingRouter.java
similarity index 72%
rename from org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingChannelResolver.java
rename to org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingRouter.java
index e876fa2e79..dbdd768ac0 100644
--- a/org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingChannelResolver.java
+++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingRouter.java
@@ -23,8 +23,6 @@ import java.util.Collection;
import java.util.List;
import org.springframework.beans.factory.InitializingBean;
-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.MessageMappingMethodInvoker;
@@ -32,38 +30,44 @@ import org.springframework.integration.message.MessagingException;
import org.springframework.util.Assert;
/**
- * 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.
+ * A Message Router 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. If the method returns channel names, then a
+ * {@link ChannelMapping} is required.
*
* @author Mark Fisher
*/
-public class MethodInvokingChannelResolver implements ChannelResolver, ChannelRegistryAware, InitializingBean {
+public class MethodInvokingRouter extends AbstractMessageRouter implements InitializingBean {
private final MessageMappingMethodInvoker invoker;
- private volatile ChannelRegistry channelRegistry;
+ private volatile ChannelMapping channelMapping;
- public MethodInvokingChannelResolver(Object object, Method method) {
+ public MethodInvokingRouter(Object object, Method method) {
this.invoker = new MessageMappingMethodInvoker(object, method);
}
- public MethodInvokingChannelResolver(Object object, String methodName) {
+ public MethodInvokingRouter(Object object, String methodName) {
this.invoker = new MessageMappingMethodInvoker(object, methodName);
}
- public void setChannelRegistry(ChannelRegistry channelRegistry) {
- this.channelRegistry = channelRegistry;
+ /**
+ * Provide the ChannelMapping strategy to use for methods that return a
+ * channel name rather than a {@link MessageChannel} instance.
+ */
+ public void setChannelMapping(ChannelMapping channelMapping) {
+ this.channelMapping = channelMapping;
}
public void afterPropertiesSet() throws Exception {
this.invoker.afterPropertiesSet();
}
- public final Collection resolveChannels(Message message) {
+ @Override
+ protected final Collection resolveChannels(Message message) {
Object result = this.invoker.invokeMethod(message);
if (result == null) {
return null;
@@ -104,9 +108,9 @@ public class MethodInvokingChannelResolver implements ChannelResolver, ChannelRe
}
else if (channelOrName instanceof String) {
String channelName = (String) channelOrName;
- Assert.state(this.channelRegistry != null,
- "ChannelRegistry is required for resolving channel names");
- MessageChannel channel = this.channelRegistry.lookupChannel(channelName);
+ Assert.state(this.channelMapping != null,
+ "ChannelMapping is required for resolving channel names");
+ MessageChannel channel = this.channelMapping.getChannel(channelName);
if (channel == null) {
throw new MessagingException("unable to resolve channel '" + channelName + "'");
}
diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeChannelResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeRouter.java
similarity index 62%
rename from org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeChannelResolver.java
rename to org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeRouter.java
index d3a245ca5c..2ffbabfba2 100644
--- a/org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeChannelResolver.java
+++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeRouter.java
@@ -24,24 +24,25 @@ import org.springframework.integration.message.Message;
import org.springframework.util.Assert;
/**
- * A ChannelResolver implementation that resolves the {@link MessageChannel} based
- * on the {@link Message Message's} payload type.
+ * A Message Router that resolves the {@link MessageChannel} based on the
+ * {@link Message Message's} payload type.
*
* @author Mark Fisher
*/
-public class PayloadTypeChannelResolver extends AbstractSingleChannelResolver {
+public class PayloadTypeRouter extends AbstractSingleChannelRouter {
- private Map, MessageChannel> channelMappings = new ConcurrentHashMap, MessageChannel>();
+ private volatile Map, MessageChannel> payloadTypeChannelMap =
+ new ConcurrentHashMap, MessageChannel>();
- public void setChannelMappings(Map, MessageChannel> channelMappings) {
- Assert.notNull(channelMappings, "'channelMappings' must not be null");
- this.channelMappings = channelMappings;
+ public void setPayloadTypeChannelMap(Map, MessageChannel> payloadTypeChannelMap) {
+ Assert.notNull(payloadTypeChannelMap, "payloadTypeChannelMap must not be null");
+ this.payloadTypeChannelMap = payloadTypeChannelMap;
}
@Override
protected MessageChannel resolveChannel(Message message) {
- return this.channelMappings.get(message.getPayload().getClass());
+ return this.payloadTypeChannelMap.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/RecipientListRouter.java
similarity index 68%
rename from org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListChannelResolver.java
rename to org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListRouter.java
index c992befc15..22a0064a0d 100644
--- a/org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListChannelResolver.java
+++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListRouter.java
@@ -25,21 +25,19 @@ import org.springframework.integration.message.Message;
import org.springframework.util.Assert;
/**
- * A {@link ChannelResolver} implementation that routes to a statically
- * configured list of recipients. The recipients are provided as a list of
- * {@link MessageChannel} instances. For dynamic recipient lists, consider
- * either implementing the {@link ChannelResolver} interface directly or
- * extending the {@link AbstractChannelNameResolver} base class.
+ * A Message Router that sends Messages to a statically configured list of
+ * recipients. The recipients are provided as a list of {@link MessageChannel}
+ * instances. For dynamic recipient lists, consider instead using the @Router
+ * annotation or extending {@link AbstractChannelMappingMessageRouter}.
*
* @author Mark Fisher
*/
-public class RecipientListChannelResolver implements ChannelResolver, InitializingBean {
+public class RecipientListRouter extends AbstractMessageRouter implements InitializingBean {
private volatile List channels;
public void setChannels(List channels) {
- Assert.notEmpty(channels, "a non-empty channel list is required");
this.channels = channels;
}
@@ -47,7 +45,8 @@ public class RecipientListChannelResolver implements ChannelResolver, Initializi
Assert.notEmpty(this.channels, "a non-empty channel list is required");
}
- public Collection resolveChannels(Message message) {
+ @Override
+ protected Collection resolveChannels(Message message) {
return this.channels;
}
diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageChannelResolver.java b/org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageRouter.java
similarity index 68%
rename from org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageChannelResolver.java
rename to org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageRouter.java
index 45eb597bbf..960c9cc00c 100644
--- a/org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageChannelResolver.java
+++ b/org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageRouter.java
@@ -24,21 +24,21 @@ import org.springframework.integration.message.Message;
import org.springframework.util.Assert;
/**
- * 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.
+ * A Message Router that resolves the target {@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 RootCauseErrorMessageChannelResolver extends AbstractSingleChannelResolver {
+public class RootCauseErrorMessageRouter extends AbstractSingleChannelRouter {
- private Map, MessageChannel> channelMappings =
+ private volatile Map, MessageChannel> exceptionTypeChannelMap =
new ConcurrentHashMap, MessageChannel>();
- public void setChannelMappings(Map, MessageChannel> channelMappings) {
- Assert.notNull(channelMappings, "'channelMappings' must not be null");
- this.channelMappings = channelMappings;
+ public void setExceptionTypeChannelMap(Map, MessageChannel> exceptionTypeChannelMap) {
+ Assert.notNull(exceptionTypeChannelMap, "exceptionTypeChannelMap must not be null");
+ this.exceptionTypeChannelMap = exceptionTypeChannelMap;
}
@@ -49,7 +49,7 @@ public class RootCauseErrorMessageChannelResolver extends AbstractSingleChannelR
if (payload != null && (payload instanceof Throwable)) {
Throwable mostSpecificCause = (Throwable) payload;
while (mostSpecificCause != null) {
- MessageChannel mappedChannel = this.channelMappings.get(mostSpecificCause.getClass());
+ MessageChannel mappedChannel = this.exceptionTypeChannelMap.get(mostSpecificCause.getClass());
if (mappedChannel != null) {
channel = mappedChannel;
}
diff --git a/org.springframework.integration/src/test/java/org/springframework/integration/aop/PublisherAnnotationAdvisorTests.java b/org.springframework.integration/src/test/java/org/springframework/integration/aop/PublisherAnnotationAdvisorTests.java
index 2c0e03f390..46359dbdfe 100644
--- a/org.springframework.integration/src/test/java/org/springframework/integration/aop/PublisherAnnotationAdvisorTests.java
+++ b/org.springframework.integration/src/test/java/org/springframework/integration/aop/PublisherAnnotationAdvisorTests.java
@@ -21,12 +21,15 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
+import java.util.HashMap;
+import java.util.Map;
+
import org.junit.Test;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.integration.channel.ChannelRegistry;
+import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.QueueChannel;
-import org.springframework.integration.channel.TestChannelRegistry;
import org.springframework.integration.message.Message;
/**
@@ -169,7 +172,20 @@ public class PublisherAnnotationAdvisorTests {
public Integer publishReturnValue() {
return 123;
}
+ }
+
+ private static class TestChannelRegistry implements ChannelRegistry {
+
+ private final Map channels = new HashMap();
+
+ public MessageChannel lookupChannel(String channelName) {
+ return this.channels.get(channelName);
+ }
+
+ public void registerChannel(MessageChannel channel) {
+ this.channels.put(channel.getName(), channel);
+ }
}
}
diff --git a/org.springframework.integration/src/test/java/org/springframework/integration/channel/TestChannelRegistry.java b/org.springframework.integration/src/test/java/org/springframework/integration/channel/TestChannelMapping.java
similarity index 83%
rename from org.springframework.integration/src/test/java/org/springframework/integration/channel/TestChannelRegistry.java
rename to org.springframework.integration/src/test/java/org/springframework/integration/channel/TestChannelMapping.java
index 6a9e2aa95c..a769be3293 100644
--- a/org.springframework.integration/src/test/java/org/springframework/integration/channel/TestChannelRegistry.java
+++ b/org.springframework.integration/src/test/java/org/springframework/integration/channel/TestChannelMapping.java
@@ -19,21 +19,22 @@ package org.springframework.integration.channel;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.integration.router.ChannelMapping;
import org.springframework.util.Assert;
/**
* @author Mark Fisher
*/
-public class TestChannelRegistry implements ChannelRegistry {
+public class TestChannelMapping implements ChannelMapping {
private final Map channels = new ConcurrentHashMap();
- public MessageChannel lookupChannel(String channelName) {
+ public MessageChannel getChannel(String channelName) {
return this.channels.get(channelName);
}
- public void registerChannel(MessageChannel channel) {
+ public void addChannel(MessageChannel channel) {
Assert.notNull(channel, "'channel' must not be null");
Assert.notNull(channel.getName(), "channel name must not be null");
this.channels.put(channel.getName(), channel);
diff --git a/org.springframework.integration/src/test/java/org/springframework/integration/endpoint/ServiceActivatorEndpointTests.java b/org.springframework.integration/src/test/java/org/springframework/integration/endpoint/ServiceActivatorEndpointTests.java
index a54449e46f..d3bab333e6 100644
--- a/org.springframework.integration/src/test/java/org/springframework/integration/endpoint/ServiceActivatorEndpointTests.java
+++ b/org.springframework.integration/src/test/java/org/springframework/integration/endpoint/ServiceActivatorEndpointTests.java
@@ -30,8 +30,8 @@ import org.junit.Test;
import org.springframework.integration.bus.DefaultMessageBus;
import org.springframework.integration.channel.ChannelRegistry;
+import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.QueueChannel;
-import org.springframework.integration.channel.TestChannelRegistry;
import org.springframework.integration.message.Message;
import org.springframework.integration.message.MessageBuilder;
import org.springframework.integration.message.MessageHandlingException;
@@ -106,8 +106,6 @@ public class ServiceActivatorEndpointTests {
final QueueChannel replyChannel1 = new QueueChannel();
final QueueChannel replyChannel2 = new QueueChannel();
replyChannel2.setBeanName("replyChannel2");
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- channelRegistry.registerChannel(replyChannel2);
Object handler = new Object() {
@SuppressWarnings("unused")
public Message handle(Message message) {
@@ -115,7 +113,16 @@ public class ServiceActivatorEndpointTests {
}
};
ServiceActivatorEndpoint endpoint = new ServiceActivatorEndpoint(handler, "handle");
- endpoint.setChannelRegistry(channelRegistry);
+ endpoint.setChannelRegistry(new ChannelRegistry() {
+ public MessageChannel lookupChannel(String channelName) {
+ if (channelName.equals("replyChannel2")) {
+ return replyChannel2;
+ }
+ return null;
+ }
+ public void registerChannel(MessageChannel channel) {
+ }
+ });
Message testMessage1 = MessageBuilder.withPayload("bar")
.setReturnAddress(replyChannel1).build();
endpoint.onMessage(testMessage1);
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 3d9f53560f..5290d06a13 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
@@ -29,7 +29,7 @@ import org.junit.Test;
import org.springframework.integration.annotation.Header;
import org.springframework.integration.channel.ChannelRegistry;
import org.springframework.integration.channel.ChannelRegistryAware;
-import org.springframework.integration.channel.TestChannelRegistry;
+import org.springframework.integration.channel.TestChannelMapping;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.integration.message.GenericMessage;
@@ -47,15 +47,14 @@ public class MethodInvokingRouterTests {
public void channelNameResolutionByPayloadConfiguredByMethodReference() throws Exception {
QueueChannel barChannel = new QueueChannel();
barChannel.setBeanName("bar-channel");
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- channelRegistry.registerChannel(barChannel);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ channelMapping.addChannel(barChannel);
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
Method routingMethod = testBean.getClass().getMethod("routePayload", String.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.setChannelRegistry(channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ router.setChannelMapping(channelMapping);
Message message = new GenericMessage("bar");
- endpoint.onMessage(message);
+ router.onMessage(message);
Message replyMessage = barChannel.receive();
assertNotNull(replyMessage);
assertEquals(message, replyMessage);
@@ -65,14 +64,13 @@ public class MethodInvokingRouterTests {
public void channelNameResolutionByPayloadConfiguredByMethodName() {
QueueChannel barChannel = new QueueChannel();
barChannel.setBeanName("bar-channel");
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- channelRegistry.registerChannel(barChannel);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ channelMapping.addChannel(barChannel);
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload");
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.setChannelRegistry(channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload");
+ router.setChannelMapping(channelMapping);
Message message = new GenericMessage("bar");
- endpoint.onMessage(message);
+ router.onMessage(message);
Message replyMessage = barChannel.receive();
assertNotNull(replyMessage);
assertEquals(message, replyMessage);
@@ -84,17 +82,16 @@ public class MethodInvokingRouterTests {
QueueChannel barChannel = new QueueChannel();
fooChannel.setBeanName("foo-channel");
barChannel.setBeanName("bar-channel");
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- channelRegistry.registerChannel(fooChannel);
- channelRegistry.registerChannel(barChannel);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ channelMapping.addChannel(fooChannel);
+ channelMapping.addChannel(barChannel);
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
Method routingMethod = testBean.getClass().getMethod("routeByHeader", String.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.setChannelRegistry(channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ router.setChannelMapping(channelMapping);
Message message = MessageBuilder.withPayload("bar")
.setHeader("targetChannel", "foo").build();
- endpoint.onMessage(message);
+ router.onMessage(message);
Message fooReply = fooChannel.receive(0);
Message barReply = barChannel.receive(0);
assertNotNull(fooReply);
@@ -106,71 +103,66 @@ public class MethodInvokingRouterTests {
public void failsWhenRequiredHeaderIsNotProvided() throws Exception {
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
Method routingMethod = testBean.getClass().getMethod("routeByHeader", String.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.onMessage(new GenericMessage("testing"));
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ router.onMessage(new GenericMessage("testing"));
}
@Test
public void channelNameResolutionByMessageConfiguredByMethodReference() throws Exception {
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestChannelNameResolutionByMessage(endpoint);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ this.doTestChannelNameResolutionByMessage(router);
}
@Test
public void channelNameResolutionByMessageConfiguredByMethodName() {
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage");
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestChannelNameResolutionByMessage(endpoint);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage");
+ this.doTestChannelNameResolutionByMessage(router);
}
- private void doTestChannelNameResolutionByMessage(RouterEndpoint endpoint) {
+ private void doTestChannelNameResolutionByMessage(MethodInvokingRouter router) {
QueueChannel fooChannel = new QueueChannel();
QueueChannel barChannel = new QueueChannel();
fooChannel.setBeanName("foo-channel");
barChannel.setBeanName("bar-channel");
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- channelRegistry.registerChannel(fooChannel);
- channelRegistry.registerChannel(barChannel);
- endpoint.setChannelRegistry(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ channelMapping.addChannel(fooChannel);
+ channelMapping.addChannel(barChannel);
+ router.setChannelMapping(channelMapping);
Message fooMessage = new StringMessage("foo");
Message barMessage = new StringMessage("bar");
Message badMessage = new StringMessage("bad");
- endpoint.onMessage(fooMessage);
+ router.onMessage(fooMessage);
Message result1 = fooChannel.receive(0);
assertNotNull(result1);
assertEquals("foo", result1.getPayload());
- endpoint.onMessage(barMessage);
+ router.onMessage(barMessage);
Message result2 = barChannel.receive(0);
assertNotNull(result2);
assertEquals("bar", result2.getPayload());
- endpoint.onMessage(badMessage);
+ router.onMessage(badMessage);
}
@Test
public void channelInstanceResolutionByPayloadConfiguredByMethodReference() throws Exception {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelMapping);
Method routingMethod = testBean.getClass().getMethod("routePayload", String.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestChannelInstanceResolutionByPayload(endpoint, channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ this.doTestChannelInstanceResolutionByPayload(router, channelMapping);
}
@Test
public void channelInstanceResolutionByPayloadConfiguredByMethodName() {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload");
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestChannelInstanceResolutionByPayload(endpoint, channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelMapping);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload");
+ this.doTestChannelInstanceResolutionByPayload(router, channelMapping);
}
- private void doTestChannelInstanceResolutionByPayload(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
+ private void doTestChannelInstanceResolutionByPayload(MethodInvokingRouter router, TestChannelMapping channelMapping) {
Message fooMessage = new StringMessage("foo");
Message barMessage = new StringMessage("bar");
Message badMessage = new StringMessage("bad");
@@ -178,341 +170,327 @@ public class MethodInvokingRouterTests {
QueueChannel barChannel = new QueueChannel();
fooChannel.setBeanName("foo-channel");
barChannel.setBeanName("bar-channel");
- channelRegistry.registerChannel(fooChannel);
- channelRegistry.registerChannel(barChannel);
- endpoint.setChannelRegistry(channelRegistry);
- endpoint.onMessage(fooMessage);
+ channelMapping.addChannel(fooChannel);
+ channelMapping.addChannel(barChannel);
+ router.setChannelMapping(channelMapping);
+ router.onMessage(fooMessage);
Message result1 = fooChannel.receive(0);
assertNotNull(result1);
assertEquals("foo", result1.getPayload());
- endpoint.onMessage(barMessage);
+ router.onMessage(barMessage);
Message result2 = barChannel.receive(0);
assertNotNull(result2);
assertEquals("bar", result2.getPayload());
- endpoint.onMessage(badMessage);
+ router.onMessage(badMessage);
}
@Test
public void channelInstanceResolutionByMessageConfiguredByMethodReference() throws Exception {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelMapping);
Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestChannelInstanceResolutionByMessage(endpoint, channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ this.doTestChannelInstanceResolutionByMessage(router, channelMapping);
}
@Test
public void channelInstanceResolutionByMessageConfiguredByMethodName() {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage");
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestChannelInstanceResolutionByMessage(endpoint, channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelMapping);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage");
+ this.doTestChannelInstanceResolutionByMessage(router, channelMapping);
}
- private void doTestChannelInstanceResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
+ private void doTestChannelInstanceResolutionByMessage(MethodInvokingRouter router, TestChannelMapping channelMapping) {
QueueChannel fooChannel = new QueueChannel();
QueueChannel barChannel = new QueueChannel();
fooChannel.setBeanName("foo-channel");
barChannel.setBeanName("bar-channel");
- channelRegistry.registerChannel(fooChannel);
- channelRegistry.registerChannel(barChannel);
- endpoint.setChannelRegistry(channelRegistry);
+ channelMapping.addChannel(fooChannel);
+ channelMapping.addChannel(barChannel);
+ router.setChannelMapping(channelMapping);
Message fooMessage = new StringMessage("foo");
Message barMessage = new StringMessage("bar");
Message badMessage = new StringMessage("bad");
- endpoint.onMessage(fooMessage);
+ router.onMessage(fooMessage);
Message result1 = fooChannel.receive(0);
assertNotNull(result1);
assertEquals("foo", result1.getPayload());
- endpoint.onMessage(barMessage);
+ router.onMessage(barMessage);
Message result2 = barChannel.receive(0);
assertNotNull(result2);
assertEquals("bar", result2.getPayload());
- endpoint.onMessage(badMessage);
+ router.onMessage(badMessage);
}
@Test
public void multiChannelNameResolutionByPayloadConfiguredByMethodReference() throws Exception {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
+ TestChannelMapping channelMapping = new TestChannelMapping();
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
Method routingMethod = testBean.getClass().getMethod("routePayload", String.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelNameResolutionByPayload(endpoint, channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ this.doTestMultiChannelNameResolutionByPayload(router, channelMapping);
}
@Test
public void multiChannelNameResolutionByPayloadConfiguredByMethodName() {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
+ TestChannelMapping channelMapping = new TestChannelMapping();
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload");
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelNameResolutionByPayload(endpoint, channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload");
+ this.doTestMultiChannelNameResolutionByPayload(router, channelMapping);
}
- private void doTestMultiChannelNameResolutionByPayload(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
+ private void doTestMultiChannelNameResolutionByPayload(MethodInvokingRouter router, TestChannelMapping channelMapping) {
QueueChannel fooChannel = new QueueChannel();
QueueChannel barChannel = new QueueChannel();
fooChannel.setBeanName("foo-channel");
barChannel.setBeanName("bar-channel");
- channelRegistry.registerChannel(fooChannel);
- channelRegistry.registerChannel(barChannel);
- endpoint.setChannelRegistry(channelRegistry);
+ channelMapping.addChannel(fooChannel);
+ channelMapping.addChannel(barChannel);
+ router.setChannelMapping(channelMapping);
Message fooMessage = new StringMessage("foo");
Message barMessage = new StringMessage("bar");
Message badMessage = new StringMessage("bad");
- endpoint.onMessage(fooMessage);
+ router.onMessage(fooMessage);
Message result1a = fooChannel.receive(0);
Message result1b = barChannel.receive(0);
assertNotNull(result1a);
assertEquals("foo", result1a.getPayload());
assertNotNull(result1b);
assertEquals("foo", result1b.getPayload());
- endpoint.onMessage(barMessage);
+ router.onMessage(barMessage);
Message result2a = fooChannel.receive(0);
Message result2b = barChannel.receive(0);
assertNotNull(result2a);
assertEquals("bar", result2a.getPayload());
assertNotNull(result2b);
assertEquals("bar", result2b.getPayload());
- endpoint.onMessage(badMessage);
+ router.onMessage(badMessage);
}
@Test
public void multiChannelNameResolutionByMessageConfiguredByMethodReference() throws Exception {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
+ TestChannelMapping channelMapping = new TestChannelMapping();
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelNameResolutionByMessage(endpoint, channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ this.doTestMultiChannelNameResolutionByMessage(router, channelMapping);
}
@Test
public void multiChannelNameResolutionByMessageConfiguredByMethodName() throws Exception {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
+ TestChannelMapping channelMapping = new TestChannelMapping();
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage");
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelNameResolutionByMessage(endpoint, channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage");
+ this.doTestMultiChannelNameResolutionByMessage(router, channelMapping);
}
- private void doTestMultiChannelNameResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
+ private void doTestMultiChannelNameResolutionByMessage(MethodInvokingRouter router, TestChannelMapping channelMapping) {
QueueChannel fooChannel = new QueueChannel();
QueueChannel barChannel = new QueueChannel();
fooChannel.setBeanName("foo-channel");
barChannel.setBeanName("bar-channel");
- channelRegistry.registerChannel(fooChannel);
- channelRegistry.registerChannel(barChannel);
- endpoint.setChannelRegistry(channelRegistry);
+ channelMapping.addChannel(fooChannel);
+ channelMapping.addChannel(barChannel);
+ router.setChannelMapping(channelMapping);
Message fooMessage = new StringMessage("foo");
Message barMessage = new StringMessage("bar");
Message badMessage = new StringMessage("bad");
- endpoint.onMessage(fooMessage);
+ router.onMessage(fooMessage);
Message result1a = fooChannel.receive(0);
assertNotNull(result1a);
assertEquals("foo", result1a.getPayload());
Message result1b = barChannel.receive(0);
assertNotNull(result1b);
assertEquals("foo", result1b.getPayload());
- endpoint.onMessage(barMessage);
+ router.onMessage(barMessage);
Message result2a = fooChannel.receive(0);
assertNotNull(result2a);
assertEquals("bar", result2a.getPayload());
Message result2b = barChannel.receive(0);
assertNotNull(result2b);
assertEquals("bar", result2b.getPayload());
- endpoint.onMessage(badMessage);
+ router.onMessage(badMessage);
}
@Test
public void multiChannelNameArrayResolutionByMessageConfiguredByMethodReference() throws Exception {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
+ TestChannelMapping channelMapping = new TestChannelMapping();
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
Method routingMethod = testBean.getClass().getMethod("routeMessageToArray", Message.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelNameArrayResolutionByMessage(endpoint, channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ this.doTestMultiChannelNameArrayResolutionByMessage(router, channelMapping);
}
@Test
public void multiChannelNameArrayResolutionByMessageConfiguredByMethodName() {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
+ TestChannelMapping channelMapping = new TestChannelMapping();
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessageToArray");
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelNameArrayResolutionByMessage(endpoint, channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessageToArray");
+ this.doTestMultiChannelNameArrayResolutionByMessage(router, channelMapping);
}
- private void doTestMultiChannelNameArrayResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
+ private void doTestMultiChannelNameArrayResolutionByMessage(MethodInvokingRouter router, TestChannelMapping channelMapping) {
QueueChannel fooChannel = new QueueChannel();
QueueChannel barChannel = new QueueChannel();
fooChannel.setBeanName("foo-channel");
barChannel.setBeanName("bar-channel");
- channelRegistry.registerChannel(fooChannel);
- channelRegistry.registerChannel(barChannel);
- endpoint.setChannelRegistry(channelRegistry);
+ channelMapping.addChannel(fooChannel);
+ channelMapping.addChannel(barChannel);
+ router.setChannelMapping(channelMapping);
Message fooMessage = new StringMessage("foo");
Message barMessage = new StringMessage("bar");
Message badMessage = new StringMessage("bad");
- endpoint.onMessage(fooMessage);
+ router.onMessage(fooMessage);
Message result1a = fooChannel.receive(0);
assertNotNull(result1a);
assertEquals("foo", result1a.getPayload());
Message result1b = barChannel.receive(0);
assertNotNull(result1b);
assertEquals("foo", result1b.getPayload());
- endpoint.onMessage(barMessage);
+ router.onMessage(barMessage);
Message result2a = fooChannel.receive(0);
assertNotNull(result2a);
assertEquals("bar", result2a.getPayload());
Message result2b = barChannel.receive(0);
assertNotNull(result2b);
assertEquals("bar", result2b.getPayload());
- endpoint.onMessage(badMessage);
+ router.onMessage(badMessage);
}
@Test
public void multiChannelListResolutionByPayloadConfiguredByMethodReference() throws Exception {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelMapping);
Method routingMethod = testBean.getClass().getMethod("routePayload", String.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelListResolutionByPayload(endpoint, channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ this.doTestMultiChannelListResolutionByPayload(router, channelMapping);
}
@Test
public void multiChannelListResolutionByPayloadConfiguredByMethodName() {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload");
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelListResolutionByPayload(endpoint, channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelMapping);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload");
+ this.doTestMultiChannelListResolutionByPayload(router, channelMapping);
}
- private void doTestMultiChannelListResolutionByPayload(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
+ private void doTestMultiChannelListResolutionByPayload(MethodInvokingRouter router, TestChannelMapping channelMapping) {
QueueChannel fooChannel = new QueueChannel();
QueueChannel barChannel = new QueueChannel();
fooChannel.setBeanName("foo-channel");
barChannel.setBeanName("bar-channel");
- channelRegistry.registerChannel(fooChannel);
- channelRegistry.registerChannel(barChannel);
- endpoint.setChannelRegistry(channelRegistry);
+ channelMapping.addChannel(fooChannel);
+ channelMapping.addChannel(barChannel);
+ router.setChannelMapping(channelMapping);
Message fooMessage = new StringMessage("foo");
Message barMessage = new StringMessage("bar");
Message badMessage = new StringMessage("bad");
- endpoint.onMessage(fooMessage);
+ router.onMessage(fooMessage);
Message result1a = fooChannel.receive(0);
Message result1b = barChannel.receive(0);
assertNotNull(result1a);
assertEquals("foo", result1a.getPayload());
assertNotNull(result1b);
assertEquals("foo", result1b.getPayload());
- endpoint.onMessage(barMessage);
+ router.onMessage(barMessage);
Message result2a = fooChannel.receive(0);
Message result2b = barChannel.receive(0);
assertNotNull(result2a);
assertEquals("bar", result2a.getPayload());
assertNotNull(result2b);
assertEquals("bar", result2b.getPayload());
- endpoint.onMessage(badMessage);
+ router.onMessage(badMessage);
}
@Test
public void multiChannelListResolutionByMessageConfiguredByMethodReference() throws Exception {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelMapping);
Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelListResolutionByMessage(endpoint, channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ this.doTestMultiChannelListResolutionByMessage(router, channelMapping);
}
@Test
public void multiChannelListResolutionByMessageConfiguredByMethodName() {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage");
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelListResolutionByMessage(endpoint, channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelMapping);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage");
+ this.doTestMultiChannelListResolutionByMessage(router, channelMapping);
}
- private void doTestMultiChannelListResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
+ private void doTestMultiChannelListResolutionByMessage(MethodInvokingRouter router, TestChannelMapping channelMapping) {
QueueChannel fooChannel = new QueueChannel();
QueueChannel barChannel = new QueueChannel();
fooChannel.setBeanName("foo-channel");
barChannel.setBeanName("bar-channel");
- channelRegistry.registerChannel(fooChannel);
- channelRegistry.registerChannel(barChannel);
- endpoint.setChannelRegistry(channelRegistry);
+ channelMapping.addChannel(fooChannel);
+ channelMapping.addChannel(barChannel);
+ router.setChannelMapping(channelMapping);
Message fooMessage = new StringMessage("foo");
Message barMessage = new StringMessage("bar");
Message badMessage = new StringMessage("bad");
- endpoint.onMessage(fooMessage);
+ router.onMessage(fooMessage);
Message result1a = fooChannel.receive(0);
Message result1b = barChannel.receive(0);
assertNotNull(result1a);
assertEquals("foo", result1a.getPayload());
assertNotNull(result1b);
assertEquals("foo", result1b.getPayload());
- endpoint.onMessage(barMessage);
+ router.onMessage(barMessage);
Message result2a = fooChannel.receive(0);
Message result2b = barChannel.receive(0);
assertNotNull(result2a);
assertEquals("bar", result2a.getPayload());
assertNotNull(result2b);
assertEquals("bar", result2b.getPayload());
- endpoint.onMessage(badMessage);
+ router.onMessage(badMessage);
}
@Test
public void multiChannelArrayResolutionByMessageConfiguredByMethodReference() throws Exception {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelMapping);
Method routingMethod = testBean.getClass().getMethod("routeMessageToArray", Message.class);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelArrayResolutionByMessage(endpoint, channelRegistry);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
+ this.doTestMultiChannelArrayResolutionByMessage(router, channelMapping);
}
@Test
public void multiChannelArrayResolutionByMessageConfiguredByMethodName() {
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
- MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessageToArray");
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- this.doTestMultiChannelArrayResolutionByMessage(endpoint, channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelMapping);
+ MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessageToArray");
+ this.doTestMultiChannelArrayResolutionByMessage(router, channelMapping);
}
- private void doTestMultiChannelArrayResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
+ private void doTestMultiChannelArrayResolutionByMessage(MethodInvokingRouter router, TestChannelMapping channelMapping) {
QueueChannel fooChannel = new QueueChannel();
QueueChannel barChannel = new QueueChannel();
fooChannel.setBeanName("foo-channel");
barChannel.setBeanName("bar-channel");
- channelRegistry.registerChannel(fooChannel);
- channelRegistry.registerChannel(barChannel);
- endpoint.setChannelRegistry(channelRegistry);
+ channelMapping.addChannel(fooChannel);
+ channelMapping.addChannel(barChannel);
+ router.setChannelMapping(channelMapping);
Message fooMessage = new StringMessage("foo");
Message barMessage = new StringMessage("bar");
Message badMessage = new StringMessage("bad");
- endpoint.onMessage(fooMessage);
+ router.onMessage(fooMessage);
Message result1a = fooChannel.receive(0);
Message result1b = barChannel.receive(0);
assertNotNull(result1a);
assertEquals("foo", result1a.getPayload());
assertNotNull(result1b);
assertEquals("foo", result1b.getPayload());
- endpoint.onMessage(barMessage);
+ router.onMessage(barMessage);
Message result2a = fooChannel.receive(0);
Message result2b = barChannel.receive(0);
assertNotNull(result2a);
assertEquals("bar", result2a.getPayload());
assertNotNull(result2b);
assertEquals("bar", result2b.getPayload());
- endpoint.onMessage(badMessage);
+ router.onMessage(badMessage);
}
@@ -572,22 +550,22 @@ public class MethodInvokingRouterTests {
public static class SingleChannelInstanceRoutingTestBean {
- private ChannelRegistry registry;
+ private ChannelMapping mapping;
- public SingleChannelInstanceRoutingTestBean(ChannelRegistry registry) {
- this.registry = registry;
+ public SingleChannelInstanceRoutingTestBean(ChannelMapping mapping) {
+ this.mapping = mapping;
}
public MessageChannel routePayload(String name) {
- return registry.lookupChannel(name + "-channel");
+ return mapping.getChannel(name + "-channel");
}
public MessageChannel routeMessage(Message message) {
if (message.getPayload().equals("foo")) {
- return registry.lookupChannel("foo-channel");
+ return mapping.getChannel("foo-channel");
}
else if (message.getPayload().equals("bar")) {
- return registry.lookupChannel("bar-channel");
+ return mapping.getChannel("bar-channel");
}
return null;
}
@@ -596,17 +574,17 @@ public class MethodInvokingRouterTests {
public static class MultiChannelInstanceRoutingTestBean {
- private ChannelRegistry registry;
+ private ChannelMapping mapping;
- public MultiChannelInstanceRoutingTestBean(ChannelRegistry registry) {
- this.registry = registry;
+ public MultiChannelInstanceRoutingTestBean(ChannelMapping mapping) {
+ this.mapping = mapping;
}
public List routePayload(String name) {
List results = new ArrayList();
if (name.equals("foo") || name.equals("bar")) {
- results.add(registry.lookupChannel("foo-channel"));
- results.add(registry.lookupChannel("bar-channel"));
+ results.add(mapping.getChannel("foo-channel"));
+ results.add(mapping.getChannel("bar-channel"));
}
return results;
}
@@ -614,8 +592,8 @@ public class MethodInvokingRouterTests {
public List routeMessage(Message message) {
List results = new ArrayList();
if (message.getPayload().equals("foo") || message.getPayload().equals("bar")) {
- results.add(registry.lookupChannel("foo-channel"));
- results.add(registry.lookupChannel("bar-channel"));
+ results.add(mapping.getChannel("foo-channel"));
+ results.add(mapping.getChannel("bar-channel"));
}
return results;
}
@@ -624,8 +602,8 @@ public class MethodInvokingRouterTests {
MessageChannel[] results = null;
if (message.getPayload().equals("foo") || message.getPayload().equals("bar")) {
results = new MessageChannel[2];
- results[0] = registry.lookupChannel("foo-channel");
- results[1] = registry.lookupChannel("bar-channel");
+ results[0] = mapping.getChannel("foo-channel");
+ results[1] = mapping.getChannel("bar-channel");
}
return results;
}
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 6f1a8693d3..20eec48e65 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
@@ -19,15 +19,10 @@ package org.springframework.integration.router;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import java.util.ArrayList;
-import java.util.List;
-
import org.junit.Test;
-import org.springframework.integration.channel.ChannelRegistry;
-import org.springframework.integration.channel.TestChannelRegistry;
-import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.QueueChannel;
+import org.springframework.integration.channel.TestChannelMapping;
import org.springframework.integration.message.Message;
import org.springframework.integration.message.MessagingException;
import org.springframework.integration.message.StringMessage;
@@ -38,31 +33,8 @@ import org.springframework.integration.message.StringMessage;
public class MultiChannelRouterTests {
@Test
- public void routeWithChannelResolver() {
- final QueueChannel channel1 = new QueueChannel();
- final QueueChannel channel2 = new QueueChannel();
- ChannelResolver channelResolver = new ChannelResolver() {
- public List resolveChannels(Message message) {
- List channels = new ArrayList();
- channels.add(channel1);
- channels.add(channel2);
- return channels;
- }
- };
- RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
- Message message = new StringMessage("test");
- endpoint.onMessage(message);
- Message result1 = channel1.receive(25);
- assertNotNull(result1);
- assertEquals("test", result1.getPayload());
- Message result2 = channel2.receive(25);
- assertNotNull(result2);
- assertEquals("test", result2.getPayload());
- }
-
- @Test
- public void routeWithChannelNameResolver() {
- AbstractChannelNameResolver channelNameResolver = new AbstractChannelNameResolver() {
+ public void routeWithChannelMapping() {
+ AbstractChannelMappingMessageRouter router = new AbstractChannelMappingMessageRouter() {
public String[] resolveChannelNames(Message message) {
return new String[] {"channel1", "channel2"};
}
@@ -71,13 +43,12 @@ public class MultiChannelRouterTests {
QueueChannel channel2 = new QueueChannel();
channel1.setBeanName("channel1");
channel2.setBeanName("channel2");
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- channelRegistry.registerChannel(channel1);
- channelRegistry.registerChannel(channel2);
- RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
- endpoint.setChannelRegistry(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ channelMapping.addChannel(channel1);
+ channelMapping.addChannel(channel2);
+ router.setChannelMapping(channelMapping);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
Message result1 = channel1.receive(25);
assertNotNull(result1);
assertEquals("test", result1.getPayload());
@@ -88,28 +59,26 @@ public class MultiChannelRouterTests {
@Test(expected = MessagingException.class)
public void channelNameLookupFailure() {
- AbstractChannelNameResolver channelNameResolver = new AbstractChannelNameResolver() {
+ AbstractChannelMappingMessageRouter router = new AbstractChannelMappingMessageRouter() {
public String[] resolveChannelNames(Message message) {
return new String[] {"noSuchChannel"};
}
};
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
- endpoint.setChannelRegistry(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ router.setChannelMapping(channelMapping);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
}
@Test(expected = MessagingException.class)
- public void channelRegistryNotAvailable() {
- AbstractChannelNameResolver channelNameResolver = new AbstractChannelNameResolver() {
+ public void channelMappingNotAvailable() {
+ AbstractChannelMappingMessageRouter router = new AbstractChannelMappingMessageRouter() {
public String[] resolveChannelNames(Message message) {
return new String[] {"noSuchChannel"};
}
};
- RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(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 9f23a92176..c14e712210 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,7 +24,6 @@ import java.util.concurrent.ConcurrentHashMap;
import org.junit.Test;
-import org.springframework.integration.channel.TestChannelRegistry;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.integration.message.GenericMessage;
@@ -40,15 +39,15 @@ public class PayloadTypeRouterTests {
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);
- PayloadTypeChannelResolver resolver = new PayloadTypeChannelResolver();
- resolver.setChannelMappings(channelMappings);
+ Map, MessageChannel> payloadTypeChannelMap = new ConcurrentHashMap, MessageChannel>();
+ payloadTypeChannelMap.put(String.class, stringChannel);
+ payloadTypeChannelMap.put(Integer.class, integerChannel);
+ PayloadTypeRouter router = new PayloadTypeRouter();
+ router.setPayloadTypeChannelMap(payloadTypeChannelMap);
Message message1 = new StringMessage("test");
Message message2 = new GenericMessage(123);
- MessageChannel result1 = resolver.resolveChannel(message1);
- MessageChannel result2 = resolver.resolveChannel(message2);
+ MessageChannel result1 = router.resolveChannel(message1);
+ MessageChannel result2 = router.resolveChannel(message2);
assertEquals(stringChannel, result1);
assertEquals(integerChannel, result2);
}
@@ -59,20 +58,15 @@ public class PayloadTypeRouterTests {
QueueChannel integerChannel = new QueueChannel();
stringChannel.setBeanName("stringChannel");
integerChannel.setBeanName("integerChannel");
- Map, MessageChannel> channelMappings = new ConcurrentHashMap, MessageChannel>();
- channelMappings.put(String.class, stringChannel);
- channelMappings.put(Integer.class, integerChannel);
- TestChannelRegistry channelRegistry = new TestChannelRegistry();
- channelRegistry.registerChannel(stringChannel);
- channelRegistry.registerChannel(integerChannel);
- PayloadTypeChannelResolver resolver = new PayloadTypeChannelResolver();
- resolver.setChannelMappings(channelMappings);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.setChannelRegistry(channelRegistry);
+ Map, MessageChannel> payloadTypeChannelMap = new ConcurrentHashMap, MessageChannel>();
+ payloadTypeChannelMap.put(String.class, stringChannel);
+ payloadTypeChannelMap.put(Integer.class, integerChannel);
+ PayloadTypeRouter router = new PayloadTypeRouter();
+ router.setPayloadTypeChannelMap(payloadTypeChannelMap);
Message message1 = new StringMessage("test");
Message message2 = new GenericMessage(123);
- endpoint.onMessage(message1);
- endpoint.onMessage(message2);
+ router.onMessage(message1);
+ router.onMessage(message2);
Message reply1 = stringChannel.receive(0);
Message reply2 = integerChannel.receive(0);
assertEquals("test", reply1.getPayload());
@@ -85,19 +79,15 @@ public class PayloadTypeRouterTests {
stringChannel.setBeanName("stringChannel");
QueueChannel defaultChannel = new QueueChannel();
defaultChannel.setBeanName("defaultChannel");
- TestChannelRegistry channelRegistry = new TestChannelRegistry();
- 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);
+ Map, MessageChannel> payloadTypeChannelMap = new ConcurrentHashMap, MessageChannel>();
+ payloadTypeChannelMap.put(String.class, stringChannel);
+ PayloadTypeRouter router = new PayloadTypeRouter();
+ router.setPayloadTypeChannelMap(payloadTypeChannelMap);
+ router.setDefaultOutputChannel(defaultChannel);
Message message1 = new StringMessage("test");
Message message2 = new GenericMessage(123);
- endpoint.onMessage(message1);
- endpoint.onMessage(message2);
+ router.onMessage(message1);
+ router.onMessage(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 f9f7154c47..34ed291bc0 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
@@ -45,11 +45,11 @@ public class RecipientListRouterTests {
List channels = new ArrayList();
channels.add(channel1);
channels.add(channel2);
- RecipientListChannelResolver resolver = new RecipientListChannelResolver();
- resolver.setChannels(channels);
- resolver.afterPropertiesSet();
+ RecipientListRouter router = new RecipientListRouter();
+ router.setChannels(channels);
+ router.afterPropertiesSet();
Message message = new StringMessage("test");
- Collection resolved = resolver.resolveChannels(message);
+ Collection resolved = router.resolveChannels(message);
assertEquals(2, resolved.size());
assertTrue(resolved.contains(channel1));
assertTrue(resolved.contains(channel2));
@@ -62,12 +62,11 @@ public class RecipientListRouterTests {
List channels = new ArrayList();
channels.add(channel1);
channels.add(channel2);
- RecipientListChannelResolver resolver = new RecipientListChannelResolver();
- resolver.setChannels(channels);
- resolver.afterPropertiesSet();
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
+ RecipientListRouter router = new RecipientListRouter();
+ router.setChannels(channels);
+ router.afterPropertiesSet();
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
Message result1 = channel1.receive(25);
assertNotNull(result1);
assertEquals("test", result1.getPayload());
@@ -80,11 +79,10 @@ public class RecipientListRouterTests {
public void routeToSingleChannel() {
QueueChannel channel = new QueueChannel();
channel.setBeanName("channel");
- RecipientListChannelResolver resolver = new RecipientListChannelResolver();
- resolver.setChannels(Collections.singletonList((MessageChannel) channel));
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
+ RecipientListRouter router = new RecipientListRouter();
+ router.setChannels(Collections.singletonList((MessageChannel) channel));
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
Message result1 = channel.receive(25);
assertNotNull(result1);
assertEquals("test", result1.getPayload());
@@ -93,22 +91,24 @@ public class RecipientListRouterTests {
}
@Test(expected = IllegalArgumentException.class)
- public void nullChannelListNotSettable() {
- RecipientListChannelResolver resolver = new RecipientListChannelResolver();
- resolver.setChannels(null);
+ public void nullChannelListRejected() {
+ RecipientListRouter router = new RecipientListRouter();
+ router.setChannels(null);
+ router.afterPropertiesSet();
}
@Test(expected = IllegalArgumentException.class)
- public void emptyChannelListNotSettable() {
- RecipientListChannelResolver resolver = new RecipientListChannelResolver();
+ public void emptyChannelListRejected() {
+ RecipientListRouter router = new RecipientListRouter();
List channels = new ArrayList();
- resolver.setChannels(channels);
+ router.setChannels(channels);
+ router.afterPropertiesSet();
}
@Test(expected = IllegalArgumentException.class)
- public void nullChannelListFailsInitialization() {
- RecipientListChannelResolver resolver = new RecipientListChannelResolver();
- resolver.afterPropertiesSet();
+ public void noChannelListFailsInitialization() {
+ RecipientListRouter router = new RecipientListRouter();
+ router.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 56fb7161ea..28ebd75207 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
@@ -50,22 +50,21 @@ public class RootCauseErrorMessageRouterTests {
@Test
- public void testMostSpecificCause() {
+ public void mostSpecificCause() {
Message failedMessage = new StringMessage("foo");
IllegalArgumentException rootCause = new IllegalArgumentException("bad argument");
RuntimeException middleCause = new RuntimeException(rootCause);
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
ErrorMessage message = new ErrorMessage(error);
- RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
- Map, MessageChannel> channelMappings =
+ RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
+ Map, MessageChannel> exceptionTypeChannelMap =
new HashMap, MessageChannel>();
- channelMappings.put(IllegalArgumentException.class, illegalArgumentChannel);
- channelMappings.put(RuntimeException.class, runtimeExceptionChannel);
- channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel);
- resolver.setChannelMappings(channelMappings);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.setDefaultOutputChannel(defaultChannel);
- endpoint.onMessage(message);
+ exceptionTypeChannelMap.put(IllegalArgumentException.class, illegalArgumentChannel);
+ exceptionTypeChannelMap.put(RuntimeException.class, runtimeExceptionChannel);
+ exceptionTypeChannelMap.put(MessageHandlingException.class, messageHandlingExceptionChannel);
+ router.setExceptionTypeChannelMap(exceptionTypeChannelMap);
+ router.setDefaultOutputChannel(defaultChannel);
+ router.onMessage(message);
assertNotNull(illegalArgumentChannel.receive(1000));
assertNull(defaultChannel.receive(0));
assertNull(runtimeExceptionChannel.receive(0));
@@ -73,21 +72,20 @@ public class RootCauseErrorMessageRouterTests {
}
@Test
- public void testFallbackToNextMostSpecificCause() {
+ public void fallbackToNextMostSpecificCause() {
Message failedMessage = new StringMessage("foo");
IllegalArgumentException rootCause = new IllegalArgumentException("bad argument");
RuntimeException middleCause = new RuntimeException(rootCause);
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
ErrorMessage message = new ErrorMessage(error);
- RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
- Map, MessageChannel> channelMappings =
+ RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
+ Map, MessageChannel> exceptionTypeChannelMap =
new HashMap, MessageChannel>();
- channelMappings.put(RuntimeException.class, runtimeExceptionChannel);
- channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel);
- resolver.setChannelMappings(channelMappings);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.setDefaultOutputChannel(defaultChannel);
- endpoint.onMessage(message);
+ exceptionTypeChannelMap.put(RuntimeException.class, runtimeExceptionChannel);
+ exceptionTypeChannelMap.put(MessageHandlingException.class, messageHandlingExceptionChannel);
+ router.setExceptionTypeChannelMap(exceptionTypeChannelMap);
+ router.setDefaultOutputChannel(defaultChannel);
+ router.onMessage(message);
assertNotNull(runtimeExceptionChannel.receive(1000));
assertNull(illegalArgumentChannel.receive(0));
assertNull(defaultChannel.receive(0));
@@ -95,20 +93,19 @@ public class RootCauseErrorMessageRouterTests {
}
@Test
- public void testFallbackToErrorMessageType() {
+ public void fallbackToErrorMessageType() {
Message failedMessage = new StringMessage("foo");
IllegalArgumentException rootCause = new IllegalArgumentException("bad argument");
RuntimeException middleCause = new RuntimeException(rootCause);
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
ErrorMessage message = new ErrorMessage(error);
- RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
- Map, MessageChannel> channelMappings =
+ RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
+ Map, MessageChannel> exceptionTypeChannelMap =
new HashMap, MessageChannel>();
- channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel);
- resolver.setChannelMappings(channelMappings);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.setDefaultOutputChannel(defaultChannel);
- endpoint.onMessage(message);
+ exceptionTypeChannelMap.put(MessageHandlingException.class, messageHandlingExceptionChannel);
+ router.setExceptionTypeChannelMap(exceptionTypeChannelMap);
+ router.setDefaultOutputChannel(defaultChannel);
+ router.onMessage(message);
assertNotNull(messageHandlingExceptionChannel.receive(1000));
assertNull(runtimeExceptionChannel.receive(0));
assertNull(illegalArgumentChannel.receive(0));
@@ -116,16 +113,15 @@ public class RootCauseErrorMessageRouterTests {
}
@Test
- public void testFallbackToDefaultChannel() {
+ public void fallbackToDefaultChannel() {
Message failedMessage = new StringMessage("foo");
IllegalArgumentException rootCause = new IllegalArgumentException("bad argument");
RuntimeException middleCause = new RuntimeException(rootCause);
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
ErrorMessage message = new ErrorMessage(error);
- RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.setDefaultOutputChannel(defaultChannel);
- endpoint.onMessage(message);
+ RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
+ router.setDefaultOutputChannel(defaultChannel);
+ router.onMessage(message);
assertNotNull(defaultChannel.receive(1000));
assertNull(runtimeExceptionChannel.receive(0));
assertNull(illegalArgumentChannel.receive(0));
@@ -133,39 +129,37 @@ public class RootCauseErrorMessageRouterTests {
}
@Test(expected = MessageDeliveryException.class)
- public void testNoMatchAndNoDefaultChannel() {
+ public void noMatchAndNoDefaultChannel() {
Message failedMessage = new StringMessage("foo");
IllegalArgumentException rootCause = new IllegalArgumentException("bad argument");
RuntimeException middleCause = new RuntimeException(rootCause);
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
ErrorMessage message = new ErrorMessage(error);
- RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
- Map, MessageChannel> channelMappings =
+ RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
+ Map, MessageChannel> exceptionTypeChannelMap =
new HashMap, MessageChannel>();
- channelMappings.put(MessageDeliveryException.class, messageDeliveryExceptionChannel);
- resolver.setChannelMappings(channelMappings);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.setResolutionRequired(true);
- endpoint.onMessage(message);
+ exceptionTypeChannelMap.put(MessageDeliveryException.class, messageDeliveryExceptionChannel);
+ router.setExceptionTypeChannelMap(exceptionTypeChannelMap);
+ router.setResolutionRequired(true);
+ router.onMessage(message);
}
@Test
- public void testExceptionPayloadButNotErrorMessage() {
+ public void exceptionPayloadButNotErrorMessage() {
Message failedMessage = new StringMessage("foo");
IllegalArgumentException rootCause = new IllegalArgumentException("bad argument");
RuntimeException middleCause = new RuntimeException(rootCause);
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
Message message = new GenericMessage(error);
- RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
- Map, MessageChannel> channelMappings =
+ RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
+ Map, MessageChannel> exceptionTypeChannelMap =
new HashMap, MessageChannel>();
- channelMappings.put(IllegalArgumentException.class, illegalArgumentChannel);
- channelMappings.put(RuntimeException.class, runtimeExceptionChannel);
- channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel);
- resolver.setChannelMappings(channelMappings);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.setDefaultOutputChannel(defaultChannel);
- endpoint.onMessage(message);
+ exceptionTypeChannelMap.put(IllegalArgumentException.class, illegalArgumentChannel);
+ exceptionTypeChannelMap.put(RuntimeException.class, runtimeExceptionChannel);
+ exceptionTypeChannelMap.put(MessageHandlingException.class, messageHandlingExceptionChannel);
+ router.setExceptionTypeChannelMap(exceptionTypeChannelMap);
+ router.setDefaultOutputChannel(defaultChannel);
+ router.onMessage(message);
assertNotNull(illegalArgumentChannel.receive(1000));
assertNull(defaultChannel.receive(0));
assertNull(runtimeExceptionChannel.receive(0));
@@ -173,21 +167,20 @@ public class RootCauseErrorMessageRouterTests {
}
@Test
- public void testIntermediateCauseHasNoMappingButMostSpecificCauseDoes() {
+ public void intermediateCauseHasNoMappingButMostSpecificCauseDoes() {
Message failedMessage = new StringMessage("foo");
IllegalArgumentException rootCause = new IllegalArgumentException("bad argument");
RuntimeException middleCause = new RuntimeException(rootCause);
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
ErrorMessage message = new ErrorMessage(error);
- RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
- Map, MessageChannel> channelMappings =
+ RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
+ Map, MessageChannel> exceptionTypeChannelMap =
new HashMap, MessageChannel>();
- channelMappings.put(IllegalArgumentException.class, illegalArgumentChannel);
- channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel);
- resolver.setChannelMappings(channelMappings);
- RouterEndpoint endpoint = new RouterEndpoint(resolver);
- endpoint.setDefaultOutputChannel(defaultChannel);
- endpoint.onMessage(message);
+ exceptionTypeChannelMap.put(IllegalArgumentException.class, illegalArgumentChannel);
+ exceptionTypeChannelMap.put(MessageHandlingException.class, messageHandlingExceptionChannel);
+ router.setExceptionTypeChannelMap(exceptionTypeChannelMap);
+ router.setDefaultOutputChannel(defaultChannel);
+ router.onMessage(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/RouterTests.java
similarity index 50%
rename from org.springframework.integration/src/test/java/org/springframework/integration/router/RouterEndpointTests.java
rename to org.springframework.integration/src/test/java/org/springframework/integration/router/RouterTests.java
index 3894db1502..a322df2023 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/RouterTests.java
@@ -16,14 +16,17 @@
package org.springframework.integration.router;
+import static org.junit.Assert.assertEquals;
+
import java.util.Collections;
import java.util.List;
import org.junit.Test;
-import org.springframework.integration.channel.ChannelRegistry;
-import org.springframework.integration.channel.TestChannelRegistry;
+import org.springframework.context.support.GenericApplicationContext;
import org.springframework.integration.channel.MessageChannel;
+import org.springframework.integration.channel.QueueChannel;
+import org.springframework.integration.channel.TestChannelMapping;
import org.springframework.integration.message.Message;
import org.springframework.integration.message.MessageDeliveryException;
import org.springframework.integration.message.MessagingException;
@@ -32,143 +35,159 @@ import org.springframework.integration.message.StringMessage;
/**
* @author Mark Fisher
*/
-public class RouterEndpointTests {
+public class RouterTests {
@Test
public void nullChannelIgnoredByDefault() {
- ChannelResolver channelResolver = new ChannelResolver() {
+ AbstractMessageRouter router = new AbstractMessageRouter() {
public List resolveChannels(Message message) {
return null;
}
};
- RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
}
@Test(expected = MessageDeliveryException.class)
public void nullChannelThrowsExceptionWhenResolutionRequired() {
- ChannelResolver channelResolver = new ChannelResolver() {
+ AbstractMessageRouter router = new AbstractMessageRouter() {
public List resolveChannels(Message message) {
return null;
}
};
- RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
- endpoint.setResolutionRequired(true);
+ router.setResolutionRequired(true);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
}
@Test
public void emptyChannelListIgnoredByDefault() {
- ChannelResolver channelResolver = new ChannelResolver() {
+ AbstractMessageRouter router = new AbstractMessageRouter() {
public List resolveChannels(Message message) {
return Collections.emptyList();
}
};
- RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
}
@Test(expected = MessageDeliveryException.class)
public void emptyChannelListThrowsExceptionWhenResolutionRequired() {
- ChannelResolver channelResolver = new ChannelResolver() {
+ AbstractMessageRouter router = new AbstractMessageRouter() {
public List resolveChannels(Message message) {
return Collections.emptyList();
}
};
- RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
- endpoint.setResolutionRequired(true);
+ router.setResolutionRequired(true);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
}
@Test
public void nullChannelNameArrayIgnoredByDefault() {
- AbstractChannelNameResolver channelNameResolver = new AbstractChannelNameResolver() {
+ AbstractChannelMappingMessageRouter router = new AbstractChannelMappingMessageRouter() {
public String[] resolveChannelNames(Message message) {
return null;
}
};
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
- endpoint.setChannelRegistry(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ router.setChannelMapping(channelMapping);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
}
@Test(expected = MessageDeliveryException.class)
public void nullChannelNameArrayThrowsExceptionWhenResolutionRequired() {
- AbstractChannelNameResolver channelNameResolver = new AbstractChannelNameResolver() {
+ AbstractChannelMappingMessageRouter router = new AbstractChannelMappingMessageRouter() {
public String[] resolveChannelNames(Message message) {
return null;
}
};
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
- endpoint.setChannelRegistry(channelRegistry);
- endpoint.setResolutionRequired(true);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ router.setChannelMapping(channelMapping);
+ router.setResolutionRequired(true);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
}
@Test
public void emptyChannelNameArrayIgnoredByDefault() {
- AbstractChannelNameResolver channelNameResolver = new AbstractChannelNameResolver() {
+ AbstractChannelMappingMessageRouter router = new AbstractChannelMappingMessageRouter() {
public String[] resolveChannelNames(Message message) {
return new String[] {};
}
};
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
- endpoint.setChannelRegistry(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ router.setChannelMapping(channelMapping);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
}
@Test(expected = MessageDeliveryException.class)
public void emptyChannelNameArrayThrowsExceptionWhenResolutionRequired() {
- AbstractChannelNameResolver channelNameResolver = new AbstractChannelNameResolver() {
+ AbstractChannelMappingMessageRouter router = new AbstractChannelMappingMessageRouter() {
public String[] resolveChannelNames(Message message) {
return new String[] {};
}
};
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
- endpoint.setChannelRegistry(channelRegistry);
- endpoint.setResolutionRequired(true);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ router.setChannelMapping(channelMapping);
+ router.setResolutionRequired(true);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
}
@Test(expected = MessagingException.class)
- public void testChannelRegistryIsRequiredWhenUsingChannelNameResolverWithSingleChannelRouter() {
- AbstractSingleChannelNameResolver channelNameResolver = new AbstractSingleChannelNameResolver() {
+ public void channelMappingIsRequiredWhenResolvingChannelNamesWithSingleChannelRouter() {
+ AbstractSingleChannelNameRouter router = new AbstractSingleChannelNameRouter() {
public String resolveChannelName(Message message) {
return "notImportant";
}
};
- RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
- endpoint.onMessage(new StringMessage("this should fail"));
+ router.onMessage(new StringMessage("this should fail"));
}
@Test(expected = MessagingException.class)
- public void testChannelRegistryIsRequiredWhenUsingChannelNameResolverWithMultiChannelRouter() {
- AbstractChannelNameResolver channelNameResolver = new AbstractChannelNameResolver() {
+ public void channelMappingIsRequiredWhenResolvingChannelNamesWithMultiChannelRouter() {
+ AbstractChannelMappingMessageRouter router = new AbstractChannelMappingMessageRouter() {
public String[] resolveChannelNames(Message message) {
return new String[] { "notImportant" };
}
};
- RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
- endpoint.onMessage(new StringMessage("this should fail"));
+ router.onMessage(new StringMessage("this should fail"));
}
- @Test(expected = IllegalArgumentException.class)
- public void testChannelResolverMustNotBeNull() {
- AbstractSingleChannelNameResolver channelNameResolver = null;
- new RouterEndpoint(channelNameResolver);
+ @Test
+ public void beanFactoryWithSingleChannelRouter() {
+ AbstractSingleChannelNameRouter router = new AbstractSingleChannelNameRouter() {
+ public String resolveChannelName(Message message) {
+ return "testChannel";
+ }
+ };
+ QueueChannel testChannel = new QueueChannel();
+ GenericApplicationContext context = new GenericApplicationContext();
+ context.getBeanFactory().registerSingleton("testChannel", testChannel);
+ router.setBeanFactory(context);
+ router.onMessage(new StringMessage("test"));
+ Message reply = testChannel.receive(0);
+ assertEquals("test", reply.getPayload());
+ }
+
+ @Test
+ public void beanFactoryWithMultiChannelRouter() {
+ AbstractChannelMappingMessageRouter router = new AbstractChannelMappingMessageRouter() {
+ public String[] resolveChannelNames(Message message) {
+ return new String[] { "testChannel" };
+ }
+ };
+ QueueChannel testChannel = new QueueChannel();
+ GenericApplicationContext context = new GenericApplicationContext();
+ context.getBeanFactory().registerSingleton("testChannel", testChannel);
+ router.setBeanFactory(context);
+ router.onMessage(new StringMessage("test"));
+ Message reply = testChannel.receive(0);
+ assertEquals("test", reply.getPayload());
}
}
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 18aef6b780..6128ec0d4d 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
@@ -21,10 +21,9 @@ import static org.junit.Assert.assertNotNull;
import org.junit.Test;
-import org.springframework.integration.channel.ChannelRegistry;
-import org.springframework.integration.channel.TestChannelRegistry;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.QueueChannel;
+import org.springframework.integration.channel.TestChannelMapping;
import org.springframework.integration.message.Message;
import org.springframework.integration.message.MessagingException;
import org.springframework.integration.message.StringMessage;
@@ -37,14 +36,13 @@ public class SingleChannelRouterTests {
@Test
public void routeWithChannelResolver() {
final QueueChannel channel = new QueueChannel();
- AbstractSingleChannelResolver channelResolver = new AbstractSingleChannelResolver() {
+ AbstractSingleChannelRouter router = new AbstractSingleChannelRouter() {
public MessageChannel resolveChannel(Message message) {
return channel;
}
};
- RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
Message result = channel.receive(25);
assertNotNull(result);
assertEquals("test", result.getPayload());
@@ -52,19 +50,18 @@ public class SingleChannelRouterTests {
@Test
public void routeWithChannelNameResolver() {
- AbstractSingleChannelNameResolver channelNameResolver = new AbstractSingleChannelNameResolver() {
+ AbstractSingleChannelNameRouter router = new AbstractSingleChannelNameRouter() {
public String resolveChannelName(Message message) {
return "testChannel";
}
};
QueueChannel channel = new QueueChannel();
channel.setBeanName("testChannel");
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- channelRegistry.registerChannel(channel);
- RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
- endpoint.setChannelRegistry(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ channelMapping.addChannel(channel);
+ router.setChannelMapping(channelMapping);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
Message result = channel.receive(25);
assertNotNull(result);
assertEquals("test", result.getPayload());
@@ -72,28 +69,26 @@ public class SingleChannelRouterTests {
@Test
public void nullChannelResultIgnored() {
- AbstractSingleChannelResolver channelResolver = new AbstractSingleChannelResolver() {
+ AbstractSingleChannelRouter router = new AbstractSingleChannelRouter() {
public MessageChannel resolveChannel(Message message) {
return null;
}
};
- RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
}
@Test(expected = MessagingException.class)
public void channelNameResolutionFailure() {
- AbstractSingleChannelNameResolver channelNameResolver = new AbstractSingleChannelNameResolver() {
+ AbstractSingleChannelNameRouter router = new AbstractSingleChannelNameRouter() {
public String resolveChannelName(Message message) {
return "noSuchChannel";
}
};
- ChannelRegistry channelRegistry = new TestChannelRegistry();
- RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
- endpoint.setChannelRegistry(channelRegistry);
+ TestChannelMapping channelMapping = new TestChannelMapping();
+ router.setChannelMapping(channelMapping);
Message message = new StringMessage("test");
- endpoint.onMessage(message);
+ router.onMessage(message);
}
}