Как разрешать конфликты при построении Bean

Ответ

Конфликты при построении Bean в Spring обычно возникают при инъекции зависимостей. Это частая проблема, которая имеет несколько решений.

Типы конфликтов

1. NoUniqueBeanDefinitionException

Когда есть несколько Bean одного типа:

@Configuration
public class BeanConfig {
    @Bean
    public DataSource dataSource1() {
        return new HikariDataSource();
    }
    
    @Bean
    public DataSource dataSource2() {
        return new HikariDataSource();
    }
}

@Service
public class MyService {
    // ERROR: required a single bean, but 2 were found
    @Autowired
    private DataSource dataSource;
}

Решение 1: @Qualifier

@Configuration
public class BeanConfig {
    @Bean(name = "primaryDataSource")
    public DataSource dataSource1() {
        return new HikariDataSource();
    }
    
    @Bean(name = "secondaryDataSource")
    public DataSource dataSource2() {
        return new HikariDataSource();
    }
}

@Service
public class MyService {
    private final DataSource primaryDs;
    private final DataSource secondaryDs;
    
    public MyService(
        @Qualifier("primaryDataSource") DataSource primary,
        @Qualifier("secondaryDataSource") DataSource secondary
    ) {
        this.primaryDs = primary;
        this.secondaryDs = secondary;
    }
}

Решение 2: @Primary

@Configuration
public class BeanConfig {
    @Bean
    @Primary
    public DataSource primaryDataSource() {
        return new HikariDataSource();
    }
    
    @Bean
    public DataSource cacheDataSource() {
        return new HikariDataSource();
    }
}

@Service
public class MyService {
    private final DataSource dataSource;  // Автоматически primaryDataSource
    
    public MyService(DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

2. NoSuchBeanDefinitionException

Когда Bean не найден:

@Service
public class MyService {
    // ERROR: No bean named 'unknownBean' available
    @Autowired
    @Qualifier("unknownBean")
    private SomeService service;
}

Решение 1: Убедиться что Bean зарегистрирован

@Configuration
public class BeanConfig {
    @Bean(name = "unknownBean")
    public SomeService createService() {
        return new SomeService();
    }
}

Решение 2: Сделать зависимость optional

@Service
public class MyService {
    private final SomeService service;
    
    public MyService(Optional<SomeService> service) {
        this.service = service.orElse(new DefaultService());
    }
}

3. BeanCreationException — циклические зависимости

Когда Bean A зависит от B, а B от A:

@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
}

@Service
public class ServiceB {
    @Autowired
    private ServiceA serviceA;  // CIRCULAR DEPENDENCY!
}

Решение 1: Инъекция через setter вместо constructor

@Service
public class ServiceA {
    private ServiceB serviceB;
    
    @Autowired
    public void setServiceB(ServiceB serviceB) {
        this.serviceB = serviceB;  // Setter инъекция менее strict
    }
}

@Service
public class ServiceB {
    private ServiceA serviceA;
    
    @Autowired
    public void setServiceA(ServiceA serviceA) {
        this.serviceA = serviceA;
    }
}

Решение 2: Использовать ObjectProvider

@Service
public class ServiceA {
    private final ObjectProvider<ServiceB> serviceBProvider;
    
    public ServiceA(ObjectProvider<ServiceB> serviceBProvider) {
        this.serviceBProvider = serviceBProvider;
    }
    
    public void doSomething() {
        ServiceB serviceB = serviceBProvider.getIfAvailable();
        if (serviceB != null) {
            serviceB.process();
        }
    }
}

Решение 3: Рефакторить архитектуру

Обычно циклические зависимости указывают на проблему дизайна. Рефакторьте:

// Создайте третий сервис
@Service
public class SharedService {
    public void sharedLogic() {
        // Логика, нужная обоим
    }
}

@Service
public class ServiceA {
    private final SharedService shared;
    
    public ServiceA(SharedService shared) {
        this.shared = shared;
    }
}

@Service
public class ServiceB {
    private final SharedService shared;
    
    public ServiceB(SharedService shared) {
        this.shared = shared;
    }
}

4. BeanInstantiationException — ошибка при создании Bean

@Configuration
public class BeanConfig {
    @Bean
    public ComplexService complexService() {
        // Exception во время создания
        return new ComplexService(null);  // NullPointerException
    }
}

Решение: Обработать ошибку

@Configuration
public class BeanConfig {
    @Bean
    public ComplexService complexService() throws Exception {
        try {
            String config = loadConfig();
            return new ComplexService(config);
        } catch (Exception e) {
            log.error("Failed to create ComplexService", e);
            return new ComplexService("default-config");
        }
    }
    
    private String loadConfig() throws Exception {
        // Loading logic
        return "some-config";
    }
}

5. Конфликты при наследовании конфигурации

// Parent configuration
@Configuration
public class BaseConfig {
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

// Child configuration
@Configuration
public class AppConfig extends BaseConfig {
    @Bean
    public UserService userService() {  // OVERRIDES parent
        return new EnhancedUserService();
    }
}

Решение: Быть explicit о том что вы делаете

@Configuration
public class BaseConfig {
    @Bean
    @ConditionalOnMissingBean(name = "userService")
    public UserService userService() {
        return new UserService();
    }
}

@Configuration
public class AppConfig {
    @Bean
    @Primary
    public UserService userService() {
        return new EnhancedUserService();
    }
}

6. Конфликты с Component Scanning

// Если сканируешь несколько пакетов
@SpringBootApplication
@ComponentScan(basePackages = {"com.app", "com.shared"})
public class Application {}

// И в обоих пакетах есть один и тот же компонент
@Component
public class ConfigService {  // в com.app
}

@Component
public class ConfigService {  // в com.shared - CONFLICT!
}

Решение: Исключить пакет

@SpringBootApplication
@ComponentScan(
    basePackages = {"com.app"},
    excludeFilters = @ComponentScan.Filter(
        type = FilterType.REGEX,
        pattern = "com\\.shared\\..*"
    )
)
public class Application {}

7. Проблемы с порядком инициализации Bean

@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
    
    @PostConstruct
    public void init() {
        // serviceB может быть null, если B инициализируется позже!
        serviceB.doSomething();
    }
}

Решение: Использовать DependsOn

@Service
@DependsOn("serviceB")  // Явно говорим что нужно B
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
    
    @PostConstruct
    public void init() {
        serviceB.doSomething();  // Теперь безопасно
    }
}

Правила разрешения конфликтов

1. NoUniqueBean → @Qualifier или @Primary
2. NoSuchBean → Проверить конфигурацию или сделать Optional
3. Циклические → Рефакторить архитектуру или ObjectProvider
4. Instantiation error → Обработать исключение
5. Наследование → @ConditionalOnMissingBean
6. Scanning conflicts → ComponentScan excludeFilters
7. Order issues → @DependsOn

Лучшие практики

✓ Используй constructor injection (явно показывает зависимости)
✓ Одна ответственность на Bean
✓ Избегай циклических зависимостей
✓ Даёшь явные имена Bean
✓ Используй @Primary осторожно
✓ Профилируй конфигурацию (за что отвечает каждая часть)
✓ Пиши юнит тесты для конфигурации

Тестирование конфигурации

@SpringBootTest
public class BeanConfigurationTest {
    
    @Autowired
    private ApplicationContext context;
    
    @Test
    void shouldHaveRequiredBeans() {
        // Проверяем что нужные бины создались
        assertNotNull(context.getBean(UserService.class));
        assertNotNull(context.getBean("primaryDataSource"));
        assertNotNull(context.getBean("secondaryDataSource"));
    }
    
    @Test
    void shouldResolveQualifiers() {
        // Проверяем что квалификаторы работают
        DataSource primary = context.getBean("primaryDataSource", DataSource.class);
        DataSource secondary = context.getBean("secondaryDataSource", DataSource.class);
        
        assertNotSame(primary, secondary);
    }
}

Основной принцип: Spring конфликты обычно говорят о проблемах дизайна. Решайте конфликты рефакторингом архитектуры, а не хаками в конфигурации.