Spring中@Import与@ContextConfiguration的用法差异咨询

Great question! Even though both annotations let you use multiple @Configuration classes to create a Spring ApplicationContext, they’re designed for distinct purposes and live in different parts of the Spring ecosystem. Let’s break down their key differences:

Core Purpose & Use Cases #

• @Import (from spring-context)
  This is a core Spring annotation meant for production and general configuration assembly. Its job is to combine multiple @Configuration classes into a single logical configuration, letting Spring load all their beans into the container. You’ll use it in your application’s main configuration code to build out your core bean ecosystem, though it works in tests too—it’s not limited to any environment.

• @ContextConfiguration (from spring-test)
  This is a test-only annotation, built exclusively for setting up test environments. Its sole purpose is to tell Spring’s testing framework exactly which configurations (classes or XML files) to use when creating the ApplicationContext for your tests. It’s never used in production code; it’s all about making test contexts predictable and tailored to your test needs.

Usage Patterns #

• @Import usage
  You annotate a @Configuration class with @Import to pull in other configuration classes as part of its definition:

  @Configuration
  @Import({PaymentConfig.class, InventoryConfig.class})
  public class AppMainConfig {
      // Additional bean definitions go here
  }
  

  When Spring loads AppMainConfig, it automatically includes all beans from PaymentConfig and InventoryConfig.

• @ContextConfiguration usage
  You annotate your test class directly to define the context for testing. It even supports loading XML configuration files (via the locations attribute), something @Import can’t do:

  @SpringJUnitConfig
  @ContextConfiguration(classes = {TestPaymentConfig.class, TestInventoryConfig.class})
  public class PaymentServiceIntegrationTest {
      // Test methods go here
  }
  

Extended Capabilities #

• @Import flexibility
  Beyond importing @Configuration classes, @Import supports advanced use cases like importing ImportSelector or ImportBeanDefinitionRegistrar implementations. This lets you dynamically register beans based on environment variables, profiles, or other runtime conditions—super useful for flexible production configurations.

• @ContextConfiguration test-specific features
  It’s optimized for testing: you can specify a custom contextLoader to tweak how the test context is loaded, pair it with @TestPropertySource to load test-specific properties, or use inheritLocations/inheritInitializers to control whether test contexts inherit settings from parent classes.

Dependency Requirements #

• @Import is part of the core spring-context module—you’ll have it available as long as you’re using Spring’s core framework, no extra dependencies needed.
• @ContextConfiguration requires the spring-test module, which you’d only include in your test scope (e.g., in Maven/Gradle test dependencies).

In short: @Import is your go-to for assembling application configurations, while @ContextConfiguration is a test-specific tool for spinning up controlled, isolated contexts for your tests. They overlap in loading multiple config classes, but their design goals are worlds apart.

内容的提问来源于stack exchange，提问作者Dmitry Senkovich