org.springframework.context.annotation

## Annotation Type ComponentScan

    @Retention(value=RUNTIME)
    @Target(value=TYPE)
    @Documented
    public @interface ComponentScan

Configures component scanning directives for use with @`Configuration` classes. Provides support parallel with Spring XML's `<context:component-scan>` element.

One of `basePackageClasses()`, `basePackages()` or its alias `value()` may be specified to define specific packages to scan. If specific packages are not defined scanning will occur from the package of the class with 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 (e.g. 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` Javadoc for usage examples.

Since:
  3.1
Author:
  Chris Beams
See Also:
  `Configuration`

### Optional Element Summary

Optional Elements
`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.
`Class<? extends 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 the `basePackages()` attribute.

### Element Detail

#### value

    public abstract String[] value

Alias for the `basePackages()` attribute. Allows for more concise annotation declarations e.g.: `@ComponentScan("org.my.pkg")` instead of `@ComponentScan(basePackages="org.my.pkg")`.

Default:
  {}

#### basePackages

    public abstract 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

    public abstract 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

    public abstract Class<? extends 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, e.g. the default `AnnotationBeanNameGenerator` or any custom instance supplied to the application context at bootstrap time.

See Also:
  `AnnotationConfigApplicationContext.setBeanNameGenerator(BeanNameGenerator)`

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

#### scopeResolver

    public abstract Class<? extends ScopeMetadataResolver> scopeResolver

The `ScopeMetadataResolver` to be used for resolving the scope of detected components.

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

#### scopedProxy

    public abstract 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:
  org.springframework.context.annotation.ScopedProxyMode.DEFAULT

#### resourcePattern

    public abstract String resourcePattern

Controls the class files eligible for component detection.

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

Default:
  "**/*.class"

#### useDefaultFilters

    public abstract boolean useDefaultFilters

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

Default:
  true

#### includeFilters

    public abstract 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.

See Also:
  `resourcePattern()`

Default:
  {}

#### excludeFilters

    public abstract ComponentScan.Filter[] excludeFilters

Specifies which types are not eligible for component scanning.

See Also:
  `resourcePattern()`

Default:
  {}