Как избежать падения приложения, если Spring не найдет Bean?

Как избежать падения приложения, если Spring не найдет Bean

Отсутствие нужного Bean может привести к критической ошибке на старте приложения. Существует несколько стратегий для изящной обработки такой ситуации.

1. Optional зависимости

Используй Optional для необязательных бинов:

@Service
public class EmailService {
    private final Optional<SmtpClient> smtpClient;
    
    public EmailService(Optional<SmtpClient> smtpClient) {
        this.smtpClient = smtpClient;
    }
    
    public void sendEmail(String to, String subject, String body) {
        if (smtpClient.isPresent()) {
            smtpClient.get().send(to, subject, body);
        } else {
            log.warn("SMTP не сконфигурирован, письмо не отправлено");
        }
    }
}

2. @Autowired(required = false)

@Service
public class PaymentService {
    
    @Autowired(required = false)
    private PaymentGateway paymentGateway;
    
    public void processPayment(Order order) {
        if (paymentGateway != null) {
            paymentGateway.charge(order.getAmount());
        } else {
            log.warn("Payment gateway not configured, skipping payment");
        }
    }
}

3. ObjectProvider для graceful handling

@Service
public class NotificationService {
    private final ObjectProvider<EmailNotificationHandler> emailHandler;
    private final ObjectProvider<SmsNotificationHandler> smsHandler;
    
    public NotificationService(
        ObjectProvider<EmailNotificationHandler> emailHandler,
        ObjectProvider<SmsNotificationHandler> smsHandler) {
        this.emailHandler = emailHandler;
        this.smsHandler = smsHandler;
    }
    
    public void notify(User user, String message) {
        emailHandler.ifAvailable(handler -> 
            handler.send(user.getEmail(), message)
        );
        
        smsHandler.ifAvailable(handler -> 
            handler.send(user.getPhone(), message)
        );
    }
}

4. Conditional Bean Registration

@Configuration
public class ExternalServiceConfig {
    
    @Bean
    @ConditionalOnProperty(
        name = "payment.gateway.enabled",
        havingValue = "true",
        matchIfMissing = false
    )
    public PaymentGateway paymentGateway() {
        return new StripePaymentGateway();
    }
    
    @Bean
    @ConditionalOnBean(PaymentGateway.class)
    public PaymentProcessor paymentProcessor(PaymentGateway gateway) {
        return new PaymentProcessor(gateway);
    }
}

5. Fallback бины

@Configuration
public class CacheConfig {
    
    @Bean
    @ConditionalOnProperty(
        name = "cache.redis.enabled",
        havingValue = "true"
    )
    public CacheService redisCacheService() {
        return new RedisCacheService();
    }
    
    @Bean
    @ConditionalOnMissingBean(CacheService.class)
    public CacheService fallbackCacheService() {
        log.warn("Redis not available, using in-memory cache fallback");
        return new InMemoryCacheService();
    }
}

6. Primary & Secondary бины

@Configuration
public class DatabaseConfig {
    
    @Bean
    @Primary
    public DataSource primaryDataSource() {
        return DriverManagerDataSource("jdbc:mysql://primary-host/db");
    }
    
    @Bean
    public DataSource secondaryDataSource() {
        return DriverManagerDataSource("jdbc:mysql://secondary-host/db");
    }
}

@Service
public class DataAccessService {
    private final DataSource dataSource; // Вприоритете primary
    
    public DataAccessService(DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

7. List инъекция (множественные реализации)

@Service
public class AuthenticationService {
    private final List<AuthProvider> providers;
    
    public AuthenticationService(List<AuthProvider> providers) {
        this.providers = providers; // Работает даже если список пуст
    }
    
    public User authenticate(String username, String password) {
        return providers.stream()
            .flatMap(provider -> provider.authenticate(username, password).stream())
            .findFirst()
            .orElseThrow(() -> new AuthenticationException("No auth provider available"));
    }
}

8. Event-driven fallback

@Component
public class ApplicationStartupListener implements ApplicationListener<ContextRefreshedEvent> {
    
    private final ObjectProvider<CriticalService> criticalService;
    
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (criticalService.getIfAvailable() == null) {
            log.error("Critical service not found, entering fallback mode");
            setupFallbackMode(event.getApplicationContext());
        }
    }
    
    private void setupFallbackMode(ApplicationContext context) {
        // Регистрация fallback компонентов
        // Отправка алерта в мониторинг
    }
}

9. Constructor injection с валидацией

@Service
public class OrderService {
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    
    public OrderService(
        @Qualifier("paymentService") Optional<PaymentService> paymentService,
        @Qualifier("inventoryService") Optional<InventoryService> inventoryService) {
        
        this.paymentService = paymentService.orElseThrow(() -> 
            new BeanInitializationException("PaymentService is required"));
        this.inventoryService = inventoryService.orElseThrow(() -> 
            new BeanInitializationException("InventoryService is required"));
    }
}

10. Configuration properties для управления

app:
  features:
    email-notifications: true
    sms-notifications: false
    analytics: true
  database:
    primary: enabled
    replica: disabled

@Configuration
@EnableConfigurationProperties(FeatureToggleProperties.class)
public class FeatureConfig {
    
    private final FeatureToggleProperties properties;
    
    @Bean
    @ConditionalOnProperty(
        prefix = "app.features",
        name = "email-notifications",
        havingValue = "true"
    )
    public EmailNotificationHandler emailHandler() {
        return new EmailNotificationHandler();
    }
}

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

1. Разделяй обязательные и необязательные сервисы — чётко обозначай в коде
2. Используй ObjectProvider — самый гибкий подход с методами ifPresent(), ifPresentOrElse()
3. Логируй предупреждения — всегда сообщай об отсутствии компонентов
4. Тестируй fallback сценарии — убедись, что приложение работает без опциональных сервисов
5. Документируй конфигурацию — покажи, какие компоненты опциональны

Выбор подхода зависит от критичности сервиса: опциональные используют Optional/ObjectProvider, обязательные требуют явного управления и валидации при старте.