Refactored router hierarchy by adding an AbstractMessageRouter base class and removing the ChannelResolver delegation. The routers that return channel names now accept a ChannelMapping strategy. The BeanNameChannelMapping is typically used as a default. The mapping routers also support "prefix" and "suffix" properties.
This commit is contained in:
Mark Fisher
@@ -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<String, MessageChannel> channels = new HashMap<String, MessageChannel>();
|
||||
|
||||
public MessageChannel lookupChannel(String channelName) {
|
||||
return this.channels.get(channelName);
|
||||
}
|
||||
|
||||
public void registerChannel(MessageChannel channel) {
|
||||
this.channels.put(channel.getName(), channel);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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<String, MessageChannel> channels = new ConcurrentHashMap<String, MessageChannel>();
|
||||
|
||||
|
||||
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);
|
||||
@@ -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<String> testMessage1 = MessageBuilder.withPayload("bar")
|
||||
.setReturnAddress(replyChannel1).build();
|
||||
endpoint.onMessage(testMessage1);
|
||||
|
||||
@@ -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<String> message = new GenericMessage<String>("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<String> message = new GenericMessage<String>("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<String> 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<String>("testing"));
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
router.onMessage(new GenericMessage<String>("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<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> 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<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> 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<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> 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<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> 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<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> 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<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> 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<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> 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<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> 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<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> 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<MessageChannel> routePayload(String name) {
|
||||
List<MessageChannel> results = new ArrayList<MessageChannel>();
|
||||
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<MessageChannel> routeMessage(Message<?> message) {
|
||||
List<MessageChannel> results = new ArrayList<MessageChannel>();
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -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<MessageChannel> resolveChannels(Message<?> message) {
|
||||
List<MessageChannel> channels = new ArrayList<MessageChannel>();
|
||||
channels.add(channel1);
|
||||
channels.add(channel2);
|
||||
return channels;
|
||||
}
|
||||
};
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
Message<String> 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<String> 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<String> 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<String> message = new StringMessage("test");
|
||||
endpoint.onMessage(message);
|
||||
router.onMessage(message);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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<Class<?>, MessageChannel> channelMappings = new ConcurrentHashMap<Class<?>, MessageChannel>();
|
||||
channelMappings.put(String.class, stringChannel);
|
||||
channelMappings.put(Integer.class, integerChannel);
|
||||
PayloadTypeChannelResolver resolver = new PayloadTypeChannelResolver();
|
||||
resolver.setChannelMappings(channelMappings);
|
||||
Map<Class<?>, MessageChannel> payloadTypeChannelMap = new ConcurrentHashMap<Class<?>, MessageChannel>();
|
||||
payloadTypeChannelMap.put(String.class, stringChannel);
|
||||
payloadTypeChannelMap.put(Integer.class, integerChannel);
|
||||
PayloadTypeRouter router = new PayloadTypeRouter();
|
||||
router.setPayloadTypeChannelMap(payloadTypeChannelMap);
|
||||
Message<String> message1 = new StringMessage("test");
|
||||
Message<Integer> message2 = new GenericMessage<Integer>(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<Class<?>, MessageChannel> channelMappings = new ConcurrentHashMap<Class<?>, 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<Class<?>, MessageChannel> payloadTypeChannelMap = new ConcurrentHashMap<Class<?>, MessageChannel>();
|
||||
payloadTypeChannelMap.put(String.class, stringChannel);
|
||||
payloadTypeChannelMap.put(Integer.class, integerChannel);
|
||||
PayloadTypeRouter router = new PayloadTypeRouter();
|
||||
router.setPayloadTypeChannelMap(payloadTypeChannelMap);
|
||||
Message<String> message1 = new StringMessage("test");
|
||||
Message<Integer> message2 = new GenericMessage<Integer>(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<Class<?>, MessageChannel> channelMappings = new ConcurrentHashMap<Class<?>, MessageChannel>();
|
||||
channelMappings.put(String.class, stringChannel);
|
||||
PayloadTypeChannelResolver resolver = new PayloadTypeChannelResolver();
|
||||
resolver.setChannelMappings(channelMappings);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setDefaultOutputChannel(defaultChannel);
|
||||
Map<Class<?>, MessageChannel> payloadTypeChannelMap = new ConcurrentHashMap<Class<?>, MessageChannel>();
|
||||
payloadTypeChannelMap.put(String.class, stringChannel);
|
||||
PayloadTypeRouter router = new PayloadTypeRouter();
|
||||
router.setPayloadTypeChannelMap(payloadTypeChannelMap);
|
||||
router.setDefaultOutputChannel(defaultChannel);
|
||||
Message<String> message1 = new StringMessage("test");
|
||||
Message<Integer> message2 = new GenericMessage<Integer>(123);
|
||||
endpoint.onMessage(message1);
|
||||
endpoint.onMessage(message2);
|
||||
router.onMessage(message1);
|
||||
router.onMessage(message2);
|
||||
Message<?> result1 = stringChannel.receive(25);
|
||||
assertNotNull(result1);
|
||||
assertEquals("test", result1.getPayload());
|
||||
|
||||
@@ -45,11 +45,11 @@ public class RecipientListRouterTests {
|
||||
List<MessageChannel> channels = new ArrayList<MessageChannel>();
|
||||
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<String> message = new StringMessage("test");
|
||||
Collection<MessageChannel> resolved = resolver.resolveChannels(message);
|
||||
Collection<MessageChannel> resolved = router.resolveChannels(message);
|
||||
assertEquals(2, resolved.size());
|
||||
assertTrue(resolved.contains(channel1));
|
||||
assertTrue(resolved.contains(channel2));
|
||||
@@ -62,12 +62,11 @@ public class RecipientListRouterTests {
|
||||
List<MessageChannel> channels = new ArrayList<MessageChannel>();
|
||||
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<String> 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<String> 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<MessageChannel> channels = new ArrayList<MessageChannel>();
|
||||
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();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
Map<Class<? extends Throwable>, MessageChannel> exceptionTypeChannelMap =
|
||||
new HashMap<Class<? extends Throwable>, 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<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
Map<Class<? extends Throwable>, MessageChannel> exceptionTypeChannelMap =
|
||||
new HashMap<Class<? extends Throwable>, 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<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
Map<Class<? extends Throwable>, MessageChannel> exceptionTypeChannelMap =
|
||||
new HashMap<Class<? extends Throwable>, 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<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
Map<Class<? extends Throwable>, MessageChannel> exceptionTypeChannelMap =
|
||||
new HashMap<Class<? extends Throwable>, 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<Exception>(error);
|
||||
RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
|
||||
Map<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
Map<Class<? extends Throwable>, MessageChannel> exceptionTypeChannelMap =
|
||||
new HashMap<Class<? extends Throwable>, 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<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
Map<Class<? extends Throwable>, MessageChannel> exceptionTypeChannelMap =
|
||||
new HashMap<Class<? extends Throwable>, 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));
|
||||
|
||||
@@ -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<MessageChannel> resolveChannels(Message<?> message) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
Message<String> 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<MessageChannel> resolveChannels(Message<?> message) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
endpoint.setResolutionRequired(true);
|
||||
router.setResolutionRequired(true);
|
||||
Message<String> message = new StringMessage("test");
|
||||
endpoint.onMessage(message);
|
||||
router.onMessage(message);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void emptyChannelListIgnoredByDefault() {
|
||||
ChannelResolver channelResolver = new ChannelResolver() {
|
||||
AbstractMessageRouter router = new AbstractMessageRouter() {
|
||||
public List<MessageChannel> resolveChannels(Message<?> message) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
};
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
Message<String> 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<MessageChannel> resolveChannels(Message<?> message) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
};
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
endpoint.setResolutionRequired(true);
|
||||
router.setResolutionRequired(true);
|
||||
Message<String> 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<String> 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<String> 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<String> 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<String> 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());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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<String> 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<String> 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<String> 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<String> message = new StringMessage("test");
|
||||
endpoint.onMessage(message);
|
||||
router.onMessage(message);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user