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

INT-1489 refactored SplitterFactoryBean to accommodate AOP proxies, and replaced an instanceof check for a concrete class to one for the MessageProducer interface

Browse Source
This commit is contained in:
Mark Fisher
2010-10-15 17:52:52 -04:00
parent 6b18489caa
commit d1dd9862a0
3 changed files with 58 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
spring-integration-core/src/main/java/org/springframework/integration/config/AbstractMessageHandlerFactoryBean.java
View File

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

46
spring-integration-core/src/main/java/org/springframework/integration/config/RouterFactoryBean.java
View File

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

26
spring-integration-core/src/main/java/org/springframework/integration/config/SplitterFactoryBean.java
View File

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