diff --git a/spring-integration-core/src/main/java/org/springframework/integration/config/AbstractMessageHandlerFactoryBean.java b/spring-integration-core/src/main/java/org/springframework/integration/config/AbstractMessageHandlerFactoryBean.java
index d3ebf8132b..c1fa40d743 100644
--- a/spring-integration-core/src/main/java/org/springframework/integration/config/AbstractMessageHandlerFactoryBean.java
+++ b/spring-integration-core/src/main/java/org/springframework/integration/config/AbstractMessageHandlerFactoryBean.java
@@ -16,6 +16,8 @@
 
 package org.springframework.integration.config;
 
+import org.springframework.aop.TargetSource;
+import org.springframework.aop.framework.Advised;
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
@@ -28,8 +30,8 @@ import org.springframework.expression.spel.SpelParserConfiguration;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
 import org.springframework.integration.MessageChannel;
 import org.springframework.integration.core.MessageHandler;
+import org.springframework.integration.core.MessageProducer;
 import org.springframework.integration.handler.AbstractMessageHandler;
-import org.springframework.integration.handler.AbstractReplyProducingMessageHandler;
 import org.springframework.integration.handler.MessageProcessor;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
@@ -100,8 +102,8 @@ abstract class AbstractMessageHandlerFactoryBean implements FactoryBean<MessageH
 		if (this.handler == null) {
 			this.initializeHandler();
 			Assert.notNull(this.handler, "failed to create MessageHandler");
-			if (this.handler instanceof AbstractReplyProducingMessageHandler && this.outputChannel != null) {
-				((AbstractReplyProducingMessageHandler) this.handler).setOutputChannel(this.outputChannel);
+			if (this.handler instanceof MessageProducer && this.outputChannel != null) {
+				((MessageProducer) this.handler).setOutputChannel(this.outputChannel);
 			}
 			if (this.handler instanceof BeanFactoryAware) {
 				((BeanFactoryAware) this.handler).setBeanFactory(beanFactory);
@@ -182,4 +184,27 @@ abstract class AbstractMessageHandlerFactoryBean implements FactoryBean<MessageH
 			"Exactly one of the 'targetObject' or 'expression' property is required.");
 	}
 
+	@SuppressWarnings("unchecked")
+	<T> T extractTypeIfPossible(Object targetObject, Class<T> expectedType) {
+		if (targetObject == null) {
+			return null;
+		}
+		if (expectedType.isAssignableFrom(targetObject.getClass())) {
+			return (T) targetObject;
+		}
+		if (targetObject instanceof Advised) {
+			TargetSource targetSource = ((Advised) targetObject).getTargetSource();
+			if (targetSource == null) {
+				return null;
+			}
+			try {
+				return extractTypeIfPossible(targetSource.getTarget(), expectedType);
+			}
+			catch (Exception e) {
+				throw new IllegalStateException(e);
+			}
+		}
+		return null;
+	}
+
 }
diff --git a/spring-integration-core/src/main/java/org/springframework/integration/config/RouterFactoryBean.java b/spring-integration-core/src/main/java/org/springframework/integration/config/RouterFactoryBean.java
index cb0295f96c..ba95bf6eb4 100644
--- a/spring-integration-core/src/main/java/org/springframework/integration/config/RouterFactoryBean.java
+++ b/spring-integration-core/src/main/java/org/springframework/integration/config/RouterFactoryBean.java
@@ -15,8 +15,6 @@ package org.springframework.integration.config;
 
 import java.util.Map;
 
-import org.springframework.aop.TargetSource;
-import org.springframework.aop.framework.Advised;
 import org.springframework.expression.Expression;
 import org.springframework.integration.MessageChannel;
 import org.springframework.integration.core.MessageHandler;
@@ -33,6 +31,7 @@ import org.springframework.util.StringUtils;
  * @author Mark Fisher
  * @author Jonas Partner
  * @author Oleg Zhurakousky
+ * @author Dave Syer
  */
 public class RouterFactoryBean extends AbstractMessageHandlerFactoryBean {
 
@@ -88,51 +87,28 @@ public class RouterFactoryBean extends AbstractMessageHandlerFactoryBean {
 	@Override
 	MessageHandler createMethodInvokingHandler(Object targetObject, String targetMethodName) {
 		Assert.notNull(targetObject, "target object must not be null");
-		AbstractMessageRouter router = extractRouter(targetObject);
+		AbstractMessageRouter router = this.extractTypeIfPossible(targetObject, AbstractMessageRouter.class);
 		if (router == null) {
-			router = this.createRouter(targetObject, targetMethodName);
+			router = this.createMethodInvokingRouter(targetObject, targetMethodName);
 			this.configureRouter(router);
-			return router;
 		}
-
-		Assert.isTrue(!StringUtils.hasText(targetMethodName), "target method should not be provided when the target "
-				+ "object is an implementation of AbstractMessageRouter");
-		this.configureRouter(router);
-		if (targetObject instanceof MessageHandler) {
-			return (MessageHandler) targetObject;
+		else {
+			Assert.isTrue(!StringUtils.hasText(targetMethodName), "target method should not be provided when the target "
+					+ "object is an implementation of AbstractMessageRouter");
+			this.configureRouter(router);
+			if (targetObject instanceof MessageHandler) {
+				return (MessageHandler) targetObject;
+			}
 		}
 		return router;
 	}
 
-	private AbstractMessageRouter extractRouter(Object targetObject) {
-		if (targetObject instanceof AbstractMessageRouter) {
-			return (AbstractMessageRouter) targetObject;
-		}
-		if (targetObject instanceof Advised) {
-			return extractAopTarget((Advised) targetObject);
-		}
-		return null;
-	}
-
-	private AbstractMessageRouter extractAopTarget(Advised advised) {
-		TargetSource targetSource = advised.getTargetSource();
-		if (targetSource == null) {
-			return null;
-		}
-		try {
-			return extractRouter(targetSource.getTarget());
-		}
-		catch (Exception e) {
-			throw new IllegalStateException(e);
-		}
-	}
-
 	@Override
 	MessageHandler createExpressionEvaluatingHandler(Expression expression) {
 		return this.configureRouter(new ExpressionEvaluatingRouter(expression));
 	}
 
-	private AbstractMessageRouter createRouter(Object targetObject, String targetMethodName) {
+	private AbstractMessageRouter createMethodInvokingRouter(Object targetObject, String targetMethodName) {
 		MethodInvokingRouter router = (StringUtils.hasText(targetMethodName)) 
 				? new MethodInvokingRouter(targetObject, targetMethodName)
 				: new MethodInvokingRouter(targetObject);
diff --git a/spring-integration-core/src/main/java/org/springframework/integration/config/SplitterFactoryBean.java b/spring-integration-core/src/main/java/org/springframework/integration/config/SplitterFactoryBean.java
index 31dc216dcb..a158603081 100644
--- a/spring-integration-core/src/main/java/org/springframework/integration/config/SplitterFactoryBean.java
+++ b/spring-integration-core/src/main/java/org/springframework/integration/config/SplitterFactoryBean.java
@@ -22,6 +22,7 @@ import org.springframework.integration.splitter.AbstractMessageSplitter;
 import org.springframework.integration.splitter.DefaultMessageSplitter;
 import org.springframework.integration.splitter.ExpressionEvaluatingSplitter;
 import org.springframework.integration.splitter.MethodInvokingSplitter;
+import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
 /**
@@ -50,16 +51,27 @@ public class SplitterFactoryBean extends AbstractMessageHandlerFactoryBean {
 
 	@Override
 	MessageHandler createMethodInvokingHandler(Object targetObject, String targetMethodName) {
-		AbstractMessageSplitter splitter = null;
-		if (targetObject instanceof AbstractMessageSplitter) {
-			splitter = (AbstractMessageSplitter) targetObject;
+		Assert.notNull(targetObject, "targetObject must not be null");
+		AbstractMessageSplitter splitter = this.extractTypeIfPossible(targetObject, AbstractMessageSplitter.class);
+		if (splitter == null) {
+			splitter = this.createMethodInvokingSplitter(targetObject, targetMethodName);
+			this.configureSplitter(splitter);
 		}
 		else {
-			splitter = (StringUtils.hasText(targetMethodName))
-					? new MethodInvokingSplitter(targetObject, targetMethodName)
-					: new MethodInvokingSplitter(targetObject);
+			Assert.isTrue(!StringUtils.hasText(targetMethodName), "target method should not be provided when the target "
+					+ "object is an implementation of AbstractMessageSplitter");
+			this.configureSplitter(splitter);
+			if (targetObject instanceof MessageHandler) {
+				return (MessageHandler) targetObject;
+			}
 		}
-		return this.configureSplitter(splitter);
+		return splitter;
+	}
+
+	private AbstractMessageSplitter createMethodInvokingSplitter(Object targetObject, String targetMethodName) {
+		return (StringUtils.hasText(targetMethodName))
+				? new MethodInvokingSplitter(targetObject, targetMethodName)
+				: new MethodInvokingSplitter(targetObject);
 	}
 
 	@Override