## org.springframework.context.annotation
Class ClassPathBeanDefinitionScanner

    java.lang.Object
      org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider
          org.springframework.context.annotation.ClassPathBeanDefinitionScanner

All Implemented Interfaces:
  ResourceLoaderAware

    public class ClassPathBeanDefinitionScanner

extends ClassPathScanningCandidateComponentProvider

A bean definition scanner that detects bean candidates on the classpath, registering corresponding bean definitions with a given registry (BeanFactory or ApplicationContext).

Candidate classes are detected through configurable type filters. The default filters include classes that are annotated with Spring's `@Component`, `@Repository`, `@Service`, or `@Controller` stereotype.

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

Since:
  2.5
Author:
  Mark Fisher, Juergen Hoeller
See Also:
  `AnnotationConfigApplicationContext.scan(java.lang.String...)`, `Component`, `Repository`, `Service`, `Controller`

Field Summary

Fields inherited from class org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider
`logger`

Constructor Summary
`ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry)` Create a new ClassPathBeanDefinitionScanner for the given bean factory.
`ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters)` Create a new ClassPathBeanDefinitionScanner for the given bean factory.

Method Summary
`protected boolean` `checkCandidate(String beanName, BeanDefinition beanDefinition)` Check the given candidate's bean name, determining whether the corresponding bean definition needs to be registered or conflicts with an existing definition.
`protected Set<BeanDefinitionHolder>` `doScan(String... basePackages)` Perform a scan within the specified base packages, returning the registered bean definitions.
`BeanDefinitionRegistry` `getRegistry()` Return the BeanDefinitionRegistry that this scanner operates on.
`protected boolean` `isCompatible(BeanDefinition newDefinition, BeanDefinition existingDefinition)` Determine whether the given new bean definition is compatible with the given existing bean definition.
`protected void` `postProcessBeanDefinition(AbstractBeanDefinition beanDefinition, String beanName)` Apply further settings to the given bean definition, beyond the contents retrieved from scanning the component class.
`protected void` `registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)` Register the specified bean with the given registry.
`int` `scan(String... basePackages)` Perform a scan within the specified base packages.
`void` `setAutowireCandidatePatterns(String[] autowireCandidatePatterns)` Set the name-matching patterns for determining autowire candidates.
`void` `setBeanDefinitionDefaults(BeanDefinitionDefaults beanDefinitionDefaults)` Set the defaults to use for detected beans.
`void` `setBeanNameGenerator(BeanNameGenerator beanNameGenerator)` Set the BeanNameGenerator to use for detected bean classes.
`void` `setIncludeAnnotationConfig(boolean includeAnnotationConfig)` Specify whether to register annotation config post-processors.
`void` `setScopedProxyMode(ScopedProxyMode scopedProxyMode)` Specify the proxy behavior for non-singleton scoped beans.
`void` `setScopeMetadataResolver(ScopeMetadataResolver scopeMetadataResolver)` Set the ScopeMetadataResolver to use for detected bean classes.

Methods inherited from class org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider
`addExcludeFilter, addIncludeFilter, findCandidateComponents, getResourceLoader, isCandidateComponent, isCandidateComponent, registerDefaultFilters, resetFilters, resolveBasePackage, setResourceLoader, setResourcePattern`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### ClassPathBeanDefinitionScanner

    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry)

  Create a new ClassPathBeanDefinitionScanner for the given bean factory.

  Parameters:
    `registry` - the BeanFactory to load bean definitions into, in the form of a BeanDefinitionRegistry

### ClassPathBeanDefinitionScanner

    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry,
                                          boolean useDefaultFilters)

  Create a new ClassPathBeanDefinitionScanner for the given bean factory.

  If the passed-in bean factory does not only implement the BeanDefinitionRegistry interface but also the ResourceLoader interface, it will be used as default ResourceLoader as well. This will usually be the case for `ApplicationContext` implementations.

  If given a plain BeanDefinitionRegistry, the default ResourceLoader will be a `PathMatchingResourcePatternResolver`.

  Parameters:
    `registry` - the BeanFactory to load bean definitions into, in the form of a BeanDefinitionRegistry
    `useDefaultFilters` - whether to include the default filters for the `@Component`, `@Repository`, `@Service`, and `@Controller` stereotype annotations.
  See Also:
    `ClassPathScanningCandidateComponentProvider.setResourceLoader(org.springframework.core.io.ResourceLoader)`

Method Detail

### getRegistry

    public final BeanDefinitionRegistry getRegistry()

  Return the BeanDefinitionRegistry that this scanner operates on.

### setBeanDefinitionDefaults

    public void setBeanDefinitionDefaults(BeanDefinitionDefaults beanDefinitionDefaults)

  Set the defaults to use for detected beans.

  See Also:
    `BeanDefinitionDefaults`

### setAutowireCandidatePatterns

    public void setAutowireCandidatePatterns(String[] autowireCandidatePatterns)

  Set the name-matching patterns for determining autowire candidates.

  Parameters:
    `autowireCandidatePatterns` - the patterns to match against

### setBeanNameGenerator

    public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator)

  Set the BeanNameGenerator to use for detected bean classes.

  Default is a `AnnotationBeanNameGenerator`.

### setScopeMetadataResolver

    public void setScopeMetadataResolver(ScopeMetadataResolver scopeMetadataResolver)

  Set the ScopeMetadataResolver to use for detected bean classes. Note that this will override any custom "scopedProxyMode" setting.

  The default is an `AnnotationScopeMetadataResolver`.

  See Also:
    `setScopedProxyMode(org.springframework.context.annotation.ScopedProxyMode)`

### setScopedProxyMode

    public void setScopedProxyMode(ScopedProxyMode scopedProxyMode)

  Specify the proxy behavior for non-singleton scoped beans. Note that this will override any custom "scopeMetadataResolver" setting.

  The default is `ScopedProxyMode.NO`.

  See Also:
    `setScopeMetadataResolver(org.springframework.context.annotation.ScopeMetadataResolver)`

### setIncludeAnnotationConfig

    public void setIncludeAnnotationConfig(boolean includeAnnotationConfig)

  Specify whether to register annotation config post-processors.

  The default is to register the post-processors. Turn this off to be able to ignore the annotations or to process them differently.

### scan

    public int scan(String... basePackages)

  Perform a scan within the specified base packages.

  Parameters:
    `basePackages` - the packages to check for annotated classes
  Returns:
    number of beans registered

### doScan

    protected Set<BeanDefinitionHolder> doScan(String... basePackages)

  Perform a scan within the specified base packages, returning the registered bean definitions.

  This method does not register an annotation config processor but rather leaves this up to the caller.

  Parameters:
    `basePackages` - the packages to check for annotated classes
  Returns:
    number of beans registered

### postProcessBeanDefinition

    protected void postProcessBeanDefinition(AbstractBeanDefinition beanDefinition,
                                             String beanName)

  Apply further settings to the given bean definition, beyond the contents retrieved from scanning the component class.

  Parameters:
    `beanDefinition` - the scanned bean definition
    `beanName` - the generated bean name for the given bean

### registerBeanDefinition

    protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder,
                                          BeanDefinitionRegistry registry)

  Register the specified bean with the given registry.

  Can be overridden in subclasses, e.g. to adapt the registration process or to register further bean definitions for each scanned bean.

  Parameters:
    `definitionHolder` - the bean definition plus bean name for the bean
    `registry` - the BeanDefinitionRegistry to register the bean with

### checkCandidate

    protected boolean checkCandidate(String beanName,
                                     BeanDefinition beanDefinition)
                              throws IllegalStateException

  Check the given candidate's bean name, determining whether the corresponding bean definition needs to be registered or conflicts with an existing definition.

  Parameters:
    `beanName` - the suggested name for the bean
    `beanDefinition` - the corresponding bean definition
  Returns:
    `true` if the bean can be registered as-is; `false` if it should be skipped because there is an existing, compatible bean definition for the specified name
  Throws:
    `IllegalStateException` - if an existing, incompatible bean definition has been found for the specified name

### isCompatible

    protected boolean isCompatible(BeanDefinition newDefinition,
                                   BeanDefinition existingDefinition)

  Determine whether the given new bean definition is compatible with the given existing bean definition.

  The default implementation simply considers them as compatible when the bean class name matches.

  Parameters:
    `newDefinition` - the new bean definition, originated from scanning
    `existingDefinition` - the existing bean definition, potentially an explicitly defined one or a previously generated one from scanning
  Returns:
    whether the definitions are considered as compatible, with the new definition to be skipped in favor of the existing definition