diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/AbstractMethodAnnotationPostProcessor.java b/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/AbstractMethodAnnotationPostProcessor.java index d07dcd8b77..1da317e6e0 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/AbstractMethodAnnotationPostProcessor.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/AbstractMethodAnnotationPostProcessor.java @@ -18,10 +18,6 @@ package org.springframework.integration.config.annotation; import java.lang.annotation.Annotation; import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.List; - -import org.aopalliance.aop.Advice; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.ListableBeanFactory; @@ -40,13 +36,6 @@ import org.springframework.integration.endpoint.MessageEndpoint; import org.springframework.integration.endpoint.PollingConsumerEndpoint; import org.springframework.integration.endpoint.SubscribingConsumerEndpoint; import org.springframework.integration.message.MessageConsumer; -import org.springframework.integration.scheduling.IntervalTrigger; -import org.springframework.transaction.PlatformTransactionManager; -import org.springframework.transaction.annotation.Transactional; -import org.springframework.transaction.interceptor.NoRollbackRuleAttribute; -import org.springframework.transaction.interceptor.RollbackRuleAttribute; -import org.springframework.transaction.interceptor.RuleBasedTransactionAttribute; -import org.springframework.transaction.interceptor.TransactionAttribute; import org.springframework.util.Assert; import org.springframework.util.StringUtils; @@ -112,33 +101,8 @@ public abstract class AbstractMethodAnnotationPostProcessor 0) { - List adviceChain = new ArrayList(); - for (String adviceChainString : adviceChainArray) { - String[] adviceRefs = StringUtils.tokenizeToStringArray(adviceChainString, ","); - for (String adviceRef : adviceRefs) { - adviceChain.add(this.beanFactoryAccessor.getBean(adviceRef, Advice.class)); - } - } - pollingEndpoint.setAdviceChain(adviceChain); - } + AnnotationConfigUtils.configurePollingEndpointWithPollerAnnotation( + pollingEndpoint, pollerAnnotation, this.beanFactoryAccessor.getBeanFactory()); } endpoint = pollingEndpoint; } @@ -164,41 +128,6 @@ public abstract class AbstractMethodAnnotationPostProcessor rollBackRules = new ArrayList(); - Class[] rbf = annotation.rollbackFor(); - for (int i = 0; i < rbf.length; ++i) { - RollbackRuleAttribute rule = new RollbackRuleAttribute(rbf[i]); - rollBackRules.add(rule); - } - String[] rbfc = annotation.rollbackForClassName(); - for (int i = 0; i < rbfc.length; ++i) { - RollbackRuleAttribute rule = new RollbackRuleAttribute(rbfc[i]); - rollBackRules.add(rule); - } - Class[] nrbf = annotation.noRollbackFor(); - for (int i = 0; i < nrbf.length; ++i) { - NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(nrbf[i]); - rollBackRules.add(rule); - } - String[] nrbfc = annotation.noRollbackForClassName(); - for (int i = 0; i < nrbfc.length; ++i) { - NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(nrbfc[i]); - rollBackRules.add(rule); - } - rbta.getRollbackRules().addAll(rollBackRules); - return rbta; - } - /** * Subclasses must implement this method to create the MessageConsumer. */ diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/AnnotationConfigUtils.java b/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/AnnotationConfigUtils.java new file mode 100644 index 0000000000..490dae08a8 --- /dev/null +++ b/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/AnnotationConfigUtils.java @@ -0,0 +1,116 @@ +/* + * 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.annotation; + +import java.util.ArrayList; +import java.util.List; + +import org.aopalliance.aop.Advice; + +import org.springframework.beans.factory.BeanFactory; +import org.springframework.integration.annotation.Poller; +import org.springframework.integration.endpoint.AbstractPollingEndpoint; +import org.springframework.integration.scheduling.IntervalTrigger; +import org.springframework.integration.scheduling.Trigger; +import org.springframework.transaction.PlatformTransactionManager; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.interceptor.NoRollbackRuleAttribute; +import org.springframework.transaction.interceptor.RollbackRuleAttribute; +import org.springframework.transaction.interceptor.RuleBasedTransactionAttribute; +import org.springframework.transaction.interceptor.TransactionAttribute; +import org.springframework.util.Assert; +import org.springframework.util.StringUtils; + +/** + * Utility methods for working with annotations on Messaging components. + * + * @author Mark Fisher + */ +public abstract class AnnotationConfigUtils { + + public static void configurePollingEndpointWithPollerAnnotation( + AbstractPollingEndpoint endpoint, Poller pollerAnnotation, BeanFactory beanFactory) { + Trigger trigger = parseTriggerFromPollerAnnotation(pollerAnnotation); + endpoint.setTrigger(trigger); + endpoint.setMaxMessagesPerPoll(pollerAnnotation.maxMessagesPerPoll()); + if (StringUtils.hasText(pollerAnnotation.transactionManager())) { + String txManagerRef = pollerAnnotation.transactionManager(); + Assert.isTrue(beanFactory.containsBean(txManagerRef), + "failed to resolve transactionManager reference, no such bean '" + txManagerRef + "'"); + PlatformTransactionManager txManager = (PlatformTransactionManager) + beanFactory.getBean(txManagerRef, PlatformTransactionManager.class); + endpoint.setTransactionManager(txManager); + Transactional txAnnotation = pollerAnnotation.transactionAttributes(); + endpoint.setTransactionDefinition(parseTransactionAnnotation(txAnnotation)); + } + String[] adviceChainArray = pollerAnnotation.adviceChain(); + if (adviceChainArray.length > 0) { + List adviceChain = new ArrayList(); + for (String adviceChainString : adviceChainArray) { + String[] adviceRefs = StringUtils.tokenizeToStringArray(adviceChainString, ","); + for (String adviceRef : adviceRefs) { + adviceChain.add((Advice) beanFactory.getBean(adviceRef, Advice.class)); + } + } + endpoint.setAdviceChain(adviceChain); + } + } + + public static Trigger parseTriggerFromPollerAnnotation(Poller pollerAnnotation) { + IntervalTrigger trigger = new IntervalTrigger( + pollerAnnotation.interval(), pollerAnnotation.timeUnit()); + trigger.setInitialDelay(pollerAnnotation.initialDelay(), pollerAnnotation.timeUnit()); + trigger.setFixedRate(pollerAnnotation.fixedRate()); + return trigger; + } + + @SuppressWarnings("unchecked") + public static TransactionAttribute parseTransactionAnnotation(Transactional annotation) { + if (annotation == null) { + return null; + } + RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute(); + rbta.setPropagationBehavior(annotation.propagation().value()); + rbta.setIsolationLevel(annotation.isolation().value()); + rbta.setTimeout(annotation.timeout()); + rbta.setReadOnly(annotation.readOnly()); + ArrayList rollBackRules = new ArrayList(); + Class[] rbf = annotation.rollbackFor(); + for (int i = 0; i < rbf.length; ++i) { + RollbackRuleAttribute rule = new RollbackRuleAttribute(rbf[i]); + rollBackRules.add(rule); + } + String[] rbfc = annotation.rollbackForClassName(); + for (int i = 0; i < rbfc.length; ++i) { + RollbackRuleAttribute rule = new RollbackRuleAttribute(rbfc[i]); + rollBackRules.add(rule); + } + Class[] nrbf = annotation.noRollbackFor(); + for (int i = 0; i < nrbf.length; ++i) { + NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(nrbf[i]); + rollBackRules.add(rule); + } + String[] nrbfc = annotation.noRollbackForClassName(); + for (int i = 0; i < nrbfc.length; ++i) { + NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(nrbfc[i]); + rollBackRules.add(rule); + } + rbta.getRollbackRules().addAll(rollBackRules); + return rbta; + } + +} diff --git a/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/ChannelAdapterAnnotationPostProcessor.java b/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/ChannelAdapterAnnotationPostProcessor.java index 788f5e0df1..8618548c4f 100644 --- a/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/ChannelAdapterAnnotationPostProcessor.java +++ b/org.springframework.integration/src/main/java/org/springframework/integration/config/annotation/ChannelAdapterAnnotationPostProcessor.java @@ -17,10 +17,6 @@ package org.springframework.integration.config.annotation; import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.List; - -import org.aopalliance.aop.Advice; import org.springframework.beans.factory.config.ConfigurableBeanFactory; import org.springframework.core.annotation.AnnotationUtils; @@ -40,15 +36,8 @@ import org.springframework.integration.message.MethodInvokingConsumer; import org.springframework.integration.message.MethodInvokingSource; import org.springframework.integration.scheduling.IntervalTrigger; import org.springframework.integration.scheduling.Trigger; -import org.springframework.transaction.PlatformTransactionManager; -import org.springframework.transaction.annotation.Transactional; -import org.springframework.transaction.interceptor.NoRollbackRuleAttribute; -import org.springframework.transaction.interceptor.RollbackRuleAttribute; -import org.springframework.transaction.interceptor.RuleBasedTransactionAttribute; -import org.springframework.transaction.interceptor.TransactionAttribute; import org.springframework.util.Assert; import org.springframework.util.ClassUtils; -import org.springframework.util.StringUtils; /** * Post-processor for methods annotated with {@link ChannelAdapter @ChannelAdapter}. @@ -95,7 +84,7 @@ public class ChannelAdapterAnnotationPostProcessor implements MethodAnnotationPo else { throw new IllegalArgumentException("The @ChannelAdapter can only be applied to methods" + " that accept no arguments but have a return value (inbound) or methods that" - + " have no return value but do accept arguments (outbound)"); + + " have no return value but do accept arguments (outbound)."); } if (endpoint != null) { String annotationName = ClassUtils.getShortNameAsProperty(annotation.annotationType()); @@ -108,39 +97,18 @@ public class ChannelAdapterAnnotationPostProcessor implements MethodAnnotationPo private SourcePollingChannelAdapter createInboundChannelAdapter(MethodInvokingSource source, MessageChannel channel, Poller pollerAnnotation) { Assert.notNull(pollerAnnotation, "The @Poller annotation is required (at method-level) " + "when using the @ChannelAdapter annotation with a no-arg method."); - Trigger trigger = this.createTrigger(pollerAnnotation); SourcePollingChannelAdapter adapter = new SourcePollingChannelAdapter(); adapter.setSource(source); adapter.setOutputChannel(channel); - adapter.setTrigger(trigger); - if (StringUtils.hasText(pollerAnnotation.transactionManager())) { - String txManagerRef = pollerAnnotation.transactionManager(); - Assert.isTrue(this.beanFactory.containsBean(txManagerRef), - "failed to resolve transactionManager reference, no such bean '" + txManagerRef + "'"); - PlatformTransactionManager txManager = (PlatformTransactionManager) - this.beanFactory.getBean(txManagerRef, PlatformTransactionManager.class); - adapter.setTransactionManager(txManager); - Transactional txAnnotation = pollerAnnotation.transactionAttributes(); - adapter.setTransactionDefinition(this.parseTransactionAnnotation(txAnnotation)); - } - String[] adviceChainArray = pollerAnnotation.adviceChain(); - if (adviceChainArray.length > 0) { - List adviceChain = new ArrayList(); - for (String adviceChainString : adviceChainArray) { - String[] adviceRefs = StringUtils.tokenizeToStringArray(adviceChainString, ","); - for (String adviceRef : adviceRefs) { - adviceChain.add((Advice) this.beanFactory.getBean(adviceRef, Advice.class)); - } - } - adapter.setAdviceChain(adviceChain); - } + AnnotationConfigUtils.configurePollingEndpointWithPollerAnnotation( + adapter, pollerAnnotation, this.beanFactory); return adapter; } private MessageEndpoint createOutboundChannelAdapter(MethodInvokingConsumer consumer, MessageChannel channel, Poller pollerAnnotation) { if (channel instanceof PollableChannel) { Trigger trigger = (pollerAnnotation != null) - ? this.createTrigger(pollerAnnotation) + ? AnnotationConfigUtils.parseTriggerFromPollerAnnotation(pollerAnnotation) : new IntervalTrigger(0); PollingConsumerEndpoint endpoint = new PollingConsumerEndpoint(consumer, (PollableChannel) channel); endpoint.setTrigger(trigger); @@ -152,51 +120,8 @@ public class ChannelAdapterAnnotationPostProcessor implements MethodAnnotationPo return null; } - private Trigger createTrigger(Poller pollerAnnotation) { - IntervalTrigger trigger = new IntervalTrigger( - pollerAnnotation.interval(), pollerAnnotation.timeUnit()); - trigger.setInitialDelay(pollerAnnotation.initialDelay()); - trigger.setFixedRate(pollerAnnotation.fixedRate()); - return trigger; - } - private boolean hasReturnValue(Method method) { return !method.getReturnType().equals(void.class); } - @SuppressWarnings("unchecked") - private TransactionAttribute parseTransactionAnnotation(Transactional annotation) { - if (annotation == null) { - return null; - } - RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute(); - rbta.setPropagationBehavior(annotation.propagation().value()); - rbta.setIsolationLevel(annotation.isolation().value()); - rbta.setTimeout(annotation.timeout()); - rbta.setReadOnly(annotation.readOnly()); - ArrayList rollBackRules = new ArrayList(); - Class[] rbf = annotation.rollbackFor(); - for (int i = 0; i < rbf.length; ++i) { - RollbackRuleAttribute rule = new RollbackRuleAttribute(rbf[i]); - rollBackRules.add(rule); - } - String[] rbfc = annotation.rollbackForClassName(); - for (int i = 0; i < rbfc.length; ++i) { - RollbackRuleAttribute rule = new RollbackRuleAttribute(rbfc[i]); - rollBackRules.add(rule); - } - Class[] nrbf = annotation.noRollbackFor(); - for (int i = 0; i < nrbf.length; ++i) { - NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(nrbf[i]); - rollBackRules.add(rule); - } - String[] nrbfc = annotation.noRollbackForClassName(); - for (int i = 0; i < nrbfc.length; ++i) { - NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(nrbfc[i]); - rollBackRules.add(rule); - } - rbta.getRollbackRules().addAll(rollBackRules); - return rbta; - } - }