## 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()` must be specified.

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
`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.

### 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:
    {}