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`'s javadoc for usage examples.

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

- - ### Optional Element Summary

    Optional Elements
    Modifier and Type | Optional Element and 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.
    `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:
        {}