Что такое аннотация @Import?

Аннотация @Import в Spring

@Import — это аннотация конфигурации в Spring Framework, которая позволяет импортировать и регистрировать в контексте приложения компоненты (beans) из других классов конфигурации. Это даёт возможность модульно организовывать конфигурацию Spring приложения, разбивая её на отдельные части и затем объединяя их вместе.

@Import используется для явной регистрации классов конфигурации, поэтому они будут обработаны контейнером Spring и их beans будут добавлены в ApplicationContext.

Основные способы использования @Import

Импорт класса конфигурации:

// Отдельная конфигурация для БД
@Configuration
public class DatabaseConfig {
    
    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost:5432/mydb");
        config.setUsername("user");
        config.setPassword("password");
        return new HikariDataSource(config);
    }
    
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

// Главная конфигурация приложения
@Configuration
@Import(DatabaseConfig.class)
public class AppConfig {
    
    @Bean
    public UserRepository userRepository(JdbcTemplate jdbcTemplate) {
        return new UserRepository(jdbcTemplate);
    }
}

// Запуск приложения
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserRepository repo = context.getBean(UserRepository.class);
    }
}

Импорт нескольких конфигураций:

// Конфигурация для безопасности
@Configuration
public class SecurityConfig {
    
    @Bean
    public SecurityManager securityManager() {
        return new SecurityManager();
    }
}

// Конфигурация для кэширования
@Configuration
public class CacheConfig {
    
    @Bean
    @ConditionalOnMissingBean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("default");
    }
}

// Главная конфигурация импортирует все остальные
@Configuration
@Import({DatabaseConfig.class, SecurityConfig.class, CacheConfig.class})
public class RootConfig {
    // Главная конфигурация
}

Импорт с использованием ImportSelector

ImportSelector позволяет динамически выбирать, какие классы конфигурации импортировать в зависимости от условий:

// Интерфейс для динамического выбора конфигураций
public class EnvironmentImportSelector implements ImportSelector {
    
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        String environment = System.getProperty("app.environment", "dev");
        
        if ("production".equals(environment)) {
            return new String[]{"com.example.config.ProdConfig"};
        } else {
            return new String[]{"com.example.config.DevConfig"};
        }
    }
}

// Использование ImportSelector
@Configuration
@Import(EnvironmentImportSelector.class)
public class AppConfig {
    // Конфигурация, которая будет импортировать DevConfig или ProdConfig
    // в зависимости от переменной окружения
}

Импорт с использованием ImportBeanDefinitionRegistrar

ImportBeanDefinitionRegistrar позволяет программно регистрировать beans в контексте:

// Регистратор для программной регистрации beans
public class CustomBeanRegistrar implements ImportBeanDefinitionRegistrar {
    
    @Override
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata,
            BeanDefinitionRegistry registry) {
        
        BeanDefinition beanDef = new RootBeanDefinition(CustomService.class);
        registry.registerBeanDefinition("customService", beanDef);
        
        // Можно регистрировать несколько beans
        BeanDefinition cacheBean = new RootBeanDefinition(CacheService.class);
        registry.registerBeanDefinition("cacheService", cacheBean);
    }
}

// Использование
@Configuration
@Import(CustomBeanRegistrar.class)
public class AppConfig {
    // Beans будут зарегистрированы программно
}

Практический пример: Модульная архитектура

// Модуль 1: Слой данных
@Configuration
public class DataModule {
    
    @Bean
    public DataSource dataSource() {
        return new HikariDataSource();
    }
    
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

// Модуль 2: Слой репозитория
@Configuration
@Import(DataModule.class)
public class RepositoryModule {
    
    @Bean
    public UserRepository userRepository(JdbcTemplate jdbcTemplate) {
        return new UserRepository(jdbcTemplate);
    }
    
    @Bean
    public OrderRepository orderRepository(JdbcTemplate jdbcTemplate) {
        return new OrderRepository(jdbcTemplate);
    }
}

// Модуль 3: Слой сервиса
@Configuration
@Import(RepositoryModule.class)
public class ServiceModule {
    
    @Bean
    public UserService userService(UserRepository userRepository) {
        return new UserService(userRepository);
    }
    
    @Bean
    public OrderService orderService(OrderRepository orderRepository) {
        return new OrderService(orderRepository);
    }
}

// Главное приложение импортирует все модули
@Configuration
@Import(ServiceModule.class)
public class ApplicationConfig {
    
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(
            ApplicationConfig.class
        );
        
        UserService userService = context.getBean(UserService.class);
        OrderService orderService = context.getBean(OrderService.class);
    }
}

@Import vs другие способы регистрации

@ComponentScan — автоматически сканирует пакеты и регистрирует @Component, @Service, @Repository:

@Configuration
@ComponentScan("com.example")
public class AppConfig {
    // Все компоненты в пакете будут найдены автоматически
}

@Import — явно импортирует конкретные классы конфигурации (более контролируемо):

@Configuration
@Import(DatabaseConfig.class)
public class AppConfig {
    // Только DatabaseConfig будет импортирован
}

Использование в Spring Boot

В Spring Boot @Import часто используется для создания автоконфигураций:

// Настраиваемый класс с аннотацией для экспорта
@Configuration
@ConditionalOnClass(SomeLibrary.class)
public class SomeLibraryAutoConfig {
    
    @Bean
    public SomeLibraryClient someLibraryClient() {
        return new SomeLibraryClient();
    }
}

// В spring.factories или spring.autoconfigure.imports:
// org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
// com.example.SomeLibraryAutoConfig

// Или используется @Import в стартовой конфигурации
@SpringBootApplication
@Import(SomeLibraryAutoConfig.class)
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Порядок обработки @Import

1. Spring обнаруживает аннотацию @Import
2. Загружаются указанные классы конфигурации
3. Если класс — @Configuration, его методы @Bean обрабатываются
4. Если класс реализует ImportSelector, вызывается selectImports()
5. Если класс реализует ImportBeanDefinitionRegistrar, вызывается registerBeanDefinitions()
6. Все beans добавляются в ApplicationContext

@Import — мощный инструмент для организации конфигурации больших приложений, позволяя разбить её на логические модули и переиспользовать конфигурацию между разными проектами.