org.springframework.context.annotation

Class ClassPathScanningCandidateComponentProvider

java.lang.Object

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider

All Implemented Interfaces:

Aware, ResourceLoaderAware, EnvironmentCapable

Direct Known Subclasses:

ClassPathBeanDefinitionScanner

public class ClassPathScanningCandidateComponentProvider
extends java.lang.Object
implements EnvironmentCapable, ResourceLoaderAware

A component provider that scans the classpath from a base package. It then applies exclude and include filters to the resulting classes to find candidates.

This implementation is based on Spring's MetadataReader facility, backed by an ASM ClassReader.

Since:

2.5

Author:

Mark Fisher, Juergen Hoeller, Ramnivas Laddad, Chris Beams

See Also:

MetadataReaderFactory, AnnotationMetadata, ScannedGenericBeanDefinition

Field Summary

Fields

Modifier and Type	Field and Description
private ConditionEvaluator	conditionEvaluator
(package private) static java.lang.String	DEFAULT_RESOURCE_PATTERN
private Environment	environment
private java.util.List<TypeFilter>	excludeFilters
private java.util.List<TypeFilter>	includeFilters
protected Log	logger
private MetadataReaderFactory	metadataReaderFactory
private java.lang.String	resourcePattern
private ResourcePatternResolver	resourcePatternResolver

Constructor Summary

Constructors

Constructor and Description
ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters) Create a ClassPathScanningCandidateComponentProvider with a StandardEnvironment.
ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters, Environment environment) Create a ClassPathScanningCandidateComponentProvider with the given Environment.

Method Summary

Modifier and Type	Method and Description
void	addExcludeFilter(TypeFilter excludeFilter) Add an exclude type filter to the front of the exclusion list.
void	addIncludeFilter(TypeFilter includeFilter) Add an include type filter to the end of the inclusion list.
void	clearCache() Clear the underlying metadata cache, removing all cached class metadata.
java.util.Set<BeanDefinition>	findCandidateComponents(java.lang.String basePackage) Scan the class path for candidate components.
Environment	getEnvironment() Return the Environment associated with this component.
MetadataReaderFactory	getMetadataReaderFactory() Return the MetadataReaderFactory used by this component provider.
protected BeanDefinitionRegistry	getRegistry() Returns the BeanDefinitionRegistry used by this scanner, if any.
ResourceLoader	getResourceLoader() Return the ResourceLoader that this component provider uses.
protected boolean	isCandidateComponent(AnnotatedBeanDefinition beanDefinition) Determine whether the given bean definition qualifies as candidate.
protected boolean	isCandidateComponent(MetadataReader metadataReader) Determine whether the given class does not match any exclude filter and does match at least one include filter.
private boolean	isConditionMatch(MetadataReader metadataReader) Determine whether the given class is a candidate component based on any @Conditional annotations.
protected void	registerDefaultFilters() Register the default filter for @Component.
void	resetFilters(boolean useDefaultFilters) Reset the configured type filters.
protected java.lang.String	resolveBasePackage(java.lang.String basePackage) Resolve the specified base package into a pattern specification for the package search path.
void	setEnvironment(Environment environment) Set the Environment to use when resolving placeholders and evaluating @Conditional-annotated component classes.
void	setMetadataReaderFactory(MetadataReaderFactory metadataReaderFactory) Set the MetadataReaderFactory to use.
void	setResourceLoader(ResourceLoader resourceLoader) Set the ResourceLoader to use for resource locations.
void	setResourcePattern(java.lang.String resourcePattern) Set the resource pattern to use when scanning the classpath.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

DEFAULT_RESOURCE_PATTERN

static final java.lang.String DEFAULT_RESOURCE_PATTERN

See Also:

Constant Field Values

logger

protected final Log logger

environment

private Environment environment

resourcePatternResolver

private ResourcePatternResolver resourcePatternResolver

metadataReaderFactory

private MetadataReaderFactory metadataReaderFactory

resourcePattern

private java.lang.String resourcePattern

includeFilters

private final java.util.List<TypeFilter> includeFilters

excludeFilters

private final java.util.List<TypeFilter> excludeFilters

conditionEvaluator

private ConditionEvaluator conditionEvaluator

Constructor Detail

ClassPathScanningCandidateComponentProvider

public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters)

Create a ClassPathScanningCandidateComponentProvider with a StandardEnvironment.

Parameters:

useDefaultFilters - whether to register the default filters for the @Component, @Repository, @Service, and @Controller stereotype annotations

See Also:

registerDefaultFilters()

ClassPathScanningCandidateComponentProvider

public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters,
                                                   Environment environment)

Create a ClassPathScanningCandidateComponentProvider with the given Environment.

Parameters:

useDefaultFilters - whether to register the default filters for the @Component, @Repository, @Service, and @Controller stereotype annotations

environment - the Environment to use

See Also:

registerDefaultFilters()

Method Detail

setResourceLoader

public void setResourceLoader(ResourceLoader resourceLoader)

Set the ResourceLoader to use for resource locations. This will typically be a ResourcePatternResolver implementation.

Default is PathMatchingResourcePatternResolver, also capable of resource pattern resolving through the ResourcePatternResolver interface.

Specified by:

setResourceLoader in interface ResourceLoaderAware

Parameters:

resourceLoader - ResourceLoader object to be used by this object

See Also:

ResourcePatternResolver, PathMatchingResourcePatternResolver

getResourceLoader

public final ResourceLoader getResourceLoader()

Return the ResourceLoader that this component provider uses.

setMetadataReaderFactory

public void setMetadataReaderFactory(MetadataReaderFactory metadataReaderFactory)

Set the MetadataReaderFactory to use.

Default is a CachingMetadataReaderFactory for the specified resource loader.

Call this setter method after setResourceLoader(org.springframework.core.io.ResourceLoader) in order for the given MetadataReaderFactory to override the default factory.

getMetadataReaderFactory

public final MetadataReaderFactory getMetadataReaderFactory()

Return the MetadataReaderFactory used by this component provider.

setEnvironment

public void setEnvironment(Environment environment)

Set the Environment to use when resolving placeholders and evaluating @Conditional-annotated component classes.

The default is a StandardEnvironment.

Parameters:

environment - the Environment to use

getEnvironment

public final Environment getEnvironment()

Description copied from interface: EnvironmentCapable

Return the Environment associated with this component.

Specified by:

getEnvironment in interface EnvironmentCapable

getRegistry

protected BeanDefinitionRegistry getRegistry()

Returns the BeanDefinitionRegistry used by this scanner, if any.

setResourcePattern

public void setResourcePattern(java.lang.String resourcePattern)

Set the resource pattern to use when scanning the classpath. This value will be appended to each base package name.

See Also:

findCandidateComponents(String), DEFAULT_RESOURCE_PATTERN

addIncludeFilter

public void addIncludeFilter(TypeFilter includeFilter)

Add an include type filter to the end of the inclusion list.

addExcludeFilter

public void addExcludeFilter(TypeFilter excludeFilter)

Add an exclude type filter to the front of the exclusion list.

resetFilters

public void resetFilters(boolean useDefaultFilters)

Reset the configured type filters.

Parameters:

useDefaultFilters - whether to re-register the default filters for the @Component, @Repository, @Service, and @Controller stereotype annotations

See Also:

registerDefaultFilters()

registerDefaultFilters

protected void registerDefaultFilters()

Register the default filter for @Component.

This will implicitly register all annotations that have the @Component meta-annotation including the @Repository, @Service, and @Controller stereotype annotations.

Also supports Java EE 6's javax.annotation.ManagedBean and JSR-330's javax.inject.Named annotations, if available.

findCandidateComponents

public java.util.Set<BeanDefinition> findCandidateComponents(java.lang.String basePackage)

Scan the class path for candidate components.

Parameters:

basePackage - the package to check for annotated classes

Returns:

a corresponding Set of autodetected bean definitions

resolveBasePackage

protected java.lang.String resolveBasePackage(java.lang.String basePackage)

Resolve the specified base package into a pattern specification for the package search path.

The default implementation resolves placeholders against system properties, and converts a "."-based package path to a "/"-based resource path.

Parameters:

basePackage - the base package as specified by the user

Returns:

the pattern specification to be used for package searching

isCandidateComponent

protected boolean isCandidateComponent(MetadataReader metadataReader)
                                throws java.io.IOException

Determine whether the given class does not match any exclude filter and does match at least one include filter.

Parameters:

metadataReader - the ASM ClassReader for the class

Returns:

whether the class qualifies as a candidate component

Throws:

java.io.IOException

isConditionMatch

private boolean isConditionMatch(MetadataReader metadataReader)

Determine whether the given class is a candidate component based on any @Conditional annotations.

Parameters:

metadataReader - the ASM ClassReader for the class

Returns:

whether the class qualifies as a candidate component

isCandidateComponent

protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition)

Determine whether the given bean definition qualifies as candidate.

The default implementation checks whether the class is concrete (i.e. not abstract and not an interface). Can be overridden in subclasses.

Parameters:

beanDefinition - the bean definition to check

Returns:

whether the bean definition qualifies as a candidate component

clearCache

public void clearCache()

Clear the underlying metadata cache, removing all cached class metadata.