## org.springframework.test.context.support
Class AnnotationConfigContextLoader

    java.lang.Object
      org.springframework.test.context.support.AbstractContextLoader
          org.springframework.test.context.support.AbstractGenericContextLoader
              org.springframework.test.context.support.AnnotationConfigContextLoader

All Implemented Interfaces:
  ContextLoader, SmartContextLoader

    public class AnnotationConfigContextLoader

extends AbstractGenericContextLoader

Concrete implementation of `AbstractGenericContextLoader` that loads bean definitions from `configuration classes`.

Note: `AnnotationConfigContextLoader` supports `configuration classes` rather than the String-based resource locations defined by the legacy `ContextLoader` API. Thus, although `AnnotationConfigContextLoader` extends `AbstractGenericContextLoader`, `AnnotationConfigContextLoader` does not support any String-based methods defined by `AbstractContextLoader` or `AbstractGenericContextLoader`. Consequently, `AnnotationConfigContextLoader` should chiefly be considered a `SmartContextLoader` rather than a `ContextLoader`.

Since:
  3.1
Author:
  Sam Brannen
See Also:
  `#processContextConfiguration()`, `#detectDefaultConfigurationClasses()`, `#loadBeanDefinitions()`

Constructor Summary
`AnnotationConfigContextLoader()`

Method Summary
`protected BeanDefinitionReader` `createBeanDefinitionReader(GenericApplicationContext context)` `AnnotationConfigContextLoader` should be used as a `SmartContextLoader`, not as a legacy `ContextLoader`.
`protected Class<?>[]` `detectDefaultConfigurationClasses(Class<?> declaringClass)` Detect the default configuration classes for the supplied test class.
`protected String[]` `generateDefaultLocations(Class<?> clazz)` `AnnotationConfigContextLoader` should be used as a `SmartContextLoader`, not as a legacy `ContextLoader`.
`protected String` `getResourceSuffix()` `AnnotationConfigContextLoader` should be used as a `SmartContextLoader`, not as a legacy `ContextLoader`.
`protected void` `loadBeanDefinitions(GenericApplicationContext context, MergedContextConfiguration mergedConfig)` Register `configuration classes` in the supplied `context` from the classes in the supplied `MergedContextConfiguration`.
`protected String[]` `modifyLocations(Class<?> clazz, String... locations)` `AnnotationConfigContextLoader` should be used as a `SmartContextLoader`, not as a legacy `ContextLoader`.
`void` `processContextConfiguration(ContextConfigurationAttributes configAttributes)` Process configuration classes in the supplied `ContextConfigurationAttributes`.

Methods inherited from class org.springframework.test.context.support.AbstractGenericContextLoader
`customizeBeanFactory, customizeContext, loadContext, loadContext, prepareContext`

Methods inherited from class org.springframework.test.context.support.AbstractContextLoader
`isGenerateDefaultLocations, processLocations`

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

Constructor Detail

### AnnotationConfigContextLoader

    public AnnotationConfigContextLoader()

Method Detail

### processContextConfiguration

    public void processContextConfiguration(ContextConfigurationAttributes configAttributes)

  Process configuration classes in the supplied `ContextConfigurationAttributes`.

  If the configuration classes are `null` or empty and `AbstractContextLoader.isGenerateDefaultLocations()` returns `true`, this `SmartContextLoader` will attempt to `detect default configuration classes`. If defaults are detected they will be `set` in the supplied configuration attributes. Otherwise, properties in the supplied configuration attributes will not be modified.

  Specified by:
    `processContextConfiguration` in interface `SmartContextLoader`
  Overrides:
    `processContextConfiguration` in class `AbstractContextLoader`
  Parameters:
    `configAttributes` - the context configuration attributes to process
  See Also:
    `org.springframework.test.context.SmartContextLoader#processContextConfiguration()`, `AbstractContextLoader.isGenerateDefaultLocations()`, `#detectDefaultConfigurationClasses()`

### detectDefaultConfigurationClasses

    protected Class<?>[] detectDefaultConfigurationClasses(Class<?> declaringClass)

  Detect the default configuration classes for the supplied test class.

  The returned class array will contain all static inner classes of the supplied class that meet the requirements for `@Configuration` class implementations as specified in the documentation for `@Configuration`.

  The implementation of this method adheres to the contract defined in the `SmartContextLoader` SPI. Specifically, this method uses introspection to detect default configuration classes that comply with the constraints required of `@Configuration` class implementations. If a potential candidate configuration class does meet these requirements, this method will log a warning, and the potential candidate class will be ignored.

  Parameters:
    `declaringClass` - the test class that declared `@ContextConfiguration`
  Returns:
    an array of default configuration classes, potentially empty but never `null`

### modifyLocations

    protected String[] modifyLocations(Class<?> clazz,
                                       String... locations)

  `AnnotationConfigContextLoader` should be used as a `SmartContextLoader`, not as a legacy `ContextLoader`. Consequently, this method is not supported.

  Overrides:
    `modifyLocations` in class `AbstractContextLoader`
  Parameters:
    `clazz` - the class with which the locations are associated
    `locations` - the resource locations to be modified
  Returns:
    an array of modified application context resource locations
  Throws:
    `UnsupportedOperationException`
  See Also:
    `AbstractContextLoader.modifyLocations(java.lang.Class<?>, java.lang.String...)`

### generateDefaultLocations

    protected String[] generateDefaultLocations(Class<?> clazz)

  `AnnotationConfigContextLoader` should be used as a `SmartContextLoader`, not as a legacy `ContextLoader`. Consequently, this method is not supported.

  Overrides:
    `generateDefaultLocations` in class `AbstractContextLoader`
  Parameters:
    `clazz` - the class for which the default locations are to be generated
  Returns:
    an array of default application context resource locations
  Throws:
    `UnsupportedOperationException`
  See Also:
    `AbstractContextLoader.generateDefaultLocations(java.lang.Class<?>)`

### getResourceSuffix

    protected String getResourceSuffix()

  `AnnotationConfigContextLoader` should be used as a `SmartContextLoader`, not as a legacy `ContextLoader`. Consequently, this method is not supported.

  Specified by:
    `getResourceSuffix` in class `AbstractContextLoader`
  Returns:
    the resource suffix; should not be `null` or empty
  Throws:
    `UnsupportedOperationException`
  See Also:
    `AbstractContextLoader.getResourceSuffix()`

### loadBeanDefinitions

    protected void loadBeanDefinitions(GenericApplicationContext context,
                                       MergedContextConfiguration mergedConfig)

  Register `configuration classes` in the supplied `context` from the classes in the supplied `MergedContextConfiguration`.

  Each class must represent an annotated configuration class or component. An `AnnotatedBeanDefinitionReader` is used to register the appropriate bean definitions.

  Note that this method does not call `createBeanDefinitionReader(org.springframework.context.support.GenericApplicationContext)` since `AnnotatedBeanDefinitionReader` is not an instance of `BeanDefinitionReader`.

  Overrides:
    `loadBeanDefinitions` in class `AbstractGenericContextLoader`
  Parameters:
    `context` - the context in which the configuration classes should be registered
    `mergedConfig` - the merged configuration from which the classes should be retrieved
  See Also:
    `AbstractGenericContextLoader.loadBeanDefinitions(org.springframework.context.support.GenericApplicationContext, org.springframework.test.context.MergedContextConfiguration)`

### createBeanDefinitionReader

    protected BeanDefinitionReader createBeanDefinitionReader(GenericApplicationContext context)

  `AnnotationConfigContextLoader` should be used as a `SmartContextLoader`, not as a legacy `ContextLoader`. Consequently, this method is not supported.

  Specified by:
    `createBeanDefinitionReader` in class `AbstractGenericContextLoader`
  Parameters:
    `context` - the context for which the `BeanDefinitionReader` should be created
  Returns:
    a `BeanDefinitionReader` for the supplied context
  Throws:
    `UnsupportedOperationException`
  See Also:
    `loadBeanDefinitions(org.springframework.context.support.GenericApplicationContext, org.springframework.test.context.MergedContextConfiguration)`, `AbstractGenericContextLoader.createBeanDefinitionReader(org.springframework.context.support.GenericApplicationContext)`