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

Removed ChannelFactory strategy and implementations prior to general channel refactoring.

Browse Source
This commit is contained in:
Mark Fisher
2008-08-31 21:20:16 +00:00
parent 68035e091d
commit 4b8a32456e
18 changed files with 1 additions and 754 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
org.springframework.integration/src/main/java/org/springframework/integration/bus/DefaultChannelFactoryBean.java
View File

@@ -1,95 +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.bus;
import java.util.List;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.integration.channel.ChannelInterceptor;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.factory.ChannelFactory;
import org.springframework.integration.channel.factory.QueueChannelFactory;
/**
* Creates a channel by delegating to the "channelFactory" bean defined
* within the {@link ApplicationContext} or else the default implementation
* (QueueChannelFactory).
* <p>
* As a {@link FactoryBean}, this class is solely intended to be used within
* an ApplicationContext.
*
* @author Marius Bogoevici
* @author Mark Fisher
*/
public class DefaultChannelFactoryBean implements ApplicationContextAware, FactoryBean, BeanNameAware {
public static final String CHANNEL_FACTORY_BEAN_NAME = "channelFactory";
private volatile String beanName;
private volatile List<ChannelInterceptor> interceptors;
private volatile ApplicationContext applicationContext;
private volatile MessageChannel channel;
private final Object initializationMonitor = new Object();
public void setApplicationContext(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
public void setBeanName(String beanName) {
this.beanName = beanName;
}
public void setInterceptors(List<ChannelInterceptor> interceptors) {
this.interceptors = interceptors;
}
public Object getObject() throws Exception {
synchronized (this.initializationMonitor) {
if (this.channel == null) {
ChannelFactory channelFactory = null;
if (this.applicationContext.containsBean(CHANNEL_FACTORY_BEAN_NAME)) {
channelFactory = (ChannelFactory) this.applicationContext.getBean(CHANNEL_FACTORY_BEAN_NAME);
}
else {
channelFactory = new QueueChannelFactory();
}
this.channel = channelFactory.getChannel(this.beanName, this.interceptors);
}
}
return this.channel;
}
public Class<?> getObjectType() {
if (this.channel == null) {
return MessageChannel.class;
}
return this.channel.getClass();
}
public boolean isSingleton() {
return true;
}
}

54
org.springframework.integration/src/main/java/org/springframework/integration/channel/factory/AbstractChannelFactory.java
View File

@@ -1,54 +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.channel.factory;
import java.util.List;
import org.springframework.integration.channel.AbstractMessageChannel;
import org.springframework.integration.channel.ChannelInterceptor;
import org.springframework.integration.channel.MessageChannel;
/**
* Base class for {@link ChannelFactory} implementations. Subclasses should
* override {@literal createChannelInternal()}.
*
* @author Marius Bogoevici
*/
public abstract class AbstractChannelFactory implements ChannelFactory {
public AbstractChannelFactory() {
super();
}
public final MessageChannel getChannel(String name, List<ChannelInterceptor> interceptors) {
AbstractMessageChannel channel = createChannelInternal();
if (null != interceptors) {
channel.setInterceptors(interceptors);
}
if (name != null && channel.getName() == null) {
channel.setBeanName(name);
}
return channel;
}
/**
* Factory method to be overridden by subclasses. It assumes that subclasses will return
* subclasses of AbstractMessageChannel.
*/
protected abstract AbstractMessageChannel createChannelInternal();
}

36
org.springframework.integration/src/main/java/org/springframework/integration/channel/factory/ChannelFactory.java
View File

@@ -1,36 +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.channel.factory;
import java.util.List;
import org.springframework.integration.channel.ChannelInterceptor;
import org.springframework.integration.channel.MessageChannel;
/**
* Interface for a channel factory.
*
* @author Marius Bogoevici
*/
public interface ChannelFactory {
/**
* Creates a channel based on the provided name and interceptors.
*/
MessageChannel getChannel(String name, List<ChannelInterceptor> interceptors);
}

34
org.springframework.integration/src/main/java/org/springframework/integration/channel/factory/DirectChannelFactory.java
View File

@@ -1,34 +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.channel.factory;
import org.springframework.integration.channel.AbstractMessageChannel;
import org.springframework.integration.channel.DirectChannel;
/**
* A {@link ChannelFactory} for creating {@link DirectChannel} instances.
*
* @author Marius Bogoevici
*/
public class DirectChannelFactory extends AbstractChannelFactory {
@Override
protected AbstractMessageChannel createChannelInternal() {
return new DirectChannel();
}
}

52
org.springframework.integration/src/main/java/org/springframework/integration/channel/factory/PriorityChannelFactory.java
View File

@@ -1,52 +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.channel.factory;
import java.util.Comparator;
import org.springframework.integration.channel.AbstractMessageChannel;
import org.springframework.integration.channel.PriorityChannel;
import org.springframework.integration.message.Message;
import org.springframework.util.Assert;
/**
* A {@link ChannelFactory} for creating {@link PriorityChannel} instances.
* @author Marius Bogoevici
*
*/
public class PriorityChannelFactory extends AbstractChannelFactory {
private int capacity = PriorityChannel.DEFAULT_CAPACITY;
private Comparator<Message<?>> comparator;
public void setCapacity(int capacity) {
Assert.isTrue(capacity > 0, "capacity must be a positive value");
this.capacity = capacity;
}
public void setComparator(Comparator<Message<?>> comparator) {
this.comparator = comparator;
}
@Override
protected AbstractMessageChannel createChannelInternal() {
return new PriorityChannel(this.capacity, this.comparator);
}
}

51
org.springframework.integration/src/main/java/org/springframework/integration/channel/factory/QueueChannelFactory.java
View File

@@ -1,51 +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.channel.factory;
import org.springframework.integration.channel.AbstractMessageChannel;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.util.Assert;
/**
* Default implementation of a {@link ChannelFactory}, which will create instances of a
* {@link QueueChannel}.
*
* @author Marius Bogoevici
*/
public class QueueChannelFactory extends AbstractChannelFactory{
int queueCapacity = QueueChannel.DEFAULT_CAPACITY;
public int getQueueCapacity() {
return queueCapacity;
}
/**
* Sets the queue capacity for the newly created channels.
* By default, the queue capacity is {@literal QueueChannel.DEFAULT_CAPACITY}
* @param queueCapacity
*/
public void setQueueCapacity(int queueCapacity) {
Assert.state(queueCapacity > 0, "Queue capacity must be greater than zero");
this.queueCapacity = queueCapacity;
}
protected AbstractMessageChannel createChannelInternal() {
return new QueueChannel(queueCapacity);
}
}

34
org.springframework.integration/src/main/java/org/springframework/integration/channel/factory/RendezvousChannelFactory.java
View File

@@ -1,34 +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.channel.factory;
import org.springframework.integration.channel.AbstractMessageChannel;
import org.springframework.integration.channel.RendezvousChannel;
/**
* A {@link ChannelFactory} for creating {@link RendezvousChannel} instances.
*
* @author Marius Bogoevici
*/
public class RendezvousChannelFactory extends AbstractChannelFactory {
@Override
protected AbstractMessageChannel createChannelInternal() {
return new RendezvousChannel();
}
}

34
org.springframework.integration/src/main/java/org/springframework/integration/channel/factory/ThreadLocalChannelFactory.java
View File

@@ -1,34 +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.channel.factory;
import org.springframework.integration.channel.AbstractMessageChannel;
import org.springframework.integration.channel.ThreadLocalChannel;
/**
* A {@link ChannelFactory} implementation for creating {@link ThreadLocalChannel} instances.
*
* @author Mark Fisher
*/
public class ThreadLocalChannelFactory extends AbstractChannelFactory {
@Override
protected AbstractMessageChannel createChannelInternal() {
return new ThreadLocalChannel();
}
}

35
org.springframework.integration/src/main/java/org/springframework/integration/config/DefaultChannelParser.java
View File

@@ -1,35 +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.config;
import org.springframework.integration.bus.DefaultChannelFactoryBean;
import org.w3c.dom.Element;
/**
* Parser for the &lt;channel&gt; element.
*
* @author Marius Bogoevici
*/
public class DefaultChannelParser extends AbstractChannelParser {
@Override
protected Class<?> getBeanClass(Element element) {
return DefaultChannelFactoryBean.class;
}
}

2
org.springframework.integration/src/main/java/org/springframework/integration/config/IntegrationNamespaceHandler.java
View File

@@ -49,7 +49,7 @@ public class IntegrationNamespaceHandler extends NamespaceHandlerSupport {
public void init() {
registerBeanDefinitionParser("message-bus", new MessageBusParser());
registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenParser());
registerBeanDefinitionParser("channel", new DefaultChannelParser());
registerBeanDefinitionParser("channel", new QueueChannelParser());
registerBeanDefinitionParser("queue-channel", new QueueChannelParser());
registerBeanDefinitionParser("publish-subscribe-channel", new PublishSubscribeChannelParser());
registerBeanDefinitionParser("direct-channel", new DirectChannelParser());

40
org.springframework.integration/src/test/java/org/springframework/integration/channel/config/DefaultChannelParserTests.java
View File

@@ -1,40 +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.channel.config;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.factory.StubChannel;
/**
* @author Marius Bogoevici
*/
public class DefaultChannelParserTests {
@Test
public void testDefaultChannel() {
ApplicationContext context = new ClassPathXmlApplicationContext("defaultChannelParserTests.xml", this.getClass());
MessageChannel channel = (MessageChannel) context.getBean("defaultChannel");
assertEquals(StubChannel.class, channel.getClass());
}
}

14
org.springframework.integration/src/test/java/org/springframework/integration/channel/config/defaultChannelParserTests.xml
View File

@@ -1,14 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/integration"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/integration
http://www.springframework.org/schema/integration/spring-integration-core-1.0.xsd">
<beans:bean id="channelFactory" class="org.springframework.integration.channel.factory.StubChannelFactory"/>
<channel id="defaultChannel"/>
</beans:beans>

149
org.springframework.integration/src/test/java/org/springframework/integration/channel/factory/ChannelFactoryTests.java
View File

@@ -1,149 +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.channel.factory;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.DirectFieldAccessor;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.support.StaticApplicationContext;
import org.springframework.integration.bus.DefaultChannelFactoryBean;
import org.springframework.integration.channel.AbstractMessageChannel;
import org.springframework.integration.channel.ChannelInterceptor;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.PriorityChannel;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.integration.channel.RendezvousChannel;
import org.springframework.integration.channel.ThreadLocalChannel;
import org.springframework.integration.channel.interceptor.ChannelInterceptorAdapter;
import org.springframework.integration.message.Message;
import org.springframework.integration.message.MessageBuilder;
/**
* @author Marius Bogoevici
* @author Mark Fisher
*/
public class ChannelFactoryTests {
private final ArrayList<ChannelInterceptor> interceptors = new ArrayList<ChannelInterceptor>();
private final ArrayList<ChannelInterceptor> appliedInterceptors = new ArrayList<ChannelInterceptor>();
@Before
public void initInterceptorsList() {
interceptors.add(new TestChannelInterceptor());
interceptors.add(new TestChannelInterceptor());
}
@Test
public void testQueueChannelFactory() {
QueueChannelFactory channelFactory = new QueueChannelFactory();
channelFactory.setQueueCapacity(99);
genericChannelFactoryTests(channelFactory, QueueChannel.class);
assertEquals(99, channelFactory.getQueueCapacity());
}
@Test
public void testDirectChannelFactory() {
DirectChannelFactory channelFactory = new DirectChannelFactory();
assertNotNull(interceptors);
AbstractMessageChannel channel = (AbstractMessageChannel)
channelFactory.getChannel("testChannel", interceptors);
assertEquals(DirectChannel.class, channel.getClass());
assertEquals("testChannel", channel.getName());
assertInterceptors(channel);
}
@Test
public void testRendezvousChannelFactory() {
RendezvousChannelFactory channelFactory = new RendezvousChannelFactory();
genericChannelFactoryTests(channelFactory, RendezvousChannel.class);
}
@Test
public void testPriorityChannelFactory() {
PriorityChannelFactory channelFactory = new PriorityChannelFactory();
genericChannelFactoryTests(channelFactory, PriorityChannel.class);
}
@Test
public void testThreadLocalChannelFactory() {
ThreadLocalChannelFactory channelFactory = new ThreadLocalChannelFactory();
assertNotNull(interceptors);
AbstractMessageChannel channel = (AbstractMessageChannel)
channelFactory.getChannel("testChannel", interceptors);
assertEquals(ThreadLocalChannel.class, channel.getClass());
assertEquals("testChannel", channel.getName());
assertInterceptors(channel);
}
@Test
public void testDefaultChannelFactoryBean() throws Exception{
StaticApplicationContext applicationContext = new StaticApplicationContext();
BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(StubChannelFactory.class);
applicationContext.registerBeanDefinition("channelFactory", builder.getBeanDefinition());
DefaultChannelFactoryBean channelFactoryBean = new DefaultChannelFactoryBean();
channelFactoryBean.setBeanName("testChannel");
channelFactoryBean.setApplicationContext(applicationContext);
channelFactoryBean.setInterceptors(interceptors);
MessageChannel channel = (MessageChannel) channelFactoryBean.getObject();
channel.getName();
assertEquals(StubChannel.class, channel.getClass());
assertEquals("testChannel", channel.getName());
channel.send(MessageBuilder.fromPayload("").build());
assertTrue(appliedInterceptors.get(0) == interceptors.get(0));
assertTrue(appliedInterceptors.get(1) == interceptors.get(1));
}
private void genericChannelFactoryTests(ChannelFactory channelFactory, Class<?> expectedChannelClass) {
assertNotNull(interceptors);
AbstractMessageChannel channel = (AbstractMessageChannel) channelFactory.getChannel("testChannel", interceptors);
assertEquals(expectedChannelClass, channel.getClass());
assertEquals("testChannel", channel.getName());
assertInterceptors(channel);
}
@SuppressWarnings("unchecked")
private void assertInterceptors(AbstractMessageChannel channel) {
Object interceptorsWrapper = new DirectFieldAccessor(channel).getPropertyValue("interceptors");
List<ChannelInterceptor> interceptors = (List<ChannelInterceptor>)
new DirectFieldAccessor(interceptorsWrapper).getPropertyValue("interceptors");
assertTrue(interceptors.get(0) == this.interceptors.get(0));
assertTrue(interceptors.get(1) == this.interceptors.get(1));
}
private class TestChannelInterceptor extends ChannelInterceptorAdapter {
public Message<?> preSend(Message<?> message, MessageChannel channel) {
appliedInterceptors.add(this);
return message;
}
}
}

48
org.springframework.integration/src/test/java/org/springframework/integration/channel/factory/StubChannel.java
View File

@@ -1,48 +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.channel.factory;
import java.util.List;
import org.springframework.integration.channel.AbstractPollableChannel;
import org.springframework.integration.message.Message;
import org.springframework.integration.message.selector.MessageSelector;
/**
* @author Marius Bogoevici
*/
public class StubChannel extends AbstractPollableChannel {
@Override
protected Message<?> doReceive(long timeout) {
return null;
}
@Override
protected boolean doSend(Message<?> message, long timeout) {
return false;
}
public List<Message<?>> clear() {
return null;
}
public List<Message<?>> purge(MessageSelector selector) {
return null;
}
}

31
org.springframework.integration/src/test/java/org/springframework/integration/channel/factory/StubChannelFactory.java
View File

@@ -1,31 +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.channel.factory;
import org.springframework.integration.channel.AbstractMessageChannel;
/**
* @author Marius Bogoevici
*/
public class StubChannelFactory extends AbstractChannelFactory {
@Override
protected AbstractMessageChannel createChannelInternal() {
return new StubChannel();
}
}

16
org.springframework.integration/src/test/java/org/springframework/integration/channel/factory/defaultChannelFactoryBeanTests.xml
View File

@@ -1,16 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/integration"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/integration
http://www.springframework.org/schema/integration/spring-integration-core-1.0.xsd">
<message-bus channel-factory="factory"/>
<beans:bean id="factory" class="org.springframework.integration.channel.factory.StubChannelFactory"/>
<beans:bean id="testChannel" class="org.springframework.integration.bus.DefaultChannelFactoryBean"/>
</beans:beans>

12
org.springframework.integration/src/test/java/org/springframework/integration/config/MessageBusParserTests.java
View File

@@ -37,9 +37,6 @@ import org.springframework.integration.bus.MessageBusInterceptorTests;
import org.springframework.integration.bus.TestMessageBusAwareImpl;
import org.springframework.integration.bus.TestMessageBusStartInterceptor;
import org.springframework.integration.bus.TestMessageBusStopInterceptor;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.channel.MessageChannel;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.integration.scheduling.TaskScheduler;
import org.springframework.integration.scheduling.spi.ProviderTaskScheduler;
@@ -115,15 +112,6 @@ public class MessageBusParserTests {
assertTrue(messageBusAware.getMessageBus() == context.getBean(MessageBusParser.MESSAGE_BUS_BEAN_NAME));
}
@Test
public void testMessageBusWithChannelFactory() {
ApplicationContext context = new ClassPathXmlApplicationContext("messageBusWithChannelFactory.xml",
this.getClass());
((MessageChannel)context.getBean("defaultTypeChannel")).getName();
assertEquals(DirectChannel.class, context.getBean("defaultTypeChannel").getClass());
assertEquals(QueueChannel.class, context.getBean("specifiedTypeChannel").getClass());
}
@Test
public void testMulticasterIsSyncByDefault() {
ApplicationContext context = new ClassPathXmlApplicationContext(

18
org.springframework.integration/src/test/java/org/springframework/integration/config/messageBusWithChannelFactory.xml
View File

@@ -1,18 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/integration"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/integration
http://www.springframework.org/schema/integration/spring-integration-core-1.0.xsd">
<message-bus/>
<beans:bean id="channelFactory" class="org.springframework.integration.channel.factory.DirectChannelFactory"/>
<channel id="defaultTypeChannel"/>
<queue-channel id="specifiedTypeChannel"/>
</beans:beans>