INT-789
This commit is contained in:
Oleg Zhurakousky
@@ -0,0 +1,198 @@
|
||||
/*
|
||||
* 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.interceptor;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
import org.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
import org.springframework.beans.BeansException;
|
||||
import org.springframework.beans.DirectFieldAccessor;
|
||||
import org.springframework.beans.factory.InitializingBean;
|
||||
import org.springframework.beans.factory.config.BeanPostProcessor;
|
||||
import org.springframework.core.OrderComparator;
|
||||
import org.springframework.integration.channel.AbstractMessageChannel;
|
||||
import org.springframework.integration.channel.ChannelInterceptor;
|
||||
import org.springframework.util.Assert;
|
||||
import org.springframework.util.CollectionUtils;
|
||||
|
||||
/**
|
||||
* Will apply global interceptors to channels (<channel-interceptor-chain>). Since global interceptors
|
||||
* could be Ordered or un-Ordered they will be sorted before merged with other interceptors in the channel.
|
||||
* Sorting will only be done within the given interceptor chain which itself defines 'order' attribute
|
||||
* essentially creating a group of ordered interceptors which are ordered internally and then these chain
|
||||
* groups are also ordered. For example:
|
||||
* <pre>
|
||||
* channel-interceptor-chain channel-name-pattern="foo" order="5" - positive order value means AFTER local channel interceptors
|
||||
* Ordered-global interceptor (4)
|
||||
* Ordered-global interceptor (1)
|
||||
* channel-interceptor-chain
|
||||
* channel-interceptor-chain channel-name-pattern="foo" order="-1" - negative order value means AFTER local channel interceptors
|
||||
* Ordered-global interceptor (3)
|
||||
* Ordered-global interceptor (10)
|
||||
* channel-interceptor-chain
|
||||
*
|
||||
* channel id="foo"
|
||||
* Ordered-in-channel interceptor (1)
|
||||
* channel
|
||||
*
|
||||
* will result in channel with the following interceptors
|
||||
* Channel "foo"
|
||||
* Ordered-global interceptor (3)
|
||||
* Ordered-global interceptor (10)
|
||||
* Ordered-in-channel interceptor (1)
|
||||
* Ordered-global interceptor (1)
|
||||
* Ordered-global interceptor (4)
|
||||
* </pre>
|
||||
*
|
||||
* @author Oleg Zhurakousky
|
||||
* @since 2.0
|
||||
*/
|
||||
final class GlobalChannelInterceptorBeanPostProcessor implements BeanPostProcessor, InitializingBean{
|
||||
private final static Log logger = LogFactory.getLog(GlobalChannelInterceptorBeanPostProcessor.class);
|
||||
private final OrderComparator comparator = new OrderComparator();
|
||||
private List<String> allAvailablePatters;
|
||||
private List<GlobalChannelInterceptorChain> globalInterceptors;
|
||||
|
||||
private List<GlobalChannelInterceptorChain> positiveOrderChains = new ArrayList<GlobalChannelInterceptorChain>();
|
||||
private List<GlobalChannelInterceptorChain> negativeOrderChains = new ArrayList<GlobalChannelInterceptorChain>();
|
||||
/**
|
||||
*
|
||||
* @param globalInterceptors
|
||||
*/
|
||||
GlobalChannelInterceptorBeanPostProcessor(List<GlobalChannelInterceptorChain> globalInterceptors){
|
||||
this.globalInterceptors = globalInterceptors;
|
||||
}
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessAfterInitialization(java.lang.Object, java.lang.String)
|
||||
*/
|
||||
public Object postProcessAfterInitialization(Object bean, String beanName)
|
||||
throws BeansException {
|
||||
return bean;
|
||||
}
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessBeforeInitialization(java.lang.Object, java.lang.String)
|
||||
*/
|
||||
public Object postProcessBeforeInitialization(Object bean, String beanName)
|
||||
throws BeansException {
|
||||
if (channelPatternMatches(beanName)){
|
||||
Assert.isTrue(bean instanceof AbstractMessageChannel, "channel interceptors can only be added to " +
|
||||
"AbstractMessageChannel. Current implementation is: " + bean.getClass());
|
||||
logger.debug("Applying global interceptors on channel '" + beanName + "'");
|
||||
this.mergeInterceptorsToChannel((AbstractMessageChannel) bean, beanName);
|
||||
}
|
||||
return bean;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param channel
|
||||
* @param channelName
|
||||
*/
|
||||
private void mergeInterceptorsToChannel(AbstractMessageChannel channel, String channelName){
|
||||
List<ChannelInterceptor> tInt = null;
|
||||
List<ChannelInterceptor> interceptors = this.getExistingInterceptors(channel);
|
||||
// POSITIVE
|
||||
List<GlobalChannelInterceptorChain> tempPositiveInterceptorChains = new ArrayList<GlobalChannelInterceptorChain>();
|
||||
for (GlobalChannelInterceptorChain positiveOrderChain : positiveOrderChains) {
|
||||
if (channelPatternMatches(channelName, positiveOrderChain.getPatterns())){
|
||||
tempPositiveInterceptorChains.add(positiveOrderChain);
|
||||
}
|
||||
}
|
||||
// sort chain
|
||||
Collections.sort(tempPositiveInterceptorChains, comparator);
|
||||
|
||||
for (GlobalChannelInterceptorChain globalChannelInterceptorChain : tempPositiveInterceptorChains) {
|
||||
tInt = globalChannelInterceptorChain.getInterceptors();
|
||||
// sort within the chain
|
||||
Collections.sort(tInt, comparator);
|
||||
interceptors.addAll(tInt);
|
||||
}
|
||||
// NEGATIVE
|
||||
List<GlobalChannelInterceptorChain> tempNegativeInterceptorChains = new ArrayList<GlobalChannelInterceptorChain>();
|
||||
for (GlobalChannelInterceptorChain negativeOrderChain : negativeOrderChains) {
|
||||
if (channelPatternMatches(channelName, negativeOrderChain.getPatterns())){
|
||||
tempNegativeInterceptorChains.add(negativeOrderChain);
|
||||
}
|
||||
}
|
||||
// sort chains
|
||||
Collections.sort(tempNegativeInterceptorChains, comparator);
|
||||
|
||||
for (GlobalChannelInterceptorChain globalChannelInterceptorChain : tempNegativeInterceptorChains) {
|
||||
tInt = globalChannelInterceptorChain.getInterceptors();
|
||||
// sort within the chain
|
||||
Collections.sort(tInt, comparator);
|
||||
interceptors.addAll(0, tInt);
|
||||
}
|
||||
}
|
||||
/*
|
||||
*
|
||||
*/
|
||||
private void filterPositiveNegativeOrderChains(){
|
||||
for (GlobalChannelInterceptorChain globalInterceptorChain : globalInterceptors) {
|
||||
if (globalInterceptorChain.getOrder() < 0){
|
||||
negativeOrderChains.add(globalInterceptorChain);
|
||||
} else {
|
||||
positiveOrderChains.add(globalInterceptorChain);
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
*
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
private List<ChannelInterceptor> getExistingInterceptors(AbstractMessageChannel channel){
|
||||
DirectFieldAccessor channelAccessor = new DirectFieldAccessor(channel);
|
||||
Object iWrapper = channelAccessor.getPropertyValue("interceptors");
|
||||
DirectFieldAccessor iWrapperAccessor = new DirectFieldAccessor(iWrapper);
|
||||
List<ChannelInterceptor> interceptors = (List<ChannelInterceptor>) iWrapperAccessor.getPropertyValue("interceptors");
|
||||
return interceptors;
|
||||
}
|
||||
/*
|
||||
*
|
||||
*/
|
||||
private boolean channelPatternMatches(String beanName, String... patternsToMatch){
|
||||
String[] patterns = null;
|
||||
if (patternsToMatch.length > 0){
|
||||
patterns = patternsToMatch;
|
||||
} else {
|
||||
patterns = allAvailablePatters.toArray(new String[]{});
|
||||
}
|
||||
for (String channelPattern : patterns) {
|
||||
Pattern p = Pattern.compile(channelPattern.trim());
|
||||
Matcher m = p.matcher(beanName);
|
||||
if (m.find()){
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public void afterPropertiesSet() throws Exception {
|
||||
allAvailablePatters = new ArrayList<String>();
|
||||
for (GlobalChannelInterceptorChain globalInterceptorchain : globalInterceptors) {
|
||||
allAvailablePatters.addAll(CollectionUtils.arrayToList(globalInterceptorchain.getPatterns()));
|
||||
}
|
||||
this.filterPositiveNegativeOrderChains();
|
||||
logger.info("Initialized: '" + this.getClass().getSimpleName() + "' to apply global channel interceptors");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
/*
|
||||
* 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.interceptor;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.springframework.core.Ordered;
|
||||
import org.springframework.integration.channel.ChannelInterceptor;
|
||||
|
||||
/**
|
||||
* @author Oleg Zhurakousky
|
||||
* @since 2.0
|
||||
*/
|
||||
final class GlobalChannelInterceptorChain implements Ordered{
|
||||
private List<ChannelInterceptor> interceptors;
|
||||
private String[] patterns;
|
||||
|
||||
private int order;
|
||||
|
||||
public GlobalChannelInterceptorChain(List<ChannelInterceptor> interceptors, String[] patterns, int order){
|
||||
this.interceptors = interceptors;
|
||||
this.patterns = patterns;
|
||||
this.order = order;
|
||||
}
|
||||
|
||||
List<ChannelInterceptor> getInterceptors(){
|
||||
return interceptors;
|
||||
}
|
||||
|
||||
String[] getPatterns() {
|
||||
return patterns;
|
||||
}
|
||||
|
||||
public String toString(){
|
||||
return interceptors.toString();
|
||||
}
|
||||
|
||||
public int getOrder() {
|
||||
return order;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
/*
|
||||
* 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.xml;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.springframework.beans.factory.config.BeanDefinition;
|
||||
import org.springframework.beans.factory.config.BeanDefinitionHolder;
|
||||
import org.springframework.beans.factory.config.RuntimeBeanReference;
|
||||
import org.springframework.beans.factory.parsing.BeanComponentDefinition;
|
||||
import org.springframework.beans.factory.support.AbstractBeanDefinition;
|
||||
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
|
||||
import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
|
||||
import org.springframework.beans.factory.support.ManagedList;
|
||||
import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
|
||||
import org.springframework.beans.factory.xml.BeanDefinitionParserDelegate;
|
||||
import org.springframework.beans.factory.xml.ParserContext;
|
||||
import org.springframework.util.StringUtils;
|
||||
import org.springframework.util.xml.DomUtils;
|
||||
import org.w3c.dom.Element;
|
||||
|
||||
/**
|
||||
* Will parse 'channel-interceptor-chain' element
|
||||
*
|
||||
* @author Oleg Zhurakousky
|
||||
* @since 2.0
|
||||
*/
|
||||
public class GlobalChannelInterceptorParser extends AbstractBeanDefinitionParser {
|
||||
private static final String CONFIG_PACKAGE = IntegrationNamespaceUtils.BASE_PACKAGE + ".channel.interceptor.";
|
||||
private final ManagedList<RuntimeBeanReference> globalInterceptorChains = new ManagedList<RuntimeBeanReference>();
|
||||
private final String GLOBAL_NAME_PATTERN_ATTR = "channel-name-pattern";
|
||||
private final String REF_ATTR = "ref";
|
||||
private final String BEAN_ATTR = "bean";
|
||||
private final String ORDER_ATTR = "order";
|
||||
private final String INTERCEPTOR_CHAIN_CLASS = "GlobalChannelInterceptorChain";
|
||||
private final String GLOBAL_POST_PROCESSOR_CLASS = "GlobalChannelInterceptorBeanPostProcessor";
|
||||
|
||||
private boolean postProcessorCreated;
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#parseInternal(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext)
|
||||
*/
|
||||
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
|
||||
this.createAndRegisterGlobalPostProcessorIfNeeded(parserContext);
|
||||
|
||||
List<Element> interceptorElements = DomUtils.getChildElementsByTagName(element, new String[]{REF_ATTR, BEAN_ATTR});
|
||||
|
||||
BeanDefinitionBuilder globalChannelInterceptorBuilder =
|
||||
BeanDefinitionBuilder.genericBeanDefinition(CONFIG_PACKAGE + INTERCEPTOR_CHAIN_CLASS);
|
||||
String[] channelPatterns = element.getAttribute(GLOBAL_NAME_PATTERN_ATTR).split(",");
|
||||
int order = this.getOrderAttribute(element);
|
||||
|
||||
ManagedList<RuntimeBeanReference> adviceChain = new ManagedList<RuntimeBeanReference>();
|
||||
for (Element interceptorElement : interceptorElements) {
|
||||
if (interceptorElement.getNodeName().equals(BEAN_ATTR)){
|
||||
BeanDefinitionParserDelegate delegate = parserContext.getDelegate();
|
||||
BeanDefinitionHolder holder = delegate.parseBeanDefinitionElement(interceptorElement);
|
||||
// needed for p: namespace
|
||||
holder = delegate.decorateBeanDefinitionIfRequired(interceptorElement, holder);
|
||||
parserContext.registerBeanComponent(new BeanComponentDefinition(holder));
|
||||
adviceChain.add(new RuntimeBeanReference(holder.getBeanName()));
|
||||
} else if (interceptorElement.getNodeName().equals(REF_ATTR)) {
|
||||
String ref = interceptorElement.getAttribute(BEAN_ATTR);
|
||||
adviceChain.add(new RuntimeBeanReference(ref));
|
||||
}
|
||||
}
|
||||
globalChannelInterceptorBuilder.addConstructorArgValue(adviceChain);
|
||||
globalChannelInterceptorBuilder.addConstructorArgValue(channelPatterns);
|
||||
globalChannelInterceptorBuilder.addConstructorArgValue(order);
|
||||
AbstractBeanDefinition interceptorChainDef = globalChannelInterceptorBuilder.getBeanDefinition();
|
||||
String interceptorChainName =
|
||||
BeanDefinitionReaderUtils.generateBeanName(interceptorChainDef, parserContext.getRegistry());
|
||||
parserContext.registerBeanComponent(new BeanComponentDefinition(interceptorChainDef, interceptorChainName));
|
||||
globalInterceptorChains.add(new RuntimeBeanReference(interceptorChainName));
|
||||
return null;
|
||||
}
|
||||
/*
|
||||
*
|
||||
*/
|
||||
private int getOrderAttribute(Element element){
|
||||
String sOrder = element.getAttribute(ORDER_ATTR);
|
||||
if (StringUtils.hasText(sOrder)){
|
||||
return Integer.parseInt(sOrder);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/*
|
||||
*
|
||||
*/
|
||||
private void createAndRegisterGlobalPostProcessorIfNeeded(ParserContext parserContext){
|
||||
if (!postProcessorCreated){
|
||||
BeanDefinitionBuilder postProcessorBuilder =
|
||||
BeanDefinitionBuilder.genericBeanDefinition(CONFIG_PACKAGE + GLOBAL_POST_PROCESSOR_CLASS);
|
||||
BeanDefinition beanDef = postProcessorBuilder.getBeanDefinition();
|
||||
postProcessorBuilder.addConstructorArgValue(globalInterceptorChains);
|
||||
String beanName =
|
||||
BeanDefinitionReaderUtils.generateBeanName(beanDef, parserContext.getRegistry());
|
||||
parserContext.registerBeanComponent(new BeanComponentDefinition(beanDef, beanName));
|
||||
postProcessorCreated = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -56,6 +56,7 @@ public class IntegrationNamespaceHandler extends AbstractIntegrationNamespaceHan
|
||||
registerBeanDefinitionParser("annotation-config", new AnnotationConfigParser());
|
||||
registerBeanDefinitionParser("application-event-multicaster", new ApplicationEventMulticasterParser());
|
||||
registerBeanDefinitionParser("publisher", new PublisherParser());
|
||||
registerBeanDefinitionParser("channel-interceptor-chain", new GlobalChannelInterceptorParser());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -1653,5 +1653,36 @@
|
||||
</xsd:attribute>
|
||||
</xsd:complexType>
|
||||
</xsd:element>
|
||||
|
||||
|
||||
<xsd:element name="channel-interceptor-chain">
|
||||
<xsd:complexType>
|
||||
<xsd:sequence>
|
||||
<xsd:element ref="beans:ref" minOccurs="0" maxOccurs="unbounded"/>
|
||||
<xsd:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xsd:element ref="beans:bean"/>
|
||||
<xsd:element ref="beans:ref"/>
|
||||
</xsd:choice>
|
||||
</xsd:sequence>
|
||||
<xsd:attribute name="channel-name-pattern" type="xsd:string" use="required">
|
||||
<xsd:annotation>
|
||||
<xsd:documentation>
|
||||
[REQUIRED] Channel name(s) or patterns. To specify more then one channel use ','
|
||||
(e.g., channel-name-pattern="input*, foo, bar")
|
||||
</xsd:documentation>
|
||||
</xsd:annotation>
|
||||
</xsd:attribute>
|
||||
<xsd:attribute name="order" type="xsd:integer" use="optional">
|
||||
<xsd:annotation>
|
||||
<xsd:documentation>
|
||||
[OPTIONAL] Specifies the order in which these interceptors will be
|
||||
added to the existing channel interceptors (if any).
|
||||
Negative value (e.g., -2) will signify AFTER, but BEFORE the
|
||||
the chain that might specify -1 (if any). Positive value (e.g., 2)
|
||||
will signify BEFORE, but AFTER the chain that might specify 1 (if any).
|
||||
</xsd:documentation>
|
||||
</xsd:annotation>
|
||||
</xsd:attribute>
|
||||
</xsd:complexType>
|
||||
</xsd:element>
|
||||
|
||||
</xsd:schema>
|
||||
Reference in New Issue
Block a user