Package org.springframework.context.annotation

# Annotation Interface ComponentScan

@Retention(RUNTIME) @Target(TYPE) @Documented @Repeatable(ComponentScans.class) public @interface ComponentScan
Configures component scanning directives for use with `@Configuration` classes.

Provides support comparable to Spring's `<context:component-scan>` XML namespace element.

Either `basePackageClasses()` or `basePackages()` (or its alias `value()`) may be specified to define specific packages to scan. If specific packages are not defined, scanning will occur recursively beginning with the package of the class that declares this annotation.

Note that the `<context:component-scan>` element has an `annotation-config` attribute; however, this annotation does not. This is because in almost all cases when using `@ComponentScan`, default annotation config processing (for example, processing `@Autowired` and friends) is assumed. Furthermore, when using `AnnotationConfigApplicationContext`, annotation config processors are always registered, meaning that any attempt to disable them at the `@ComponentScan` level would be ignored.

See `@Configuration`'s Javadoc for usage examples.

`@ComponentScan` can be used as a repeatable annotation. `@ComponentScan` may also be used as a meta-annotation to create custom composed annotations with attribute overrides.

Locally declared `@ComponentScan` annotations always take precedence over and effectively hide `@ComponentScan` meta-annotations, which allows explicit local configuration to override configuration that is meta-present (including composed annotations meta-annotated with `@ComponentScan`).

Since:
  3.1
Author:
  Chris Beams, Juergen Hoeller, Sam Brannen
See Also:
  - `Configuration`

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static @interface`
`ComponentScan.Filter`
Declares the type filter to be used as an include filter or exclude filter.

## Optional Element Summary

Optional Elements
Modifier and Type
Optional Element
Description
`Class<?>[]`
`basePackageClasses`
Type-safe alternative to `basePackages()` for specifying the packages to scan for annotated components.
`String[]`
`basePackages`
Base packages to scan for annotated components.
`ComponentScan.Filter[]`
`excludeFilters`
Specifies which types are not eligible for component scanning.
`ComponentScan.Filter[]`
`includeFilters`
Specifies which types are eligible for component scanning.
`boolean`
`lazyInit`
Specify whether scanned beans should be registered for lazy initialization.
`Class<? extends org.springframework.beans.factory.support.BeanNameGenerator>`
`nameGenerator`
The `BeanNameGenerator` class to be used for naming detected components within the Spring container.
`String`
`resourcePattern`
Controls the class files eligible for component detection.
`ScopedProxyMode`
`scopedProxy`
Indicates whether proxies should be generated for detected components, which may be necessary when using scopes in a proxy-style fashion.
`Class<? extends ScopeMetadataResolver>`
`scopeResolver`
The `ScopeMetadataResolver` to be used for resolving the scope of detected components.
`boolean`
`useDefaultFilters`
Indicates whether automatic detection of classes annotated with `@Component` `@Repository`, `@Service`, or `@Controller` should be enabled.
`String[]`
`value`
Alias for `basePackages()`.

## Element Details

### value

@AliasFor("basePackages") String[] value
Alias for `basePackages()`.

Allows for more concise annotation declarations if no other attributes are needed — for example, `@ComponentScan("org.my.pkg")` instead of `@ComponentScan(basePackages = "org.my.pkg")`.

Default:
  {}

### basePackages

@AliasFor("value") String[] basePackages
Base packages to scan for annotated components.

`value()` is an alias for (and mutually exclusive with) this attribute.

Use `basePackageClasses()` for a type-safe alternative to String-based package names.

Default:
  {}

### basePackageClasses

Class<?>[] basePackageClasses
Type-safe alternative to `basePackages()` for specifying the packages to scan for annotated components. The package of each class specified will be scanned.

Consider creating a special no-op marker class or interface in each package that serves no purpose other than being referenced by this attribute.

Default:
  {}

### nameGenerator

Class<? extends org.springframework.beans.factory.support.BeanNameGenerator> nameGenerator
The `BeanNameGenerator` class to be used for naming detected components within the Spring container.

The default value of the `BeanNameGenerator` interface itself indicates that the scanner used to process this `@ComponentScan` annotation should use its inherited bean name generator, for example, the default `AnnotationBeanNameGenerator` or any custom instance supplied to the application context at bootstrap time.

See Also:
  - `AnnotationConfigApplicationContext.setBeanNameGenerator(BeanNameGenerator)`
  - `AnnotationBeanNameGenerator`
  - `FullyQualifiedAnnotationBeanNameGenerator`

Default:
  org.springframework.beans.factory.support.BeanNameGenerator.class

### scopeResolver

Class<? extends ScopeMetadataResolver> scopeResolver
The `ScopeMetadataResolver` to be used for resolving the scope of detected components.

Default:
  org.springframework.context.annotation.AnnotationScopeMetadataResolver.class

### scopedProxy

ScopedProxyMode scopedProxy
Indicates whether proxies should be generated for detected components, which may be necessary when using scopes in a proxy-style fashion.

The default is defer to the default behavior of the component scanner used to execute the actual scan.

Note that setting this attribute overrides any value set for `scopeResolver()`.

See Also:
  - `ClassPathBeanDefinitionScanner.setScopedProxyMode(ScopedProxyMode)`

Default:
  DEFAULT

### resourcePattern

String resourcePattern
Controls the class files eligible for component detection.

Consider use of `includeFilters()` and `excludeFilters()` for a more flexible approach.

Default:
  "**/*.class"

### useDefaultFilters

boolean useDefaultFilters
Indicates whether automatic detection of classes annotated with `@Component` `@Repository`, `@Service`, or `@Controller` should be enabled.

Default:
  true

### includeFilters

ComponentScan.Filter[] includeFilters
Specifies which types are eligible for component scanning.

Further narrows the set of candidate components from everything in `basePackages()` to everything in the base packages that matches the given filter or filters.

Note that these filters will be applied in addition to the default filters, if specified. Any type under the specified base packages which matches a given filter will be included, even if it does not match the default filters (i.e. is not annotated with `@Component`).

See Also:
  - `resourcePattern()`
  - `useDefaultFilters()`

Default:
  {}

### excludeFilters

ComponentScan.Filter[] excludeFilters
Specifies which types are not eligible for component scanning.

See Also:
  - `resourcePattern()`

Default:
  {}

### lazyInit

boolean lazyInit
Specify whether scanned beans should be registered for lazy initialization.

Default is `false`; switch this to `true` when desired.

Since:
  4.1

Default:
  false