RouterEndpoint now delegates directly to a single ChannelResolver strategy. This removes the extra level of indirection that was provided by the Router interface. Also, instead of providing multiple ChannelResolver strategy interfaces, the name-resolving and single-channel implementations are now available as abstract base classes.
This commit is contained in:
Mark Fisher
@@ -53,10 +53,11 @@ public class MethodInvokingRouterTests {
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
|
||||
Method routingMethod = testBean.getClass().getMethod("routePayload", String.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message = new GenericMessage<String>("bar");
|
||||
assertTrue(router.route(message));
|
||||
assertTrue(endpoint.send(message));
|
||||
Message<?> replyMessage = barChannel.receive();
|
||||
assertNotNull(replyMessage);
|
||||
assertEquals(message, replyMessage);
|
||||
@@ -69,10 +70,11 @@ public class MethodInvokingRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload");
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload");
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message = new GenericMessage<String>("bar");
|
||||
assertTrue(router.route(message));
|
||||
assertTrue(endpoint.send(message));
|
||||
Message<?> replyMessage = barChannel.receive();
|
||||
assertNotNull(replyMessage);
|
||||
assertEquals(message, replyMessage);
|
||||
@@ -89,11 +91,12 @@ public class MethodInvokingRouterTests {
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
|
||||
Method routingMethod = testBean.getClass().getMethod("routeByHeader", String.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message = MessageBuilder.fromPayload("bar")
|
||||
.setHeader("targetChannel", "foo").build();
|
||||
assertTrue(router.route(message));
|
||||
assertTrue(endpoint.send(message));
|
||||
Message<?> fooReply = fooChannel.receive(0);
|
||||
Message<?> barReply = barChannel.receive(0);
|
||||
assertNotNull(fooReply);
|
||||
@@ -105,26 +108,29 @@ public class MethodInvokingRouterTests {
|
||||
public void failsWhenRequiredHeaderIsNotProvided() throws Exception {
|
||||
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
|
||||
Method routingMethod = testBean.getClass().getMethod("routeByHeader", String.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
router.route(new GenericMessage<String>("testing"));
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.send(new GenericMessage<String>("testing"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void channelNameResolutionByMessageConfiguredByMethodReference() throws Exception {
|
||||
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
|
||||
Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
this.doTestChannelNameResolutionByMessage(router);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestChannelNameResolutionByMessage(endpoint);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void channelNameResolutionByMessageConfiguredByMethodName() {
|
||||
SingleChannelNameRoutingTestBean testBean = new SingleChannelNameRoutingTestBean();
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage");
|
||||
this.doTestChannelNameResolutionByMessage(router);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage");
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestChannelNameResolutionByMessage(endpoint);
|
||||
}
|
||||
|
||||
private void doTestChannelNameResolutionByMessage(MethodInvokingRouter router) {
|
||||
private void doTestChannelNameResolutionByMessage(RouterEndpoint endpoint) {
|
||||
QueueChannel fooChannel = new QueueChannel();
|
||||
QueueChannel barChannel = new QueueChannel();
|
||||
fooChannel.setBeanName("foo-channel");
|
||||
@@ -132,19 +138,19 @@ public class MethodInvokingRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
channelRegistry.registerChannel(fooChannel);
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> badMessage = new StringMessage("bad");
|
||||
assertTrue(router.route(fooMessage));
|
||||
assertTrue(endpoint.send(fooMessage));
|
||||
Message<?> result1 = fooChannel.receive(0);
|
||||
assertNotNull(result1);
|
||||
assertEquals("foo", result1.getPayload());
|
||||
assertTrue(router.route(barMessage));
|
||||
assertTrue(endpoint.send(barMessage));
|
||||
Message<?> result2 = barChannel.receive(0);
|
||||
assertNotNull(result2);
|
||||
assertEquals("bar", result2.getPayload());
|
||||
assertFalse(router.route(badMessage));
|
||||
assertFalse(endpoint.send(badMessage));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -152,19 +158,21 @@ public class MethodInvokingRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry);
|
||||
Method routingMethod = testBean.getClass().getMethod("routePayload", String.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
this.doTestChannelInstanceResolutionByPayload(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestChannelInstanceResolutionByPayload(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void channelInstanceResolutionByPayloadConfiguredByMethodName() {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload");
|
||||
this.doTestChannelInstanceResolutionByPayload(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload");
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestChannelInstanceResolutionByPayload(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
private void doTestChannelInstanceResolutionByPayload(MethodInvokingRouter router, ChannelRegistry channelRegistry) {
|
||||
private void doTestChannelInstanceResolutionByPayload(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
|
||||
Message<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> badMessage = new StringMessage("bad");
|
||||
@@ -174,16 +182,16 @@ public class MethodInvokingRouterTests {
|
||||
barChannel.setBeanName("bar-channel");
|
||||
channelRegistry.registerChannel(fooChannel);
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
assertTrue(router.route(fooMessage));
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
assertTrue(endpoint.send(fooMessage));
|
||||
Message<?> result1 = fooChannel.receive(0);
|
||||
assertNotNull(result1);
|
||||
assertEquals("foo", result1.getPayload());
|
||||
assertTrue(router.route(barMessage));
|
||||
assertTrue(endpoint.send(barMessage));
|
||||
Message<?> result2 = barChannel.receive(0);
|
||||
assertNotNull(result2);
|
||||
assertEquals("bar", result2.getPayload());
|
||||
assertFalse(router.route(badMessage));
|
||||
assertFalse(endpoint.send(badMessage));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -191,38 +199,40 @@ public class MethodInvokingRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry);
|
||||
Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
this.doTestChannelInstanceResolutionByMessage(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestChannelInstanceResolutionByMessage(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void channelInstanceResolutionByMessageConfiguredByMethodName() {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
SingleChannelInstanceRoutingTestBean testBean = new SingleChannelInstanceRoutingTestBean(channelRegistry);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage");
|
||||
this.doTestChannelInstanceResolutionByMessage(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage");
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestChannelInstanceResolutionByMessage(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
private void doTestChannelInstanceResolutionByMessage(MethodInvokingRouter router, ChannelRegistry channelRegistry) {
|
||||
private void doTestChannelInstanceResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
|
||||
QueueChannel fooChannel = new QueueChannel();
|
||||
QueueChannel barChannel = new QueueChannel();
|
||||
fooChannel.setBeanName("foo-channel");
|
||||
barChannel.setBeanName("bar-channel");
|
||||
channelRegistry.registerChannel(fooChannel);
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> badMessage = new StringMessage("bad");
|
||||
assertTrue(router.route(fooMessage));
|
||||
assertTrue(endpoint.send(fooMessage));
|
||||
Message<?> result1 = fooChannel.receive(0);
|
||||
assertNotNull(result1);
|
||||
assertEquals("foo", result1.getPayload());
|
||||
assertTrue(router.route(barMessage));
|
||||
assertTrue(endpoint.send(barMessage));
|
||||
Message<?> result2 = barChannel.receive(0);
|
||||
assertNotNull(result2);
|
||||
assertEquals("bar", result2.getPayload());
|
||||
assertFalse(router.route(badMessage));
|
||||
assertFalse(endpoint.send(badMessage));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -230,44 +240,46 @@ public class MethodInvokingRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
|
||||
Method routingMethod = testBean.getClass().getMethod("routePayload", String.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
this.doTestMultiChannelNameResolutionByPayload(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelNameResolutionByPayload(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void multiChannelNameResolutionByPayloadConfiguredByMethodName() {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload");
|
||||
this.doTestMultiChannelNameResolutionByPayload(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload");
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelNameResolutionByPayload(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
private void doTestMultiChannelNameResolutionByPayload(MethodInvokingRouter router, ChannelRegistry channelRegistry) {
|
||||
private void doTestMultiChannelNameResolutionByPayload(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
|
||||
QueueChannel fooChannel = new QueueChannel();
|
||||
QueueChannel barChannel = new QueueChannel();
|
||||
fooChannel.setBeanName("foo-channel");
|
||||
barChannel.setBeanName("bar-channel");
|
||||
channelRegistry.registerChannel(fooChannel);
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> badMessage = new StringMessage("bad");
|
||||
assertTrue(router.route(fooMessage));
|
||||
assertTrue(endpoint.send(fooMessage));
|
||||
Message<?> result1a = fooChannel.receive(0);
|
||||
Message<?> result1b = barChannel.receive(0);
|
||||
assertNotNull(result1a);
|
||||
assertEquals("foo", result1a.getPayload());
|
||||
assertNotNull(result1b);
|
||||
assertEquals("foo", result1b.getPayload());
|
||||
assertTrue(router.route(barMessage));
|
||||
assertTrue(endpoint.send(barMessage));
|
||||
Message<?> result2a = fooChannel.receive(0);
|
||||
Message<?> result2b = barChannel.receive(0);
|
||||
assertNotNull(result2a);
|
||||
assertEquals("bar", result2a.getPayload());
|
||||
assertNotNull(result2b);
|
||||
assertEquals("bar", result2b.getPayload());
|
||||
assertFalse(router.route(badMessage));
|
||||
assertFalse(endpoint.send(badMessage));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -275,44 +287,46 @@ public class MethodInvokingRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
|
||||
Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
this.doTestMultiChannelNameResolutionByMessage(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelNameResolutionByMessage(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void multiChannelNameResolutionByMessageConfiguredByMethodName() throws Exception {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage");
|
||||
this.doTestMultiChannelNameResolutionByMessage(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage");
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelNameResolutionByMessage(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
private void doTestMultiChannelNameResolutionByMessage(MethodInvokingRouter router, ChannelRegistry channelRegistry) {
|
||||
private void doTestMultiChannelNameResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
|
||||
QueueChannel fooChannel = new QueueChannel();
|
||||
QueueChannel barChannel = new QueueChannel();
|
||||
fooChannel.setBeanName("foo-channel");
|
||||
barChannel.setBeanName("bar-channel");
|
||||
channelRegistry.registerChannel(fooChannel);
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> badMessage = new StringMessage("bad");
|
||||
assertTrue(router.route(fooMessage));
|
||||
assertTrue(endpoint.send(fooMessage));
|
||||
Message<?> result1a = fooChannel.receive(0);
|
||||
assertNotNull(result1a);
|
||||
assertEquals("foo", result1a.getPayload());
|
||||
Message<?> result1b = barChannel.receive(0);
|
||||
assertNotNull(result1b);
|
||||
assertEquals("foo", result1b.getPayload());
|
||||
assertTrue(router.route(barMessage));
|
||||
assertTrue(endpoint.send(barMessage));
|
||||
Message<?> result2a = fooChannel.receive(0);
|
||||
assertNotNull(result2a);
|
||||
assertEquals("bar", result2a.getPayload());
|
||||
Message<?> result2b = barChannel.receive(0);
|
||||
assertNotNull(result2b);
|
||||
assertEquals("bar", result2b.getPayload());
|
||||
assertFalse(router.route(badMessage));
|
||||
assertFalse(endpoint.send(badMessage));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -320,44 +334,46 @@ public class MethodInvokingRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
|
||||
Method routingMethod = testBean.getClass().getMethod("routeMessageToArray", Message.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
this.doTestMultiChannelNameArrayResolutionByMessage(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelNameArrayResolutionByMessage(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void multiChannelNameArrayResolutionByMessageConfiguredByMethodName() {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelNameRoutingTestBean testBean = new MultiChannelNameRoutingTestBean();
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessageToArray");
|
||||
this.doTestMultiChannelNameArrayResolutionByMessage(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessageToArray");
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelNameArrayResolutionByMessage(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
private void doTestMultiChannelNameArrayResolutionByMessage(MethodInvokingRouter router, ChannelRegistry channelRegistry) {
|
||||
private void doTestMultiChannelNameArrayResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
|
||||
QueueChannel fooChannel = new QueueChannel();
|
||||
QueueChannel barChannel = new QueueChannel();
|
||||
fooChannel.setBeanName("foo-channel");
|
||||
barChannel.setBeanName("bar-channel");
|
||||
channelRegistry.registerChannel(fooChannel);
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> badMessage = new StringMessage("bad");
|
||||
assertTrue(router.route(fooMessage));
|
||||
assertTrue(endpoint.send(fooMessage));
|
||||
Message<?> result1a = fooChannel.receive(0);
|
||||
assertNotNull(result1a);
|
||||
assertEquals("foo", result1a.getPayload());
|
||||
Message<?> result1b = barChannel.receive(0);
|
||||
assertNotNull(result1b);
|
||||
assertEquals("foo", result1b.getPayload());
|
||||
assertTrue(router.route(barMessage));
|
||||
assertTrue(endpoint.send(barMessage));
|
||||
Message<?> result2a = fooChannel.receive(0);
|
||||
assertNotNull(result2a);
|
||||
assertEquals("bar", result2a.getPayload());
|
||||
Message<?> result2b = barChannel.receive(0);
|
||||
assertNotNull(result2b);
|
||||
assertEquals("bar", result2b.getPayload());
|
||||
assertFalse(router.route(badMessage));
|
||||
assertFalse(endpoint.send(badMessage));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -365,44 +381,46 @@ public class MethodInvokingRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
|
||||
Method routingMethod = testBean.getClass().getMethod("routePayload", String.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
this.doTestMultiChannelListResolutionByPayload(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelListResolutionByPayload(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void multiChannelListResolutionByPayloadConfiguredByMethodName() {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routePayload");
|
||||
this.doTestMultiChannelListResolutionByPayload(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routePayload");
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelListResolutionByPayload(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
private void doTestMultiChannelListResolutionByPayload(MethodInvokingRouter router, ChannelRegistry channelRegistry) {
|
||||
private void doTestMultiChannelListResolutionByPayload(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
|
||||
QueueChannel fooChannel = new QueueChannel();
|
||||
QueueChannel barChannel = new QueueChannel();
|
||||
fooChannel.setBeanName("foo-channel");
|
||||
barChannel.setBeanName("bar-channel");
|
||||
channelRegistry.registerChannel(fooChannel);
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> badMessage = new StringMessage("bad");
|
||||
assertTrue(router.route(fooMessage));
|
||||
assertTrue(endpoint.send(fooMessage));
|
||||
Message<?> result1a = fooChannel.receive(0);
|
||||
Message<?> result1b = barChannel.receive(0);
|
||||
assertNotNull(result1a);
|
||||
assertEquals("foo", result1a.getPayload());
|
||||
assertNotNull(result1b);
|
||||
assertEquals("foo", result1b.getPayload());
|
||||
assertTrue(router.route(barMessage));
|
||||
assertTrue(endpoint.send(barMessage));
|
||||
Message<?> result2a = fooChannel.receive(0);
|
||||
Message<?> result2b = barChannel.receive(0);
|
||||
assertNotNull(result2a);
|
||||
assertEquals("bar", result2a.getPayload());
|
||||
assertNotNull(result2b);
|
||||
assertEquals("bar", result2b.getPayload());
|
||||
assertFalse(router.route(badMessage));
|
||||
assertFalse(endpoint.send(badMessage));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -410,44 +428,46 @@ public class MethodInvokingRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
|
||||
Method routingMethod = testBean.getClass().getMethod("routeMessage", Message.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
this.doTestMultiChannelListResolutionByMessage(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelListResolutionByMessage(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void multiChannelListResolutionByMessageConfiguredByMethodName() {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessage");
|
||||
this.doTestMultiChannelListResolutionByMessage(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessage");
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelListResolutionByMessage(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
private void doTestMultiChannelListResolutionByMessage(MethodInvokingRouter router, ChannelRegistry channelRegistry) {
|
||||
private void doTestMultiChannelListResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
|
||||
QueueChannel fooChannel = new QueueChannel();
|
||||
QueueChannel barChannel = new QueueChannel();
|
||||
fooChannel.setBeanName("foo-channel");
|
||||
barChannel.setBeanName("bar-channel");
|
||||
channelRegistry.registerChannel(fooChannel);
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> badMessage = new StringMessage("bad");
|
||||
assertTrue(router.route(fooMessage));
|
||||
assertTrue(endpoint.send(fooMessage));
|
||||
Message<?> result1a = fooChannel.receive(0);
|
||||
Message<?> result1b = barChannel.receive(0);
|
||||
assertNotNull(result1a);
|
||||
assertEquals("foo", result1a.getPayload());
|
||||
assertNotNull(result1b);
|
||||
assertEquals("foo", result1b.getPayload());
|
||||
assertTrue(router.route(barMessage));
|
||||
assertTrue(endpoint.send(barMessage));
|
||||
Message<?> result2a = fooChannel.receive(0);
|
||||
Message<?> result2b = barChannel.receive(0);
|
||||
assertNotNull(result2a);
|
||||
assertEquals("bar", result2a.getPayload());
|
||||
assertNotNull(result2b);
|
||||
assertEquals("bar", result2b.getPayload());
|
||||
assertFalse(router.route(badMessage));
|
||||
assertFalse(endpoint.send(badMessage));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -455,44 +475,46 @@ public class MethodInvokingRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
|
||||
Method routingMethod = testBean.getClass().getMethod("routeMessageToArray", Message.class);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, routingMethod);
|
||||
this.doTestMultiChannelArrayResolutionByMessage(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, routingMethod);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelArrayResolutionByMessage(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void multiChannelArrayResolutionByMessageConfiguredByMethodName() {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelInstanceRoutingTestBean testBean = new MultiChannelInstanceRoutingTestBean(channelRegistry);
|
||||
MethodInvokingRouter router = new MethodInvokingRouter(testBean, "routeMessageToArray");
|
||||
this.doTestMultiChannelArrayResolutionByMessage(router, channelRegistry);
|
||||
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(testBean, "routeMessageToArray");
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
this.doTestMultiChannelArrayResolutionByMessage(endpoint, channelRegistry);
|
||||
}
|
||||
|
||||
private void doTestMultiChannelArrayResolutionByMessage(MethodInvokingRouter router, ChannelRegistry channelRegistry) {
|
||||
private void doTestMultiChannelArrayResolutionByMessage(RouterEndpoint endpoint, ChannelRegistry channelRegistry) {
|
||||
QueueChannel fooChannel = new QueueChannel();
|
||||
QueueChannel barChannel = new QueueChannel();
|
||||
fooChannel.setBeanName("foo-channel");
|
||||
barChannel.setBeanName("bar-channel");
|
||||
channelRegistry.registerChannel(fooChannel);
|
||||
channelRegistry.registerChannel(barChannel);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> fooMessage = new StringMessage("foo");
|
||||
Message<String> barMessage = new StringMessage("bar");
|
||||
Message<String> badMessage = new StringMessage("bad");
|
||||
assertTrue(router.route(fooMessage));
|
||||
assertTrue(endpoint.send(fooMessage));
|
||||
Message<?> result1a = fooChannel.receive(0);
|
||||
Message<?> result1b = barChannel.receive(0);
|
||||
assertNotNull(result1a);
|
||||
assertEquals("foo", result1a.getPayload());
|
||||
assertNotNull(result1b);
|
||||
assertEquals("foo", result1b.getPayload());
|
||||
assertTrue(router.route(barMessage));
|
||||
assertTrue(endpoint.send(barMessage));
|
||||
Message<?> result2a = fooChannel.receive(0);
|
||||
Message<?> result2b = barChannel.receive(0);
|
||||
assertNotNull(result2a);
|
||||
assertEquals("bar", result2a.getPayload());
|
||||
assertNotNull(result2b);
|
||||
assertEquals("bar", result2b.getPayload());
|
||||
assertFalse(router.route(badMessage));
|
||||
assertFalse(endpoint.send(badMessage));
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -24,13 +24,12 @@ import java.util.List;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import org.springframework.integration.ConfigurationException;
|
||||
import org.springframework.integration.channel.ChannelRegistry;
|
||||
import org.springframework.integration.channel.DefaultChannelRegistry;
|
||||
import org.springframework.integration.channel.MessageChannel;
|
||||
import org.springframework.integration.channel.QueueChannel;
|
||||
import org.springframework.integration.message.Message;
|
||||
import org.springframework.integration.message.MessageDeliveryException;
|
||||
import org.springframework.integration.message.MessagingException;
|
||||
import org.springframework.integration.message.StringMessage;
|
||||
|
||||
/**
|
||||
@@ -42,19 +41,17 @@ public class MultiChannelRouterTests {
|
||||
public void routeWithChannelResolver() {
|
||||
final QueueChannel channel1 = new QueueChannel();
|
||||
final QueueChannel channel2 = new QueueChannel();
|
||||
MultiChannelResolver channelResolver = new MultiChannelResolver() {
|
||||
public List<MessageChannel> resolve(Message<?> message) {
|
||||
AbstractChannelResolver channelResolver = new AbstractChannelResolver() {
|
||||
public List<MessageChannel> resolveChannels(Message<?> message) {
|
||||
List<MessageChannel> channels = new ArrayList<MessageChannel>();
|
||||
channels.add(channel1);
|
||||
channels.add(channel2);
|
||||
return channels;
|
||||
}
|
||||
};
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelResolver(channelResolver);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
Message<String> message = new StringMessage("test");
|
||||
router.route(message);
|
||||
endpoint.send(message);
|
||||
Message<?> result1 = channel1.receive(25);
|
||||
assertNotNull(result1);
|
||||
assertEquals("test", result1.getPayload());
|
||||
@@ -65,8 +62,8 @@ public class MultiChannelRouterTests {
|
||||
|
||||
@Test
|
||||
public void routeWithChannelNameResolver() {
|
||||
MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() {
|
||||
public String[] resolve(Message<?> message) {
|
||||
AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() {
|
||||
public String[] resolveChannelNames(Message<?> message) {
|
||||
return new String[] {"channel1", "channel2"};
|
||||
}
|
||||
};
|
||||
@@ -77,12 +74,10 @@ public class MultiChannelRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
channelRegistry.registerChannel(channel1);
|
||||
channelRegistry.registerChannel(channel2);
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message = new StringMessage("test");
|
||||
router.route(message);
|
||||
endpoint.send(message);
|
||||
Message<?> result1 = channel1.receive(25);
|
||||
assertNotNull(result1);
|
||||
assertEquals("test", result1.getPayload());
|
||||
@@ -91,46 +86,30 @@ public class MultiChannelRouterTests {
|
||||
assertEquals("test", result2.getPayload());
|
||||
}
|
||||
|
||||
@Test(expected = ConfigurationException.class)
|
||||
public void configuringBothChannelResolverAndChannelNameResolverIsNotAllowed() {
|
||||
MultiChannelResolver channelResolver = new MultiChannelResolver() {
|
||||
public List<MessageChannel> resolve(Message<?> message) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() {
|
||||
public String[] resolve(Message<?> message) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelResolver(channelResolver);
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
router.afterPropertiesSet();
|
||||
}
|
||||
|
||||
@Test(expected = MessageDeliveryException.class)
|
||||
@Test(expected = MessagingException.class)
|
||||
public void channelNameLookupFailure() {
|
||||
MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() {
|
||||
public String[] resolve(Message<?> message) {
|
||||
AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() {
|
||||
public String[] resolveChannelNames(Message<?> message) {
|
||||
return new String[] {"noSuchChannel"};
|
||||
}
|
||||
};
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message = new StringMessage("test");
|
||||
router.route(message);
|
||||
endpoint.send(message);
|
||||
}
|
||||
|
||||
@Test(expected = ConfigurationException.class)
|
||||
public void channelResolverIsRequired() {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
router.afterPropertiesSet();
|
||||
@Test(expected = MessagingException.class)
|
||||
public void channelRegistryNotAvailable() {
|
||||
AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() {
|
||||
public String[] resolveChannelNames(Message<?> message) {
|
||||
return new String[] {"noSuchChannel"};
|
||||
}
|
||||
};
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
|
||||
Message<String> message = new StringMessage("test");
|
||||
endpoint.send(message);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -24,6 +24,7 @@ import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import org.springframework.integration.channel.DefaultChannelRegistry;
|
||||
import org.springframework.integration.channel.MessageChannel;
|
||||
import org.springframework.integration.channel.QueueChannel;
|
||||
import org.springframework.integration.message.GenericMessage;
|
||||
@@ -36,41 +37,67 @@ import org.springframework.integration.message.StringMessage;
|
||||
public class PayloadTypeRouterTests {
|
||||
|
||||
@Test
|
||||
public void testRoutingByPayloadType() {
|
||||
public void resolveByPayloadType() {
|
||||
QueueChannel stringChannel = new QueueChannel();
|
||||
QueueChannel integerChannel = new QueueChannel();
|
||||
Map<Class<?>, MessageChannel> channelMappings = new ConcurrentHashMap<Class<?>, MessageChannel>();
|
||||
channelMappings.put(String.class, stringChannel);
|
||||
channelMappings.put(Integer.class, integerChannel);
|
||||
PayloadTypeRouter router = new PayloadTypeRouter();
|
||||
router.setChannelMappings(channelMappings);
|
||||
router.afterPropertiesSet();
|
||||
PayloadTypeChannelResolver resolver = new PayloadTypeChannelResolver();
|
||||
resolver.setChannelMappings(channelMappings);
|
||||
Message<String> message1 = new StringMessage("test");
|
||||
Message<Integer> message2 = new GenericMessage<Integer>(123);
|
||||
router.route(message1);
|
||||
router.route(message2);
|
||||
Message<?> result1 = stringChannel.receive(25);
|
||||
assertNotNull(result1);
|
||||
assertEquals("test", result1.getPayload());
|
||||
Message<?> result2 = integerChannel.receive(25);
|
||||
assertNotNull(result2);
|
||||
assertEquals(123, result2.getPayload());
|
||||
MessageChannel result1 = resolver.resolveChannel(message1);
|
||||
MessageChannel result2 = resolver.resolveChannel(message2);
|
||||
assertEquals(stringChannel, result1);
|
||||
assertEquals(integerChannel, result2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRoutingToDefaultChannelWhenNoTypeMatches() {
|
||||
public void resolveByPayloadTypeWithRouterEndpoint() {
|
||||
QueueChannel stringChannel = new QueueChannel();
|
||||
QueueChannel defaultChannel = new QueueChannel();
|
||||
QueueChannel integerChannel = new QueueChannel();
|
||||
stringChannel.setBeanName("stringChannel");
|
||||
integerChannel.setBeanName("integerChannel");
|
||||
Map<Class<?>, MessageChannel> channelMappings = new ConcurrentHashMap<Class<?>, MessageChannel>();
|
||||
channelMappings.put(String.class, stringChannel);
|
||||
PayloadTypeRouter router = new PayloadTypeRouter();
|
||||
router.setChannelMappings(channelMappings);
|
||||
router.setDefaultChannel(defaultChannel);
|
||||
router.afterPropertiesSet();
|
||||
channelMappings.put(Integer.class, integerChannel);
|
||||
DefaultChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
channelRegistry.registerChannel(stringChannel);
|
||||
channelRegistry.registerChannel(integerChannel);
|
||||
PayloadTypeChannelResolver resolver = new PayloadTypeChannelResolver();
|
||||
resolver.setChannelMappings(channelMappings);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message1 = new StringMessage("test");
|
||||
Message<Integer> message2 = new GenericMessage<Integer>(123);
|
||||
router.route(message1);
|
||||
router.route(message2);
|
||||
endpoint.send(message1);
|
||||
endpoint.send(message2);
|
||||
Message<?> reply1 = stringChannel.receive(0);
|
||||
Message<?> reply2 = integerChannel.receive(0);
|
||||
assertEquals("test", reply1.getPayload());
|
||||
assertEquals(123, reply2.getPayload());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void routingToDefaultChannelWhenNoTypeMatches() {
|
||||
QueueChannel stringChannel = new QueueChannel();
|
||||
stringChannel.setBeanName("stringChannel");
|
||||
QueueChannel defaultChannel = new QueueChannel();
|
||||
defaultChannel.setBeanName("defaultChannel");
|
||||
DefaultChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
channelRegistry.registerChannel(stringChannel);
|
||||
channelRegistry.registerChannel(defaultChannel);
|
||||
Map<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);
|
||||
Message<String> message1 = new StringMessage("test");
|
||||
Message<Integer> message2 = new GenericMessage<Integer>(123);
|
||||
endpoint.send(message1);
|
||||
endpoint.send(message2);
|
||||
Message<?> result1 = stringChannel.receive(25);
|
||||
assertNotNull(result1);
|
||||
assertEquals("test", result1.getPayload());
|
||||
|
||||
@@ -19,8 +19,10 @@ package org.springframework.integration.router;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.Test;
|
||||
@@ -38,6 +40,23 @@ import org.springframework.integration.message.StringMessage;
|
||||
*/
|
||||
public class RecipientListRouterTests {
|
||||
|
||||
@Test
|
||||
public void resolveWithChannelList() {
|
||||
QueueChannel channel1 = new QueueChannel();
|
||||
QueueChannel channel2 = new QueueChannel();
|
||||
List<MessageChannel> channels = new ArrayList<MessageChannel>();
|
||||
channels.add(channel1);
|
||||
channels.add(channel2);
|
||||
RecipientListChannelResolver resolver = new RecipientListChannelResolver();
|
||||
resolver.setChannels(channels);
|
||||
resolver.afterPropertiesSet();
|
||||
Message<String> message = new StringMessage("test");
|
||||
Collection<MessageChannel> resolved = resolver.resolveChannels(message);
|
||||
assertEquals(2, resolved.size());
|
||||
assertTrue(resolved.contains(channel1));
|
||||
assertTrue(resolved.contains(channel2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void routeWithChannelList() {
|
||||
QueueChannel channel1 = new QueueChannel();
|
||||
@@ -45,11 +64,12 @@ public class RecipientListRouterTests {
|
||||
List<MessageChannel> channels = new ArrayList<MessageChannel>();
|
||||
channels.add(channel1);
|
||||
channels.add(channel2);
|
||||
RecipientListRouter router = new RecipientListRouter();
|
||||
router.setChannels(channels);
|
||||
router.afterPropertiesSet();
|
||||
RecipientListChannelResolver resolver = new RecipientListChannelResolver();
|
||||
resolver.setChannels(channels);
|
||||
resolver.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
Message<String> message = new StringMessage("test");
|
||||
router.route(message);
|
||||
endpoint.send(message);
|
||||
Message<?> result1 = channel1.receive(25);
|
||||
assertNotNull(result1);
|
||||
assertEquals("test", result1.getPayload());
|
||||
@@ -67,12 +87,13 @@ public class RecipientListRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
channelRegistry.registerChannel(channel1);
|
||||
channelRegistry.registerChannel(channel2);
|
||||
RecipientListRouter router = new RecipientListRouter();
|
||||
router.setChannelNames(new String[] {"channel1", "channel2"});
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
router.afterPropertiesSet();
|
||||
RecipientListChannelResolver resolver = new RecipientListChannelResolver();
|
||||
resolver.setChannelNames(new String[] {"channel1", "channel2"});
|
||||
resolver.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message = new StringMessage("test");
|
||||
router.route(message);
|
||||
endpoint.send(message);
|
||||
Message<?> result1 = channel1.receive(25);
|
||||
assertNotNull(result1);
|
||||
assertEquals("test", result1.getPayload());
|
||||
@@ -90,12 +111,13 @@ public class RecipientListRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
channelRegistry.registerChannel(channel1);
|
||||
channelRegistry.registerChannel(channel2);
|
||||
RecipientListRouter router = new RecipientListRouter();
|
||||
router.setChannelNames(new String[] {"channel1"});
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
router.afterPropertiesSet();
|
||||
RecipientListChannelResolver resolver = new RecipientListChannelResolver();
|
||||
resolver.setChannelNames(new String[] {"channel1"});
|
||||
resolver.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message = new StringMessage("test");
|
||||
router.route(message);
|
||||
endpoint.send(message);
|
||||
Message<?> result1 = channel1.receive(25);
|
||||
assertNotNull(result1);
|
||||
assertEquals("test", result1.getPayload());
|
||||
@@ -115,11 +137,11 @@ public class RecipientListRouterTests {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
channelRegistry.registerChannel(channel1);
|
||||
channelRegistry.registerChannel(channel2);
|
||||
RecipientListRouter router = new RecipientListRouter();
|
||||
router.setChannels(channels);
|
||||
router.setChannelNames(new String[] {"channel1"});
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
router.afterPropertiesSet();
|
||||
RecipientListChannelResolver resolver = new RecipientListChannelResolver();
|
||||
resolver.setChannels(channels);
|
||||
resolver.setChannelNames(new String[] {"channel1"});
|
||||
resolver.setChannelRegistry(channelRegistry);
|
||||
resolver.afterPropertiesSet();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -56,16 +56,16 @@ public class RootCauseErrorMessageRouterTests {
|
||||
RuntimeException middleCause = new RuntimeException(rootCause);
|
||||
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
|
||||
ErrorMessage message = new ErrorMessage(error);
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
|
||||
Map<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
new HashMap<Class<? extends Throwable>, MessageChannel>();
|
||||
channelMappings.put(IllegalArgumentException.class, illegalArgumentChannel);
|
||||
channelMappings.put(RuntimeException.class, runtimeExceptionChannel);
|
||||
channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel);
|
||||
router.setChannelMappings(channelMappings);
|
||||
router.setDefaultChannel(defaultChannel);
|
||||
router.afterPropertiesSet();
|
||||
router.route(message);
|
||||
resolver.setChannelMappings(channelMappings);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setDefaultOutputChannel(defaultChannel);
|
||||
endpoint.send(message);
|
||||
assertNotNull(illegalArgumentChannel.receive(1000));
|
||||
assertNull(defaultChannel.receive(0));
|
||||
assertNull(runtimeExceptionChannel.receive(0));
|
||||
@@ -79,15 +79,15 @@ public class RootCauseErrorMessageRouterTests {
|
||||
RuntimeException middleCause = new RuntimeException(rootCause);
|
||||
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
|
||||
ErrorMessage message = new ErrorMessage(error);
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
|
||||
Map<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
new HashMap<Class<? extends Throwable>, MessageChannel>();
|
||||
channelMappings.put(RuntimeException.class, runtimeExceptionChannel);
|
||||
channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel);
|
||||
router.setChannelMappings(channelMappings);
|
||||
router.setDefaultChannel(defaultChannel);
|
||||
router.afterPropertiesSet();
|
||||
router.route(message);
|
||||
resolver.setChannelMappings(channelMappings);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setDefaultOutputChannel(defaultChannel);
|
||||
endpoint.send(message);
|
||||
assertNotNull(runtimeExceptionChannel.receive(1000));
|
||||
assertNull(illegalArgumentChannel.receive(0));
|
||||
assertNull(defaultChannel.receive(0));
|
||||
@@ -101,14 +101,14 @@ public class RootCauseErrorMessageRouterTests {
|
||||
RuntimeException middleCause = new RuntimeException(rootCause);
|
||||
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
|
||||
ErrorMessage message = new ErrorMessage(error);
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
|
||||
Map<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
new HashMap<Class<? extends Throwable>, MessageChannel>();
|
||||
channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel);
|
||||
router.setChannelMappings(channelMappings);
|
||||
router.setDefaultChannel(defaultChannel);
|
||||
router.afterPropertiesSet();
|
||||
router.route(message);
|
||||
resolver.setChannelMappings(channelMappings);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setDefaultOutputChannel(defaultChannel);
|
||||
endpoint.send(message);
|
||||
assertNotNull(messageHandlingExceptionChannel.receive(1000));
|
||||
assertNull(runtimeExceptionChannel.receive(0));
|
||||
assertNull(illegalArgumentChannel.receive(0));
|
||||
@@ -122,10 +122,10 @@ public class RootCauseErrorMessageRouterTests {
|
||||
RuntimeException middleCause = new RuntimeException(rootCause);
|
||||
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
|
||||
ErrorMessage message = new ErrorMessage(error);
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
router.setDefaultChannel(defaultChannel);
|
||||
router.afterPropertiesSet();
|
||||
router.route(message);
|
||||
RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setDefaultOutputChannel(defaultChannel);
|
||||
endpoint.send(message);
|
||||
assertNotNull(defaultChannel.receive(1000));
|
||||
assertNull(runtimeExceptionChannel.receive(0));
|
||||
assertNull(illegalArgumentChannel.receive(0));
|
||||
@@ -139,13 +139,12 @@ public class RootCauseErrorMessageRouterTests {
|
||||
RuntimeException middleCause = new RuntimeException(rootCause);
|
||||
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
|
||||
ErrorMessage message = new ErrorMessage(error);
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
|
||||
Map<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
new HashMap<Class<? extends Throwable>, MessageChannel>();
|
||||
channelMappings.put(MessageDeliveryException.class, messageDeliveryExceptionChannel);
|
||||
router.setChannelMappings(channelMappings);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(router);
|
||||
resolver.setChannelMappings(channelMappings);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setResolutionRequired(true);
|
||||
endpoint.send(message);
|
||||
}
|
||||
@@ -157,16 +156,16 @@ public class RootCauseErrorMessageRouterTests {
|
||||
RuntimeException middleCause = new RuntimeException(rootCause);
|
||||
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
|
||||
Message<?> message = new GenericMessage<Exception>(error);
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
|
||||
Map<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
new HashMap<Class<? extends Throwable>, MessageChannel>();
|
||||
channelMappings.put(IllegalArgumentException.class, illegalArgumentChannel);
|
||||
channelMappings.put(RuntimeException.class, runtimeExceptionChannel);
|
||||
channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel);
|
||||
router.setChannelMappings(channelMappings);
|
||||
router.setDefaultChannel(defaultChannel);
|
||||
router.afterPropertiesSet();
|
||||
router.route(message);
|
||||
resolver.setChannelMappings(channelMappings);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setDefaultOutputChannel(defaultChannel);
|
||||
endpoint.send(message);
|
||||
assertNotNull(illegalArgumentChannel.receive(1000));
|
||||
assertNull(defaultChannel.receive(0));
|
||||
assertNull(runtimeExceptionChannel.receive(0));
|
||||
@@ -180,15 +179,15 @@ public class RootCauseErrorMessageRouterTests {
|
||||
RuntimeException middleCause = new RuntimeException(rootCause);
|
||||
MessageHandlingException error = new MessageHandlingException(failedMessage, "failed", middleCause);
|
||||
ErrorMessage message = new ErrorMessage(error);
|
||||
RootCauseErrorMessageRouter router = new RootCauseErrorMessageRouter();
|
||||
RootCauseErrorMessageChannelResolver resolver = new RootCauseErrorMessageChannelResolver();
|
||||
Map<Class<? extends Throwable>, MessageChannel> channelMappings =
|
||||
new HashMap<Class<? extends Throwable>, MessageChannel>();
|
||||
channelMappings.put(IllegalArgumentException.class, illegalArgumentChannel);
|
||||
channelMappings.put(MessageHandlingException.class, messageHandlingExceptionChannel);
|
||||
router.setChannelMappings(channelMappings);
|
||||
router.setDefaultChannel(defaultChannel);
|
||||
router.afterPropertiesSet();
|
||||
router.route(message);
|
||||
resolver.setChannelMappings(channelMappings);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(resolver);
|
||||
endpoint.setDefaultOutputChannel(defaultChannel);
|
||||
endpoint.send(message);
|
||||
assertNotNull(illegalArgumentChannel.receive(1000));
|
||||
assertNull(defaultChannel.receive(0));
|
||||
assertNull(runtimeExceptionChannel.receive(0));
|
||||
|
||||
@@ -38,30 +38,24 @@ public class RouterEndpointTests {
|
||||
|
||||
@Test
|
||||
public void nullChannelIgnoredByDefault() {
|
||||
MultiChannelResolver channelResolver = new MultiChannelResolver() {
|
||||
public List<MessageChannel> resolve(Message<?> message) {
|
||||
ChannelResolver channelResolver = new ChannelResolver() {
|
||||
public List<MessageChannel> resolveChannels(Message<?> message) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelResolver(channelResolver);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(router);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
Message<String> message = new StringMessage("test");
|
||||
assertFalse(endpoint.send(message));
|
||||
}
|
||||
|
||||
@Test(expected = MessageDeliveryException.class)
|
||||
public void nullChannelThrowsExceptionWhenResolutionRequired() {
|
||||
MultiChannelResolver channelResolver = new MultiChannelResolver() {
|
||||
public List<MessageChannel> resolve(Message<?> message) {
|
||||
ChannelResolver channelResolver = new ChannelResolver() {
|
||||
public List<MessageChannel> resolveChannels(Message<?> message) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelResolver(channelResolver);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(router);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
endpoint.setResolutionRequired(true);
|
||||
Message<String> message = new StringMessage("test");
|
||||
endpoint.send(message);
|
||||
@@ -69,30 +63,24 @@ public class RouterEndpointTests {
|
||||
|
||||
@Test
|
||||
public void emptyChannelListIgnoredByDefault() {
|
||||
MultiChannelResolver channelResolver = new MultiChannelResolver() {
|
||||
public List<MessageChannel> resolve(Message<?> message) {
|
||||
ChannelResolver channelResolver = new ChannelResolver() {
|
||||
public List<MessageChannel> resolveChannels(Message<?> message) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
};
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelResolver(channelResolver);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(router);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
Message<String> message = new StringMessage("test");
|
||||
assertFalse(endpoint.send(message));
|
||||
}
|
||||
|
||||
@Test(expected = MessageDeliveryException.class)
|
||||
public void emptyChannelListThrowsExceptionWhenResolutionRequired() {
|
||||
MultiChannelResolver channelResolver = new MultiChannelResolver() {
|
||||
public List<MessageChannel> resolve(Message<?> message) {
|
||||
ChannelResolver channelResolver = new ChannelResolver() {
|
||||
public List<MessageChannel> resolveChannels(Message<?> message) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
};
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelResolver(channelResolver);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(router);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
endpoint.setResolutionRequired(true);
|
||||
Message<String> message = new StringMessage("test");
|
||||
endpoint.send(message);
|
||||
@@ -100,16 +88,13 @@ public class RouterEndpointTests {
|
||||
|
||||
@Test
|
||||
public void nullChannelNameArrayIgnoredByDefault() {
|
||||
MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() {
|
||||
public String[] resolve(Message<?> message) {
|
||||
AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() {
|
||||
public String[] resolveChannelNames(Message<?> message) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(router);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message = new StringMessage("test");
|
||||
assertFalse(endpoint.send(message));
|
||||
@@ -117,16 +102,13 @@ public class RouterEndpointTests {
|
||||
|
||||
@Test(expected = MessageDeliveryException.class)
|
||||
public void nullChannelNameArrayThrowsExceptionWhenResolutionRequired() {
|
||||
MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() {
|
||||
public String[] resolve(Message<?> message) {
|
||||
AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() {
|
||||
public String[] resolveChannelNames(Message<?> message) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(router);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
endpoint.setResolutionRequired(true);
|
||||
Message<String> message = new StringMessage("test");
|
||||
@@ -136,16 +118,13 @@ public class RouterEndpointTests {
|
||||
|
||||
@Test
|
||||
public void emptyChannelNameArrayIgnoredByDefault() {
|
||||
MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() {
|
||||
public String[] resolve(Message<?> message) {
|
||||
AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() {
|
||||
public String[] resolveChannelNames(Message<?> message) {
|
||||
return new String[] {};
|
||||
}
|
||||
};
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(router);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message = new StringMessage("test");
|
||||
assertFalse(endpoint.send(message));
|
||||
@@ -153,16 +132,13 @@ public class RouterEndpointTests {
|
||||
|
||||
@Test(expected = MessageDeliveryException.class)
|
||||
public void emptyChannelNameArrayThrowsExceptionWhenResolutionRequired() {
|
||||
MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() {
|
||||
public String[] resolve(Message<?> message) {
|
||||
AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() {
|
||||
public String[] resolveChannelNames(Message<?> message) {
|
||||
return new String[] {};
|
||||
}
|
||||
};
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(router);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
endpoint.setResolutionRequired(true);
|
||||
Message<String> message = new StringMessage("test");
|
||||
@@ -171,28 +147,30 @@ public class RouterEndpointTests {
|
||||
|
||||
@Test(expected = MessagingException.class)
|
||||
public void testChannelRegistryIsRequiredWhenUsingChannelNameResolverWithSingleChannelRouter() {
|
||||
ChannelNameResolver channelNameResolver = new ChannelNameResolver() {
|
||||
public String resolve(Message<?> message) {
|
||||
AbstractSingleChannelNameResolver channelNameResolver = new AbstractSingleChannelNameResolver() {
|
||||
public String resolveChannelName(Message<?> message) {
|
||||
return "notImportant";
|
||||
}
|
||||
};
|
||||
SingleChannelRouter router = new SingleChannelRouter();
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(router);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
|
||||
endpoint.send(new StringMessage("this should fail"));
|
||||
}
|
||||
|
||||
@Test(expected = MessagingException.class)
|
||||
public void testChannelRegistryIsRequiredWhenUsingChannelNameResolverWithMultiChannelRouter() {
|
||||
MultiChannelNameResolver channelNameResolver = new MultiChannelNameResolver() {
|
||||
public String[] resolve(Message<?> message) {
|
||||
AbstractMultiChannelNameResolver channelNameResolver = new AbstractMultiChannelNameResolver() {
|
||||
public String[] resolveChannelNames(Message<?> message) {
|
||||
return new String[] { "notImportant" };
|
||||
}
|
||||
};
|
||||
MultiChannelRouter router = new MultiChannelRouter();
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(router);
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
|
||||
endpoint.send(new StringMessage("this should fail"));
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void testChannelResolverMustNotBeNull() {
|
||||
AbstractSingleChannelNameResolver channelNameResolver = null;
|
||||
new RouterEndpoint(channelNameResolver);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -22,13 +22,12 @@ import static org.junit.Assert.assertNotNull;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import org.springframework.integration.ConfigurationException;
|
||||
import org.springframework.integration.channel.ChannelRegistry;
|
||||
import org.springframework.integration.channel.DefaultChannelRegistry;
|
||||
import org.springframework.integration.channel.MessageChannel;
|
||||
import org.springframework.integration.channel.QueueChannel;
|
||||
import org.springframework.integration.message.Message;
|
||||
import org.springframework.integration.message.MessageDeliveryException;
|
||||
import org.springframework.integration.message.MessagingException;
|
||||
import org.springframework.integration.message.StringMessage;
|
||||
|
||||
/**
|
||||
@@ -39,16 +38,14 @@ public class SingleChannelRouterTests {
|
||||
@Test
|
||||
public void routeWithChannelResolver() {
|
||||
final QueueChannel channel = new QueueChannel();
|
||||
ChannelResolver channelResolver = new ChannelResolver() {
|
||||
public MessageChannel resolve(Message<?> message) {
|
||||
AbstractSingleChannelResolver channelResolver = new AbstractSingleChannelResolver() {
|
||||
public MessageChannel resolveChannel(Message<?> message) {
|
||||
return channel;
|
||||
}
|
||||
};
|
||||
SingleChannelRouter router = new SingleChannelRouter();
|
||||
router.setChannelResolver(channelResolver);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
Message<String> message = new StringMessage("test");
|
||||
router.route(message);
|
||||
endpoint.send(message);
|
||||
Message<?> result = channel.receive(25);
|
||||
assertNotNull(result);
|
||||
assertEquals("test", result.getPayload());
|
||||
@@ -56,8 +53,8 @@ public class SingleChannelRouterTests {
|
||||
|
||||
@Test
|
||||
public void routeWithChannelNameResolver() {
|
||||
ChannelNameResolver channelNameResolver = new ChannelNameResolver() {
|
||||
public String resolve(Message<?> message) {
|
||||
AbstractSingleChannelNameResolver channelNameResolver = new AbstractSingleChannelNameResolver() {
|
||||
public String resolveChannelName(Message<?> message) {
|
||||
return "testChannel";
|
||||
}
|
||||
};
|
||||
@@ -65,71 +62,39 @@ public class SingleChannelRouterTests {
|
||||
channel.setBeanName("testChannel");
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
channelRegistry.registerChannel(channel);
|
||||
SingleChannelRouter router = new SingleChannelRouter();
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message = new StringMessage("test");
|
||||
router.route(message);
|
||||
endpoint.send(message);
|
||||
Message<?> result = channel.receive(25);
|
||||
assertNotNull(result);
|
||||
assertEquals("test", result.getPayload());
|
||||
}
|
||||
|
||||
@Test(expected = ConfigurationException.class)
|
||||
public void configuringBothChannelResolverAndChannelNameResolverIsNotAllowed() {
|
||||
ChannelResolver channelResolver = new ChannelResolver() {
|
||||
public MessageChannel resolve(Message<?> message) {
|
||||
return new QueueChannel();
|
||||
}
|
||||
};
|
||||
ChannelNameResolver channelNameResolver = new ChannelNameResolver() {
|
||||
public String resolve(Message<?> message) {
|
||||
return "";
|
||||
}
|
||||
};
|
||||
SingleChannelRouter router = new SingleChannelRouter();
|
||||
router.setChannelResolver(channelResolver);
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
router.afterPropertiesSet();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nullChannelResult() {
|
||||
ChannelResolver channelResolver = new ChannelResolver() {
|
||||
public MessageChannel resolve(Message<?> message) {
|
||||
AbstractSingleChannelResolver channelResolver = new AbstractSingleChannelResolver() {
|
||||
public MessageChannel resolveChannel(Message<?> message) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
SingleChannelRouter router = new SingleChannelRouter();
|
||||
router.setChannelResolver(channelResolver);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelResolver);
|
||||
Message<String> message = new StringMessage("test");
|
||||
assertFalse(router.route(message));
|
||||
assertFalse(endpoint.send(message));
|
||||
}
|
||||
|
||||
@Test(expected = MessageDeliveryException.class)
|
||||
@Test(expected = MessagingException.class)
|
||||
public void channelNameResolutionFailure() {
|
||||
ChannelNameResolver channelNameResolver = new ChannelNameResolver() {
|
||||
public String resolve(Message<?> message) {
|
||||
AbstractSingleChannelNameResolver channelNameResolver = new AbstractSingleChannelNameResolver() {
|
||||
public String resolveChannelName(Message<?> message) {
|
||||
return "noSuchChannel";
|
||||
}
|
||||
};
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
SingleChannelRouter router = new SingleChannelRouter();
|
||||
router.setChannelNameResolver(channelNameResolver);
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
router.afterPropertiesSet();
|
||||
RouterEndpoint endpoint = new RouterEndpoint(channelNameResolver);
|
||||
endpoint.setChannelRegistry(channelRegistry);
|
||||
Message<String> message = new StringMessage("test");
|
||||
router.route(message);
|
||||
}
|
||||
|
||||
@Test(expected = ConfigurationException.class)
|
||||
public void testChannelResolverIsRequired() {
|
||||
ChannelRegistry channelRegistry = new DefaultChannelRegistry();
|
||||
SingleChannelRouter router = new SingleChannelRouter();
|
||||
router.setChannelRegistry(channelRegistry);
|
||||
router.afterPropertiesSet();
|
||||
endpoint.send(message);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user