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

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.

Browse Source
This commit is contained in:
Mark Fisher
2008-10-10 23:47:22 +00:00
parent ac85cb1ecf
commit cb90d39657
33 changed files with 910 additions and 822 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/RouterAnnotationPostProcessor.java
View File

@@ -22,8 +22,7 @@ import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.integration.annotation.Router;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.message.MessageConsumer;
import org.springframework.integration.router.MethodInvokingChannelResolver;
import org.springframework.integration.router.RouterEndpoint;
import org.springframework.integration.router.MethodInvokingRouter;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
@@ -41,8 +40,7 @@ public class RouterAnnotationPostProcessor extends AbstractMethodAnnotationPostP
@Override
protected MessageConsumer createConsumer(Object bean, Method method, Router annotation) {
MethodInvokingChannelResolver resolver = new MethodInvokingChannelResolver(bean, method);
RouterEndpoint router = new RouterEndpoint(resolver);
MethodInvokingRouter router = new MethodInvokingRouter(bean, method);
String defaultOutputChannelName = annotation.defaultOutputChannel();
if (StringUtils.hasText(defaultOutputChannelName)) {
MessageChannel defaultOutputChannel = this.channelRegistry.lookupChannel(defaultOutputChannelName);

24
org.springframework.integration/src/main/java/org/springframework/integration/config/xml/RouterParser.java
View File

@@ -19,9 +19,12 @@ package org.springframework.integration.config.xml;
import org.w3c.dom.Element;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.integration.router.MethodInvokingChannelResolver;
import org.springframework.integration.router.RouterEndpoint;
import org.springframework.integration.router.BeanNameChannelMapping;
import org.springframework.integration.router.MethodInvokingRouter;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
/**
* Parser for the <router/> element.
@@ -32,10 +35,19 @@ public class RouterParser extends AbstractConsumerEndpointParser {
@Override
protected BeanDefinitionBuilder parseConsumer(Element element, ParserContext parserContext) {
String adapterBeanName = this.parseAdapter(element, parserContext, MethodInvokingChannelResolver.class);
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(RouterEndpoint.class);
builder.addConstructorArgReference(adapterBeanName);
builder.addPropertyReference("channelRegistry", MessageBusParser.MESSAGE_BUS_BEAN_NAME);
String ref = element.getAttribute(REF_ATTRIBUTE);
Assert.hasText(ref, "The '" + REF_ATTRIBUTE + "' attribute is required.");
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MethodInvokingRouter.class);
builder.addConstructorArgReference(ref);
if (StringUtils.hasText(element.getAttribute(METHOD_ATTRIBUTE))) {
String method = element.getAttribute(METHOD_ATTRIBUTE);
builder.addConstructorArgValue(method);
}
BeanDefinitionBuilder channelMappingBuilder =
BeanDefinitionBuilder.genericBeanDefinition(BeanNameChannelMapping.class);
String channelMappingBeanName = BeanDefinitionReaderUtils.registerWithGeneratedName(
channelMappingBuilder.getBeanDefinition(), parserContext.getRegistry());
builder.addPropertyReference("channelMapping", channelMappingBeanName);
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "default-output-channel");
return builder;
}

104
org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractChannelMappingMessageRouter.java Normal file
View File

@@ -0,0 +1,104 @@
/*
* Copyright 2002-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.integration.router;
import java.util.ArrayList;
import java.util.Collection;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.message.Message;
import org.springframework.integration.message.MessagingException;
import org.springframework.util.Assert;
/**
* A base class for router implementations that return only
* the channel name(s) rather than {@link MessageChannel} instances.
*
* @author Mark Fisher
*/
public abstract class AbstractChannelMappingMessageRouter extends AbstractMessageRouter implements BeanFactoryAware, InitializingBean {
private volatile ChannelMapping channelMapping;
private volatile String prefix;
private volatile String suffix;
private volatile BeanFactory beanFactory;
public void setChannelMapping(ChannelMapping channelMapping) {
this.channelMapping = channelMapping;
}
public void setPrefix(String prefix) {
this.prefix = prefix;
}
public void setSuffix(String suffix) {
this.suffix = suffix;
}
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
public void afterPropertiesSet() {
if (this.channelMapping == null) {
Assert.notNull(beanFactory, "either a ChannelMapping or BeanFactory is required");
this.channelMapping = new BeanNameChannelMapping(this.beanFactory);
}
}
@Override
protected final Collection<MessageChannel> resolveChannels(Message<?> message) {
this.afterPropertiesSet();
Collection<MessageChannel> channels = new ArrayList<MessageChannel>();
String[] channelNames = this.resolveChannelNames(message);
if (channelNames == null) {
return null;
}
for (String channelName : channelNames) {
if (channelName != null) {
Assert.state(this.channelMapping != null,
"unable to resolve channels, no ChannelMapping available");
if (this.prefix != null) {
channelName = this.prefix + channelName;
}
if (this.suffix != null) {
channelName = channelName + suffix;
}
MessageChannel channel = this.channelMapping.getChannel(channelName);
if (channel == null) {
throw new MessagingException(message,
"unable to resolve channel '" + channelName + "'");
}
channels.add(channel);
}
}
return channels;
}
/**
* Subclasses must implement this method to return the channel name(s).
*/
protected abstract String[] resolveChannelNames(Message<?> message);
}

70
org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractChannelNameResolver.java
View File

@@ -1,70 +0,0 @@
/*
* Copyright 2002-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.integration.router;
import java.util.ArrayList;
import java.util.Collection;
import org.springframework.integration.channel.ChannelRegistry;
import org.springframework.integration.channel.ChannelRegistryAware;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.message.Message;
import org.springframework.integration.message.MessagingException;
import org.springframework.util.Assert;
/**
* A base class for {@link ChannelResolver} implementations that return only
* the channel name(s) rather than {@link MessageChannel} instances.
*
* @author Mark Fisher
*/
public abstract class AbstractChannelNameResolver implements ChannelResolver, ChannelRegistryAware {
private ChannelRegistry channelRegistry;
public void setChannelRegistry(ChannelRegistry channelRegistry) {
this.channelRegistry = channelRegistry;
}
public final Collection<MessageChannel> resolveChannels(Message<?> message) {
Collection<MessageChannel> channels = new ArrayList<MessageChannel>();
String[] channelNames = this.resolveChannelNames(message);
if (channelNames == null) {
return null;
}
for (String channelName : channelNames) {
if (channelName != null) {
Assert.state(this.channelRegistry != null,
"unable to resolve channels, no ChannelRegistry available");
MessageChannel channel = this.channelRegistry.lookupChannel(channelName);
if (channel == null) {
throw new MessagingException(message,
"unable to resolve chnanel '" + channelName + "'");
}
channels.add(channel);
}
}
return channels;
}
/**
* Subclasses must implement this method to return the channel name(s).
*/
protected abstract String[] resolveChannelNames(Message<?> message);
}

35
org.springframework.integration/src/main/java/org/springframework/integration/router/RouterEndpoint.java → org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractMessageRouter.java
View File

@@ -18,21 +18,18 @@ package org.springframework.integration.router;
import java.util.Collection;
import org.springframework.integration.channel.ChannelRegistry;
import org.springframework.integration.channel.ChannelRegistryAware;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.MessageChannelTemplate;
import org.springframework.integration.endpoint.AbstractMessageConsumer;
import org.springframework.integration.message.Message;
import org.springframework.integration.message.MessageDeliveryException;
import org.springframework.util.Assert;
/**
* Base class for Message Routers.
*
* @author Mark Fisher
*/
public class RouterEndpoint extends AbstractMessageConsumer implements ChannelRegistryAware {
private final ChannelResolver channelResolver;
public abstract class AbstractMessageRouter extends AbstractMessageConsumer {
private volatile MessageChannel defaultOutputChannel;
@@ -41,18 +38,12 @@ public class RouterEndpoint extends AbstractMessageConsumer implements ChannelRe
private final MessageChannelTemplate channelTemplate = new MessageChannelTemplate();
public RouterEndpoint(ChannelResolver channelResolver) {
Assert.notNull(channelResolver, "ChannelResolver must not be null");
this.channelResolver = channelResolver;
}
public void setChannelRegistry(ChannelRegistry channelRegistry) {
if (this.channelResolver instanceof ChannelRegistryAware) {
((ChannelRegistryAware) this.channelResolver).setChannelRegistry(channelRegistry);
}
}
/**
* Set the default channel where Messages should be sent if channel
* resolution fails to return any channels. If no default channel is
* provided, the router will either drop the Message or throw an Exception
* depending on the value of {@link #resolutionRequired}.
*/
public void setDefaultOutputChannel(MessageChannel defaultOutputChannel) {
this.defaultOutputChannel = defaultOutputChannel;
}
@@ -78,7 +69,7 @@ public class RouterEndpoint extends AbstractMessageConsumer implements ChannelRe
@Override
protected void onMessageInternal(Message<?> message) {
boolean sent = false;
Collection<MessageChannel> results = this.channelResolver.resolveChannels(message);
Collection<MessageChannel> results = this.resolveChannels(message);
if (results != null) {
for (MessageChannel channel : results) {
if (channel != null) {
@@ -99,4 +90,10 @@ public class RouterEndpoint extends AbstractMessageConsumer implements ChannelRe
}
}
/**
* Subclasses must implement this method to return the target channels for
* a given Message.
*/
protected abstract Collection<MessageChannel> resolveChannels(Message<?> message);
}

5
org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelNameResolver.java → org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelNameRouter.java
View File

@@ -21,9 +21,10 @@ import org.springframework.integration.message.Message;
/**
* @author Mark Fisher
*/
public abstract class AbstractSingleChannelNameResolver extends AbstractChannelNameResolver {
public abstract class AbstractSingleChannelNameRouter extends AbstractChannelMappingMessageRouter {
public final String[] resolveChannelNames(Message<?> message) {
@Override
protected final String[] resolveChannelNames(Message<?> message) {
String channelName = this.resolveChannelName(message);
return (channelName != null) ? new String[] { channelName } : null;
}

8
org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelResolver.java → org.springframework.integration/src/main/java/org/springframework/integration/router/AbstractSingleChannelRouter.java
View File

@@ -25,12 +25,12 @@ import org.springframework.integration.message.Message;
/**
* @author Mark Fisher
*/
public abstract class AbstractSingleChannelResolver implements ChannelResolver {
public abstract class AbstractSingleChannelRouter extends AbstractMessageRouter {
public Collection<MessageChannel> resolveChannels(Message<?> message) {
@Override
protected final Collection<MessageChannel> resolveChannels(Message<?> message) {
MessageChannel channel = this.resolveChannel(message);
return (channel != null) ?
Collections.singletonList(channel) : null;
return (channel != null) ? Collections.singletonList(channel) : null;
}
protected abstract MessageChannel resolveChannel(Message<?> message);

61
org.springframework.integration/src/main/java/org/springframework/integration/router/BeanNameChannelMapping.java Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2002-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.integration.router;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.util.Assert;
/**
* An implementation of the ChannelMapping strategy that retrieves a
* MessageChannel instance from the {@link BeanFactory} using the provided
* name.
*
* @author Mark Fisher
*/
public class BeanNameChannelMapping implements ChannelMapping, BeanFactoryAware {
private volatile BeanFactory beanFactory;
/**
* Constructor for use within a context where the BeanFactory will be
* injected via the {@link #setBeanFactory(BeanFactory)} callback method.
*/
public BeanNameChannelMapping() {
}
/**
* Constructor for programmatic creation from within other components that
* already have access to the {@link BeanFactory}.
*/
public BeanNameChannelMapping(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
public MessageChannel getChannel(String name) {
Assert.state(this.beanFactory != null, "beanFactory must not be null");
return (MessageChannel) this.beanFactory.getBean(name, MessageChannel.class);
}
}

30
org.springframework.integration/src/main/java/org/springframework/integration/router/ChannelMapping.java Normal file
View File

@@ -0,0 +1,30 @@
/*
* Copyright 2002-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.integration.router;
import org.springframework.integration.channel.MessageChannel;
/**
* Strategy for mapping from a name to a {@link MessageChannel}.
*
* @author Mark Fisher
*/
public interface ChannelMapping {
MessageChannel getChannel(String name);
}

36
org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingChannelResolver.java → org.springframework.integration/src/main/java/org/springframework/integration/router/MethodInvokingRouter.java
View File

@@ -23,8 +23,6 @@ import java.util.Collection;
import java.util.List;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.integration.channel.ChannelRegistry;
import org.springframework.integration.channel.ChannelRegistryAware;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.message.Message;
import org.springframework.integration.message.MessageMappingMethodInvoker;
@@ -32,38 +30,44 @@ import org.springframework.integration.message.MessagingException;
import org.springframework.util.Assert;
/**
* A {@link ChannelResolver} implementation that invokes the specified method
* on the given object. The method's return value may be a single MessageChannel
* instance, a single String to be interpreted as a channel name, or a Collection
* (or Array) of either type.
* A Message Router that invokes the specified method on the given object. The
* method's return value may be a single MessageChannel instance, a single
* String to be interpreted as a channel name, or a Collection (or Array) of
* either type. If the method returns channel names, then a
* {@link ChannelMapping} is required.
*
* @author Mark Fisher
*/
public class MethodInvokingChannelResolver implements ChannelResolver, ChannelRegistryAware, InitializingBean {
public class MethodInvokingRouter extends AbstractMessageRouter implements InitializingBean {
private final MessageMappingMethodInvoker invoker;
private volatile ChannelRegistry channelRegistry;
private volatile ChannelMapping channelMapping;
public MethodInvokingChannelResolver(Object object, Method method) {
public MethodInvokingRouter(Object object, Method method) {
this.invoker = new MessageMappingMethodInvoker(object, method);
}
public MethodInvokingChannelResolver(Object object, String methodName) {
public MethodInvokingRouter(Object object, String methodName) {
this.invoker = new MessageMappingMethodInvoker(object, methodName);
}
public void setChannelRegistry(ChannelRegistry channelRegistry) {
this.channelRegistry = channelRegistry;
/**
* Provide the ChannelMapping strategy to use for methods that return a
* channel name rather than a {@link MessageChannel} instance.
*/
public void setChannelMapping(ChannelMapping channelMapping) {
this.channelMapping = channelMapping;
}
public void afterPropertiesSet() throws Exception {
this.invoker.afterPropertiesSet();
}
public final Collection<MessageChannel> resolveChannels(Message<?> message) {
@Override
protected final Collection<MessageChannel> resolveChannels(Message<?> message) {
Object result = this.invoker.invokeMethod(message);
if (result == null) {
return null;
@@ -104,9 +108,9 @@ public class MethodInvokingChannelResolver implements ChannelResolver, ChannelRe
}
else if (channelOrName instanceof String) {
String channelName = (String) channelOrName;
Assert.state(this.channelRegistry != null,
"ChannelRegistry is required for resolving channel names");
MessageChannel channel = this.channelRegistry.lookupChannel(channelName);
Assert.state(this.channelMapping != null,
"ChannelMapping is required for resolving channel names");
MessageChannel channel = this.channelMapping.getChannel(channelName);
if (channel == null) {
throw new MessagingException("unable to resolve channel '" + channelName + "'");
}

17
org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeChannelResolver.java → org.springframework.integration/src/main/java/org/springframework/integration/router/PayloadTypeRouter.java
View File

@@ -24,24 +24,25 @@ import org.springframework.integration.message.Message;
import org.springframework.util.Assert;
/**
* A ChannelResolver implementation that resolves the {@link MessageChannel} based
* on the {@link Message Message's} payload type.
* A Message Router that resolves the {@link MessageChannel} based on the
* {@link Message Message's} payload type.
*
* @author Mark Fisher
*/
public class PayloadTypeChannelResolver extends AbstractSingleChannelResolver {
public class PayloadTypeRouter extends AbstractSingleChannelRouter {
private Map<Class<?>, MessageChannel> channelMappings = new ConcurrentHashMap<Class<?>, MessageChannel>();
private volatile Map<Class<?>, MessageChannel> payloadTypeChannelMap =
new ConcurrentHashMap<Class<?>, MessageChannel>();
public void setChannelMappings(Map<Class<?>, MessageChannel> channelMappings) {
Assert.notNull(channelMappings, "'channelMappings' must not be null");
this.channelMappings = channelMappings;
public void setPayloadTypeChannelMap(Map<Class<?>, MessageChannel> payloadTypeChannelMap) {
Assert.notNull(payloadTypeChannelMap, "payloadTypeChannelMap must not be null");
this.payloadTypeChannelMap = payloadTypeChannelMap;
}
@Override
protected MessageChannel resolveChannel(Message<?> message) {
return this.channelMappings.get(message.getPayload().getClass());
return this.payloadTypeChannelMap.get(message.getPayload().getClass());
}
}

15
org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListChannelResolver.java → org.springframework.integration/src/main/java/org/springframework/integration/router/RecipientListRouter.java
View File

@@ -25,21 +25,19 @@ import org.springframework.integration.message.Message;
import org.springframework.util.Assert;
/**
* A {@link ChannelResolver} implementation that routes to a statically
* configured list of recipients. The recipients are provided as a list of
* {@link MessageChannel} instances. For dynamic recipient lists, consider
* either implementing the {@link ChannelResolver} interface directly or
* extending the {@link AbstractChannelNameResolver} base class.
* A Message Router that sends Messages to a statically configured list of
* recipients. The recipients are provided as a list of {@link MessageChannel}
* instances. For dynamic recipient lists, consider instead using the @Router
* annotation or extending {@link AbstractChannelMappingMessageRouter}.
*
* @author Mark Fisher
*/
public class RecipientListChannelResolver implements ChannelResolver, InitializingBean {
public class RecipientListRouter extends AbstractMessageRouter implements InitializingBean {
private volatile List<MessageChannel> channels;
public void setChannels(List<MessageChannel> channels) {
Assert.notEmpty(channels, "a non-empty channel list is required");
this.channels = channels;
}
@@ -47,7 +45,8 @@ public class RecipientListChannelResolver implements ChannelResolver, Initializi
Assert.notEmpty(this.channels, "a non-empty channel list is required");
}
public Collection<MessageChannel> resolveChannels(Message<?> message) {
@Override
protected Collection<MessageChannel> resolveChannels(Message<?> message) {
return this.channels;
}

18
org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageChannelResolver.java → org.springframework.integration/src/main/java/org/springframework/integration/router/RootCauseErrorMessageRouter.java
View File

@@ -24,21 +24,21 @@ import org.springframework.integration.message.Message;
import org.springframework.util.Assert;
/**
* A ChannelResolver implementation that resolves the {@link MessageChannel} for
* messages whose payload is an Exception. The channel resolution is based upon the
* most specific cause of the error for which a channel-mapping exists.
* A Message Router that resolves the target {@link MessageChannel} for
* messages whose payload is an Exception. The channel resolution is based upon
* the most specific cause of the error for which a channel-mapping exists.
*
* @author Mark Fisher
*/
public class RootCauseErrorMessageChannelResolver extends AbstractSingleChannelResolver {
public class RootCauseErrorMessageRouter extends AbstractSingleChannelRouter {
private Map<Class<? extends Throwable>, MessageChannel> channelMappings =
private volatile Map<Class<? extends Throwable>, MessageChannel> exceptionTypeChannelMap =
new ConcurrentHashMap<Class<? extends Throwable>, MessageChannel>();
public void setChannelMappings(Map<Class<? extends Throwable>, MessageChannel> channelMappings) {
Assert.notNull(channelMappings, "'channelMappings' must not be null");
this.channelMappings = channelMappings;
public void setExceptionTypeChannelMap(Map<Class<? extends Throwable>, MessageChannel> exceptionTypeChannelMap) {
Assert.notNull(exceptionTypeChannelMap, "exceptionTypeChannelMap must not be null");
this.exceptionTypeChannelMap = exceptionTypeChannelMap;
}
@@ -49,7 +49,7 @@ public class RootCauseErrorMessageChannelResolver extends AbstractSingleChannelR
if (payload != null && (payload instanceof Throwable)) {
Throwable mostSpecificCause = (Throwable) payload;
while (mostSpecificCause != null) {
MessageChannel mappedChannel = this.channelMappings.get(mostSpecificCause.getClass());
MessageChannel mappedChannel = this.exceptionTypeChannelMap.get(mostSpecificCause.getClass());
if (mappedChannel != null) {
channel = mappedChannel;
}

18
org.springframework.integration/src/test/java/org/springframework/integration/aop/PublisherAnnotationAdvisorTests.java
View File

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

7
org.springframework.integration/src/test/java/org/springframework/integration/channel/TestChannelRegistry.java → org.springframework.integration/src/test/java/org/springframework/integration/channel/TestChannelMapping.java
View File

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

15
org.springframework.integration/src/test/java/org/springframework/integration/endpoint/ServiceActivatorEndpointTests.java
View File

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

342
org.springframework.integration/src/test/java/org/springframework/integration/router/MethodInvokingRouterTests.java
View File

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

61
org.springframework.integration/src/test/java/org/springframework/integration/router/MultiChannelRouterTests.java
View File

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

52
org.springframework.integration/src/test/java/org/springframework/integration/router/PayloadTypeRouterTests.java
View File

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

44
org.springframework.integration/src/test/java/org/springframework/integration/router/RecipientListRouterTests.java
View File

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

111
org.springframework.integration/src/test/java/org/springframework/integration/router/RootCauseErrorMessageRouterTests.java
View File

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

121
org.springframework.integration/src/test/java/org/springframework/integration/router/RouterEndpointTests.java → org.springframework.integration/src/test/java/org/springframework/integration/router/RouterTests.java
View File

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

33
org.springframework.integration/src/test/java/org/springframework/integration/router/SingleChannelRouterTests.java
View File

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