ComponentScanBeanDefinitionParser supports placeholders for entire base-package specification and for type filter expressions

jhoeller · jhoeller · commit e52f041a78a4 · 2014-09-25T01:03:08.000+02:00
Issue: SPR-10424
Issue: SPR-10425
diff --git a/spring-context/src/main/java/org/springframework/context/annotation/ComponentScanBeanDefinitionParser.java b/spring-context/src/main/java/org/springframework/context/annotation/ComponentScanBeanDefinitionParser.java
@@ -77,7 +77,9 @@ public class ComponentScanBeanDefinitionParser implements BeanDefinitionParser {
 
 	@Override
 	public BeanDefinition parse(Element element, ParserContext parserContext) {
-		String[] basePackages = StringUtils.tokenizeToStringArray(element.getAttribute(BASE_PACKAGE_ATTRIBUTE),
+		String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
+		basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
+		String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
 				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
 
 		// Actually scan for bean definitions and register them.
@@ -89,17 +91,15 @@ public BeanDefinition parse(Element element, ParserContext parserContext) {
 	}
 
 	protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
-		XmlReaderContext readerContext = parserContext.getReaderContext();
-
 		boolean useDefaultFilters = true;
 		if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
 			useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
 		}
 
 		// Delegate bean definition registration to scanner class.
-		ClassPathBeanDefinitionScanner scanner = createScanner(readerContext, useDefaultFilters);
-		scanner.setResourceLoader(readerContext.getResourceLoader());
-		scanner.setEnvironment(parserContext.getDelegate().getEnvironment());
+		ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
+		scanner.setResourceLoader(parserContext.getReaderContext().getResourceLoader());
+		scanner.setEnvironment(parserContext.getReaderContext().getEnvironment());
 		scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
 		scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());
 
@@ -111,17 +111,17 @@ protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserCo
 			parseBeanNameGenerator(element, scanner);
 		}
 		catch (Exception ex) {
-			readerContext.error(ex.getMessage(), readerContext.extractSource(element), ex.getCause());
+			parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
 		}
 
 		try {
 			parseScope(element, scanner);
 		}
 		catch (Exception ex) {
-			readerContext.error(ex.getMessage(), readerContext.extractSource(element), ex.getCause());
+			parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
 		}
 
-		parseTypeFilters(element, scanner, readerContext, parserContext);
+		parseTypeFilters(element, scanner, parserContext);
 
 		return scanner;
 	}
@@ -195,9 +195,7 @@ else if ("no".equals(mode)) {
 		}
 	}
 
-	protected void parseTypeFilters(
-			Element element, ClassPathBeanDefinitionScanner scanner, XmlReaderContext readerContext, ParserContext parserContext) {
-
+	protected void parseTypeFilters(Element element, ClassPathBeanDefinitionScanner scanner, ParserContext parserContext) {
 		// Parse exclude and include filter elements.
 		ClassLoader classLoader = scanner.getResourceLoader().getClassLoader();
 		NodeList nodeList = element.getChildNodes();
@@ -207,25 +205,27 @@ protected void parseTypeFilters(
 				String localName = parserContext.getDelegate().getLocalName(node);
 				try {
 					if (INCLUDE_FILTER_ELEMENT.equals(localName)) {
-						TypeFilter typeFilter = createTypeFilter((Element) node, classLoader);
+						TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);
 						scanner.addIncludeFilter(typeFilter);
 					}
 					else if (EXCLUDE_FILTER_ELEMENT.equals(localName)) {
-						TypeFilter typeFilter = createTypeFilter((Element) node, classLoader);
+						TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);
 						scanner.addExcludeFilter(typeFilter);
 					}
 				}
 				catch (Exception ex) {
-					readerContext.error(ex.getMessage(), readerContext.extractSource(element), ex.getCause());
+					parserContext.getReaderContext().error(
+							ex.getMessage(), parserContext.extractSource(element), ex.getCause());
 				}
 			}
 		}
 	}
 
 	@SuppressWarnings("unchecked")
-	protected TypeFilter createTypeFilter(Element element, ClassLoader classLoader) {
+	protected TypeFilter createTypeFilter(Element element, ClassLoader classLoader, ParserContext parserContext) {
 		String filterType = element.getAttribute(FILTER_TYPE_ATTRIBUTE);
 		String expression = element.getAttribute(FILTER_EXPRESSION_ATTRIBUTE);
+		expression = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(expression);
 		try {
 			if ("annotation".equals(filterType)) {
 				return new AnnotationTypeFilter((Class<Annotation>) classLoader.loadClass(expression));
diff --git a/spring-context/src/test/java/org/springframework/context/annotation/ComponentScanParserTests.java b/spring-context/src/test/java/org/springframework/context/annotation/ComponentScanParserTests.java
@@ -32,7 +32,6 @@
 import org.springframework.core.type.classreading.MetadataReader;
 import org.springframework.core.type.classreading.MetadataReaderFactory;
 import org.springframework.core.type.filter.TypeFilter;
-import org.springframework.stereotype.Component;
 
 import static org.hamcrest.CoreMatchers.*;
 import static org.junit.Assert.*;
@@ -49,15 +48,35 @@ private ClassPathXmlApplicationContext loadContext(String path) {
 		return new ClassPathXmlApplicationContext(path, getClass());
 	}
 
+
 	@Test
-	public void aspectJTypeFilter() {
+	public void aspectjTypeFilter() {
 		ClassPathXmlApplicationContext context = loadContext("aspectjTypeFilterTests.xml");
 		assertTrue(context.containsBean("fooServiceImpl"));
 		assertTrue(context.containsBean("stubFooDao"));
 		assertFalse(context.containsBean("scopedProxyTestBean"));
 		context.close();
 	}
 
+	@Test
+	public void aspectjTypeFilterWithPlaceholders() {
+		System.setProperty("basePackage", "example.scannable, test");
+		System.setProperty("scanInclude", "example.scannable.FooService+");
+		System.setProperty("scanExclude", "example..Scoped*Test*");
+		try {
+			ClassPathXmlApplicationContext context = loadContext("aspectjTypeFilterTestsWithPlaceholders.xml");
+			assertTrue(context.containsBean("fooServiceImpl"));
+			assertTrue(context.containsBean("stubFooDao"));
+			assertFalse(context.containsBean("scopedProxyTestBean"));
+			context.close();
+		}
+		finally {
+			System.clearProperty("basePackage");
+			System.clearProperty("scanInclude");
+			System.clearProperty("scanExclude");
+		}
+	}
+
 	@Test
 	public void nonMatchingResourcePattern() {
 		ClassPathXmlApplicationContext context = loadContext("nonMatchingResourcePatternTests.xml");
@@ -131,6 +150,7 @@ public void componentScanRespectsProfileAnnotation() {
 	public static @interface CustomAnnotation {
 	}
 
+
 	/**
 	 * Intentionally spelling "custom" with a "k" since there are numerous
 	 * classes in this package named *Custom*.
@@ -146,6 +166,7 @@ public KustomAnnotationDependencyBean getDependency() {
 		}
 	}
 
+
 	/**
 	 * Intentionally spelling "custom" with a "k" since there are numerous
 	 * classes in this package named *Custom*.
@@ -154,6 +175,7 @@ public KustomAnnotationDependencyBean getDependency() {
 	public static class KustomAnnotationDependencyBean {
 	}
 
+
 	public static class CustomTypeFilter implements TypeFilter {
 
 		/**
diff --git a/spring-context/src/test/java/org/springframework/context/annotation/aspectjTypeFilterTests.xml b/spring-context/src/test/java/org/springframework/context/annotation/aspectjTypeFilterTests.xml
@@ -8,7 +8,7 @@
 	<context:component-scan base-package="example.scannable" use-default-filters="false" annotation-config="false">
         <context:include-filter type="aspectj" expression="example.scannable.Stub*"/>
         <context:include-filter type="aspectj" expression="example.scannable.FooService+"/>
-        <context:exclude-filter type="aspectj" expression="example..Scoped*Test*" />
+        <context:exclude-filter type="aspectj" expression="example..Scoped*Test*"/>
     </context:component-scan>
 
 </beans>
diff --git a/spring-context/src/test/java/org/springframework/context/annotation/aspectjTypeFilterTestsWithPlaceholders.xml b/spring-context/src/test/java/org/springframework/context/annotation/aspectjTypeFilterTestsWithPlaceholders.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:context="http://www.springframework.org/schema/context"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
+				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
+
+	<context:component-scan base-package="${basePackage}" use-default-filters="false" annotation-config="false">
+        <context:include-filter type="aspectj" expression="example.scannable.Stub*"/>
+        <context:include-filter type="aspectj" expression="${scanInclude}"/>
+        <context:exclude-filter type="aspectj" expression="${scanExclude}"/>
+    </context:component-scan>
+
+</beans>

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,9 @@ public class ComponentScanBeanDefinitionParser implements BeanDefinitionParser {`
`77`	`77`
`78`	`78`	`@Override`
`79`	`79`	`public BeanDefinition parse(Element element, ParserContext parserContext) {`
`80`		`- String[] basePackages = StringUtils.tokenizeToStringArray(element.getAttribute(BASE_PACKAGE_ATTRIBUTE),`
	`80`	`+ String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);`
	`81`	`+ basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);`
	`82`	`+ String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,`
`81`	`83`	`ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);`
`82`	`84`
`83`	`85`	`// Actually scan for bean definitions and register them.`
`@@ -89,17 +91,15 @@ public BeanDefinition parse(Element element, ParserContext parserContext) {`
`89`	`91`	`}`
`90`	`92`
`91`	`93`	`protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {`
`92`		`- XmlReaderContext readerContext = parserContext.getReaderContext();`
`93`		`-`
`94`	`94`	`boolean useDefaultFilters = true;`
`95`	`95`	`if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {`
`96`	`96`	`useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`// Delegate bean definition registration to scanner class.`
`100`		`- ClassPathBeanDefinitionScanner scanner = createScanner(readerContext, useDefaultFilters);`
`101`		`- scanner.setResourceLoader(readerContext.getResourceLoader());`
`102`		`- scanner.setEnvironment(parserContext.getDelegate().getEnvironment());`
	`100`	`+ ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);`
	`101`	`+ scanner.setResourceLoader(parserContext.getReaderContext().getResourceLoader());`
	`102`	`+ scanner.setEnvironment(parserContext.getReaderContext().getEnvironment());`
`103`	`103`	`scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());`
`104`	`104`	`scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());`
`105`	`105`
`@@ -111,17 +111,17 @@ protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserCo`
`111`	`111`	`parseBeanNameGenerator(element, scanner);`
`112`	`112`	`}`
`113`	`113`	`catch (Exception ex) {`
`114`		`- readerContext.error(ex.getMessage(), readerContext.extractSource(element), ex.getCause());`
	`114`	`+ parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`try {`
`118`	`118`	`parseScope(element, scanner);`
`119`	`119`	`}`
`120`	`120`	`catch (Exception ex) {`
`121`		`- readerContext.error(ex.getMessage(), readerContext.extractSource(element), ex.getCause());`
	`121`	`+ parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());`
`122`	`122`	`}`
`123`	`123`
`124`		`- parseTypeFilters(element, scanner, readerContext, parserContext);`
	`124`	`+ parseTypeFilters(element, scanner, parserContext);`
`125`	`125`
`126`	`126`	`return scanner;`
`127`	`127`	`}`
`@@ -195,9 +195,7 @@ else if ("no".equals(mode)) {`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`
`198`		`- protected void parseTypeFilters(`
`199`		`- Element element, ClassPathBeanDefinitionScanner scanner, XmlReaderContext readerContext, ParserContext parserContext) {`
`200`		`-`
	`198`	`+ protected void parseTypeFilters(Element element, ClassPathBeanDefinitionScanner scanner, ParserContext parserContext) {`
`201`	`199`	`// Parse exclude and include filter elements.`
`202`	`200`	`ClassLoader classLoader = scanner.getResourceLoader().getClassLoader();`
`203`	`201`	`NodeList nodeList = element.getChildNodes();`
`@@ -207,25 +205,27 @@ protected void parseTypeFilters(`
`207`	`205`	`String localName = parserContext.getDelegate().getLocalName(node);`
`208`	`206`	`try {`
`209`	`207`	`if (INCLUDE_FILTER_ELEMENT.equals(localName)) {`
`210`		`- TypeFilter typeFilter = createTypeFilter((Element) node, classLoader);`
	`208`	`+ TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);`
`211`	`209`	`scanner.addIncludeFilter(typeFilter);`
`212`	`210`	`}`
`213`	`211`	`else if (EXCLUDE_FILTER_ELEMENT.equals(localName)) {`
`214`		`- TypeFilter typeFilter = createTypeFilter((Element) node, classLoader);`
	`212`	`+ TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);`
`215`	`213`	`scanner.addExcludeFilter(typeFilter);`
`216`	`214`	`}`
`217`	`215`	`}`
`218`	`216`	`catch (Exception ex) {`
`219`		`- readerContext.error(ex.getMessage(), readerContext.extractSource(element), ex.getCause());`
	`217`	`+ parserContext.getReaderContext().error(`
	`218`	`+ ex.getMessage(), parserContext.extractSource(element), ex.getCause());`
`220`	`219`	`}`
`221`	`220`	`}`
`222`	`221`	`}`
`223`	`222`	`}`
`224`	`223`
`225`	`224`	`@SuppressWarnings("unchecked")`
`226`		`- protected TypeFilter createTypeFilter(Element element, ClassLoader classLoader) {`
	`225`	`+ protected TypeFilter createTypeFilter(Element element, ClassLoader classLoader, ParserContext parserContext) {`
`227`	`226`	`String filterType = element.getAttribute(FILTER_TYPE_ATTRIBUTE);`
`228`	`227`	`String expression = element.getAttribute(FILTER_EXPRESSION_ATTRIBUTE);`
	`228`	`+ expression = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(expression);`
`229`	`229`	`try {`
`230`	`230`	`if ("annotation".equals(filterType)) {`
`231`	`231`	`return new AnnotationTypeFilter((Class<Annotation>) classLoader.loadClass(expression));`