Prior to Spring 3.1, only path-based resource locations were supported. * As of Spring 3.1, {@link #loader context loaders} may choose to support * either path-based or class-based resources (but not both). Consequently * {@code @ContextConfiguration} can be used to declare either path-based * resource locations (via the {@link #locations} or {@link #value} * attribute) or configuration classes (via the {@link #classes} * attribute). * * @author Sam Brannen * @since 2.5 * @see ContextLoader * @see SmartContextLoader * @see org.springframework.context.ApplicationContext * @see ActiveProfiles */ @Documented @Inherited @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface ContextConfiguration { /** * Alias for {@link #locations() locations}. * *
This attribute may not be used in conjunction * with {@link #locations} or {@link #classes}, but it may be used * instead of {@link #locations}. * @since 3.0 */ String[] value() default {}; /** * The resource locations to use for loading an * {@link org.springframework.context.ApplicationContext ApplicationContext}. * *
Check out the javadoc for * {@link org.springframework.test.context.support.AbstractContextLoader#modifyLocations * AbstractContextLoader.modifyLocations()} for details on how a location * String will be interpreted at runtime, in particular in case of a relative * path. Also, check out the documentation on * {@link org.springframework.test.context.support.AbstractContextLoader#generateDefaultLocations * AbstractContextLoader.generateDefaultLocations()} for details on the default * locations that are going to be used if none are specified. * *
Note that the above-mentioned default rules only apply for a standard * {@link org.springframework.test.context.support.AbstractContextLoader * AbstractContextLoader} subclass such as * {@link org.springframework.test.context.support.GenericXmlContextLoader * GenericXmlContextLoader} which is the effective default implementation * used at runtime. * *
This attribute may not be used in conjunction with * {@link #value} or {@link #classes}, but it may be used instead of * {@link #value}. * @since 2.5 */ String[] locations() default {}; /** * The {@link org.springframework.context.annotation.Configuration configuration classes} * to use for loading an * {@link org.springframework.context.ApplicationContext ApplicationContext}. * *
To enable support for configuration class processing, an appropriate * {@link SmartContextLoader} must be {@link #loader configured}. * {@link org.springframework.test.context.support.AnnotationConfigContextLoader * AnnotationConfigContextLoader} is one such loader provided by the Spring Framework. * *
Check out the javadoc for * {@link org.springframework.test.context.support.AnnotationConfigContextLoader#generateDefaultConfigurationClasses * AnnotationConfigContextLoader.generateDefaultConfigurationClasses()} * for details on the default configuration classes that will be used if none * are specified. * *
Note that this attribute may not be used in * conjunction with {@link #locations} or {@link #value}. * @since 3.1 * @see org.springframework.context.annotation.Configuration * @see org.springframework.test.context.support.AnnotationConfigContextLoader */ Class[] classes() default {}; /** * Whether or not {@link #locations resource locations} or * {@link #classes configuration classes} from superclasses should be * inherited. * *
The default value is true, which means that an annotated
* class will inherit the resource locations or configuration
* classes defined by an annotated superclass. Specifically, the resource
* locations or configuration classes for an annotated class will be
* appended to the list of resource locations or configuration classes
* defined by an annotated superclass. Thus, subclasses have the option of
* extending the list of resource locations or configuration
* classes.
*
*
If inheritLocations is set to false, the
* resource locations or configuration classes for the annotated class
* will shadow and effectively replace any resource locations
* or configuration classes defined by a superclass.
*
*
In the following example that uses path-based resource locations, the * {@link org.springframework.context.ApplicationContext ApplicationContext} * for {@code ExtendedTest} will be loaded from * "base-context.xml" and * "extended-context.xml", in that order. Beans defined in * "extended-context.xml" may therefore override those defined in * "base-context.xml". *
* @ContextConfiguration("base-context.xml")
* public class BaseTest {
* // ...
* }
*
* @ContextConfiguration("extended-context.xml")
* public class ExtendedTest extends BaseTest {
* // ...
* }
*
*
* Similarly, in the following example that uses configuration * classes, the * {@link org.springframework.context.ApplicationContext ApplicationContext} * for {@code ExtendedTest} will be loaded from the * {@code BaseConfig} and {@code ExtendedConfig} * configuration classes, in that order. Beans defined in * {@code ExtendedConfig} may therefore override those defined in * {@code BaseConfig}. *
* @ContextConfiguration(classes=BaseConfig.class, loader=AnnotationConfigContextLoader.class)
* public class BaseTest {
* // ...
* }
*
* @ContextConfiguration(classes=ExtendedConfig.class, loader=AnnotationConfigContextLoader.class)
* public class ExtendedTest extends BaseTest {
* // ...
* }
*
* @since 2.5
*/
boolean inheritLocations() default true;
// TODO Update regarding default --> DelegatingSmartContextLoader
/**
* The type of {@link ContextLoader} (or {@link SmartContextLoader}) to use
* for loading an {@link org.springframework.context.ApplicationContext
* ApplicationContext}.
*
* If not specified, the loader will be inherited from the first superclass * that is annotated with {@code @ContextConfiguration} and specifies an * explicit loader. If no class in the hierarchy specifies an explicit * loader, a default loader will be used instead. * *
The default concrete implementation chosen at runtime will be * {@link org.springframework.test.context.support.GenericXmlContextLoader * GenericXmlContextLoader}. Also check out * {@link org.springframework.test.context.support.AbstractContextLoader * AbstractContextLoader}'s javadoc for details on the default behavior there. * @since 2.5 */ Class loader() default ContextLoader.class; }