Какие знаешь способы создания бина, кроме XML-конфигурации и аннотаций?

Способы создания Bean в Spring кроме XML-конфигурации и аннотаций

Spring предоставляет множество способов регистрации бинов помимо классических XML-файлов и @Component/@Bean. Рассмотрю все альтернативные подходы, которые использовал в production системах.

1. @Bean аннотация в @Configuration классе

Технически это не совсем "кроме аннотаций", но это Java-based конфигурация вместо XML:

@Configuration
public class AppConfiguration {
    
    // Явное определение бина как метод
    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
    
    @Bean
    public UserService userService(UserRepository userRepository) {
        // Spring автоматически инъектирует зависимость
        return new UserService(userRepository);
    }
    
    // С условиями
    @Bean
    @ConditionalOnProperty(name = "feature.enabled", havingValue = "true")
    public SpecialService specialService() {
        return new SpecialService();
    }
    
    // С разными профилями
    @Bean
    @Profile("production")
    public DataSource productionDataSource() {
        return new ProductionDataSource();
    }
    
    @Bean
    @Profile("development")
    public DataSource devDataSource() {
        return new DevDataSource();
    }
}

2. BeanFactory функциональный API (Spring 5.0+)

Модерный способ для programmatic регистрации:

@SpringBootApplication
public class Application {
    
    public static void main(String[] args) {
        // Вместо стандартного SpringApplication.run()
        new GenericApplicationContext() {{
            // Регистрируем бины функционально
            registerBean(UserRepository.class);
            registerBean(UserService.class, 
                () -> new UserService(getBean(UserRepository.class)));
            registerBean(String.class, () -> "Hello World");
            
            refresh();  // Инициализируем контекст
        }}
        .run(args);
    }
}

Iли через BeanDefinitionRegistry:

@Configuration
public class DynamicBeanConfiguration implements BeanDefinitionRegistryPostProcessor {
    
    @Override
    public void postProcessBeanDefinitionRegistry(
            BeanDefinitionRegistry registry) throws BeansException {
        
        // Динамически регистрируем бины
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(UserService.class);
        beanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
        
        registry.registerBeanDefinition("userService", beanDefinition);
    }
}

3. BeanDefinitionBuilder (программное создание)

Мощный способ создавать бины runtime:

@Component
public class DynamicBeanRegistrar {
    
    private final BeanFactory beanFactory;
    private final DefaultListableBeanFactory defaultListableBeanFactory;
    
    public void registerDynamicBean() {
        // Получаем регистр
        DefaultListableBeanFactory registry = 
            (DefaultListableBeanFactory) beanFactory;
        
        // Строим определение бина
        BeanDefinition beanDefinition = BeanDefinitionBuilder
                .genericBeanDefinition(UserService.class)
                .addConstructorArgReference("userRepository")  // Зависимость
                .setScope(BeanDefinition.SCOPE_SINGLETON)
                .getPrimaryBeanDefinition();
        
        // Регистрируем
        registry.registerBeanDefinition("dynamicUserService", beanDefinition);
    }
}

4. InitializingBean + FactoryBean

Минимальный способ для создания объектов с логикой:

// Стандартный способ с FactoryBean
public class UserRepositoryFactoryBean 
        implements FactoryBean<UserRepository> {
    
    @Override
    public UserRepository getObject() throws Exception {
        // Сложная логика создания
        UserRepository repo = new UserRepositoryImpl();
        repo.initialize();  // Инициализация
        return repo;
    }
    
    @Override
    public Class<?> getObjectType() {
        return UserRepository.class;
    }
    
    @Override
    public boolean isSingleton() {
        return true;  // singleton scope
    }
}

// Регистрируем через XML или @Bean
@Configuration
public class Config {
    @Bean
    public FactoryBean<UserRepository> userRepository() {
        return new UserRepositoryFactoryBean();
    }
}

// Использование: Spring автоматически вызовет getObject()
@Service
public class UserService {
    @Autowired
    private UserRepository repository;  // Получит результат getObject()
}

5. BeanPostProcessor (трансформация существующих бинов)

Для модификации бинов ДО их регистрации:

@Component
public class LoggingBeanPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("Creating bean: " + beanName);
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // Можно создать прокси, обернуть, логировать
        if (bean instanceof UserService) {
            return new UserServiceProxy((UserService) bean);  // Прокси!
        }
        return bean;
    }
}

public class UserServiceProxy implements UserService {
    private final UserService delegate;
    
    public UserServiceProxy(UserService delegate) {
        this.delegate = delegate;
    }
    
    @Override
    public User getUser(Long id) {
        long start = System.currentTimeMillis();
        User result = delegate.getUser(id);
        long duration = System.currentTimeMillis() - start;
        System.out.println("getUser took: " + duration + "ms");
        return result;
    }
}

6. ImportBeanDefinitionRegistrar (для библиотек)

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

public class MyBeanRegistrar implements ImportBeanDefinitionRegistrar {
    
    @Override
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata,
            BeanDefinitionRegistry registry) {
        
        // Регистрируем несколько бинов
        BeanDefinition bean1 = new GenericBeanDefinition();
        bean1.setBeanClassName("com.example.UserService");
        registry.registerBeanDefinition("userService", bean1);
        
        BeanDefinition bean2 = new GenericBeanDefinition();
        bean2.setBeanClassName("com.example.UserRepository");
        registry.registerBeanDefinition("userRepository", bean2);
    }
}

// Активируем через @Import
@Configuration
@Import(MyBeanRegistrar.class)
public class AppConfiguration {
}

7. @Import для регистрации @Configuration классов

Прямая регистрация конфигурационных классов:

// Модуль 1
@Configuration
public class DatabaseConfiguration {
    @Bean
    public DataSource dataSource() {
        return new DataSource();
    }
}

// Модуль 2
@Configuration
public class ServiceConfiguration {
    @Bean
    public UserService userService(DataSource dataSource) {
        return new UserService(dataSource);
    }
}

// Главная конфигурация
@Configuration
@Import({DatabaseConfiguration.class, ServiceConfiguration.class})
public class AppConfiguration {
    // Все бины из импортированных конфигураций будут зарегистрированы
}

8. Groovy Bean Definition DSL

Для конфигурации через Groovy (красивая синтаксис):

// application.groovy
import org.springframework.context.annotation.Bean

beans {
    userRepository(UserRepositoryImpl) {
        // Пример конфигурации
    }
    
    userService(UserService) {
        repository = userRepository  // Инъекция
    }
    
    // Условная регистрация
    if (System.getProperty(profile) == production) {
        productionService(ProductionService)
    }
}

Загрузка:

public class GroovyConfigApplication {
    public static void main(String[] args) {
        new GenericGroovyApplicationContext(
            "classpath:application.groovy"
        );
    }
}

9. ObjectProvider (для optional зависимостей)

Мягкое внедрение с fallback:

@Service
public class UserService {
    private final UserRepository userRepository;
    private final CacheService cacheService;  // Optional
    
    public UserService(
            UserRepository userRepository,
            ObjectProvider<CacheService> cacheServiceProvider) {
        this.userRepository = userRepository;
        // Если CacheService зарегистрирован, используем его
        // Если нет, используем null
        this.cacheService = cacheServiceProvider.getIfAvailable();
    }
    
    public User getUser(Long id) {
        if (cacheService != null) {
            return cacheService.getUser(id);  // С кэшем
        }
        return userRepository.findById(id).orElse(null);  // Без кэша
    }
}

10. Programmatic Registration с GenericApplicationContext

Полная programmatic регистрация без конфигов:

public class ProgrammaticBeanRegistration {
    
    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        
        // Регистрируем бины
        context.registerBean(
            "userRepository",
            UserRepository.class,
            UserRepositoryImpl::new
        );
        
        context.registerBean(
            "userService",
            UserService.class,
            () -> new UserService(context.getBean(UserRepository.class))
        );
        
        context.registerBean(
            "messageSource",
            MessageSource.class,
            () -> {
                ResourceBundleMessageSource ms = new ResourceBundleMessageSource();
                ms.setBasename("messages");
                return ms;
            }
        );
        
        // Инициализируем контекст
        context.refresh();
        
        // Используем
        UserService userService = context.getBean(UserService.class);
        userService.doSomething();
    }
}

11. Spring Boot Auto-Configuration (@Conditional)

Для автоматических конфигураций на основе условий:

@Configuration
@ConditionalOnClass(DataSource.class)  // Если класс в classpath
@ConditionalOnProperty(
    name = "app.database.enabled",
    havingValue = "true",
    matchIfMissing = true
)
public class DataSourceAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean  // Если уже нет такого бина
    public DataSource dataSource() {
        return new HikariDataSource();
    }
}

12. META-INF/spring.factories (Spring Boot)

Для auto-configuration библиотек:

# META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyAutoConfiguration,\
com.example.AnotherAutoConfiguration

@Configuration
public class MyAutoConfiguration {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

13. @ComponentScan с basePackages (pattern-based)

Автоматическое сканирование по пакетам:

@Configuration
@ComponentScan(
    basePackages = "com.example",
    includeFilters = @ComponentScan.Filter(
        type = FilterType.REGEX,
        pattern = ".*Service"
    ),
    excludeFilters = @ComponentScan.Filter(
        type = FilterType.ASSIGNABLE_TYPE,
        classes = SpecialService.class
    )
)
public class ScanConfiguration {
}

14. ApplicationContextInitializer (на старте)

Для инициализации бинов на старте приложения:

public class CustomApplicationContextInitializer 
        implements ApplicationContextInitializer<GenericApplicationContext> {
    
    @Override
    public void initialize(GenericApplicationContext applicationContext) {
        // Регистрируем бины ДО refresh
        applicationContext.registerBean("config", AppConfig.class);
        applicationContext.registerBean("service", MyService.class);
    }
}

// Активируем
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        app.addInitializers(new CustomApplicationContextInitializer());
        app.run(args);
    }
}

Сравнительная таблица

Мой рекомендуемый подход (production stack)

// Уровень 1: основные бины (через @Bean)
@Configuration
public class CoreConfiguration {
    @Bean
    public UserRepository userRepository() { }
    
    @Bean
    public UserService userService(UserRepository repo) { }
}

// Уровень 2: условные бины (через @Conditional)
@Configuration
@ConditionalOnProperty("feature.cache.enabled")
public class CacheConfiguration {
    @Bean
    public CacheService cacheService() { }
}

// Уровень 3: динамическое расширение (через BeanDefinitionRegistry)
@Component
public class DynamicBeanRegistrar implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        // Регистрируем runtime бины
    }
}

// Уровень 4: трансформация (через BeanPostProcessor)
@Component
public class MonitoringBeanPostProcessor implements BeanPostProcessor {
    // Добавляем мониторинг ко всем бинам
}

В production я обычно использую комбинацию @Bean + @Conditional + BeanPostProcessor, это обеспечивает баланс между простотой и гибкостью.