Какие знаешь способы инъекции Bean?

Способы инъекции Bean в Spring

Депендеци инъекция (DI) — один из столпов Spring Framework. Spring предоставляет несколько способов внедрения зависимостей, каждый со своими преимуществами и недостатками.

1. Constructor Injection (Инъекция через конструктор)

Это рекомендуемый способ, обеспечивающий неизменяемость и явные зависимости:

@Service
public class UserService {
    private final UserRepository repository;
    private final EmailService emailService;
    private final Logger logger;
    
    // Constructor injection
    public UserService(UserRepository repository, EmailService emailService) {
        this.repository = Objects.requireNonNull(repository, "Repository не может быть null");
        this.emailService = Objects.requireNonNull(emailService, "EmailService не может быть null");
        this.logger = LoggerFactory.getLogger(UserService.class);
    }
    
    public User createUser(CreateUserRequest request) {
        return repository.save(mapToUser(request));
    }
}

Преимущества:

• Неизменяемость — все зависимости final
• Явность — легко увидеть все зависимости конструктора
• Null-safety — можно проверить на null при создании
• Тестируемость — легко создать Mock'и в тестах
• Циклические зависимости выявляются сразу

Недостатки:

• Конструктор может стать очень длинным с большим количеством зависимостей (признак нарушения SRP)

2. Setter Injection (Инъекция через setter)

Легаси способ, но всё ещё используется:

@Service
public class OrderService {
    private UserRepository userRepository;
    private PaymentService paymentService;
    
    // Setter injection
    @Autowired
    public void setUserRepository(UserRepository repository) {
        this.userRepository = repository;
    }
    
    @Autowired
    public void setPaymentService(PaymentService service) {
        this.paymentService = service;
    }
    
    public Order createOrder(CreateOrderRequest request) {
        User user = userRepository.findById(request.getUserId());
        paymentService.charge(user, request.getAmount());
        return new Order(user);
    }
}

Преимущества:

• Опциональные зависимости — можно оставить null
• Переиспользование конструктора — без параметров

Недостатки:

• Изменяемость — объект можно менять после создания
• Неполнота — объект может быть в неполном состоянии
• Скрытые зависимости — не видно из сигнатуры класса
• Циклические зависимости могут не выявиться сразу

3. Field Injection (Инъекция через поле)

Самый удобный, но и самый опасный способ:

@Service
public class NotificationService {
    
    @Autowired
    private EmailService emailService;
    
    @Autowired
    private SmsService smsService;
    
    @Autowired
    private LoggerService loggerService;
    
    public void notifyUser(User user, String message) {
        emailService.send(user.getEmail(), message);
        smsService.send(user.getPhone(), message);
        loggerService.log("Notification sent");
    }
}

Преимущества:

• Краткость — минимум кода
• Удобство — простая конфигурация

Недостатки:

• Скрытые зависимости — не видно из конструктора
• Изменяемость — легко случайно переписать
• Сложно тестировать — нужна рефлексия для Mock'ов
• NullPointerException риск — неизвестно, инициализировано ли поле
• Нарушает инкапсуляцию — поля должны быть private

4. Qualifier Injection (Выбор конкретной реализации)

Когда есть несколько Bean'ов одного интерфейса:

// Определение Bean'ов
@Configuration
public class PaymentConfig {
    
    @Bean
    @Qualifier("paypalPayment")
    public PaymentProcessor paypalPayment() {
        return new PayPalProcessor();
    }
    
    @Bean
    @Qualifier("stripePayment")
    public PaymentProcessor stripePayment() {
        return new StripeProcessor();
    }
}

// Использование
@Service
public class CheckoutService {
    private final PaymentProcessor paymentProcessor;
    
    // Указываем какой Bean использовать
    public CheckoutService(@Qualifier("stripePayment") PaymentProcessor processor) {
        this.paymentProcessor = processor;
    }
    
    public void checkout(Order order) {
        paymentProcessor.process(order);
    }
}

5. Primary Bean Injection

Указание основного Bean'а:

@Configuration
public class DatabaseConfig {
    
    @Bean
    @Primary  // Этот Bean используется по умолчанию
    public DataSource primaryDataSource() {
        return new PrimaryDataSource();
    }
    
    @Bean
    public DataSource replicaDataSource() {
        return new ReplicaDataSource();
    }
}

// Использование (без @Qualifier)
@Service
public class UserRepository {
    
    public UserRepository(DataSource dataSource) {
        // Автоматически используется primaryDataSource
    }
}

6. ObjectProvider Injection

Для опциональных и ленивых зависимостей:

@Service
public class ReportService {
    private final ObjectProvider<CacheService> cacheServiceProvider;
    private final ObjectProvider<MetricsService> metricsService;
    
    public ReportService(
            ObjectProvider<CacheService> cacheServiceProvider,
            ObjectProvider<MetricsService> metricsService) {
        this.cacheServiceProvider = cacheServiceProvider;
        this.metricsService = metricsService;
    }
    
    public Report generateReport(String id) {
        // getIfAvailable — вернёт null, если Bean не зарегистрирован
        CacheService cache = cacheServiceProvider.getIfAvailable();
        if (cache != null) {
            Report cached = cache.get(id);
            if (cached != null) return cached;
        }
        
        Report report = new Report();
        
        // ifAvailable — выполнить, если Bean доступен
        metricsService.ifAvailable(m -> m.incrementReportCount());
        
        return report;
    }
}

7. Optional Injection

Для опциональных зависимостей:

@Service
public class AnalyticsService {
    private final Optional<GoogleAnalytics> googleAnalytics;
    private final Optional<MixPanel> mixPanel;
    
    public AnalyticsService(
            Optional<GoogleAnalytics> googleAnalytics,
            Optional<MixPanel> mixPanel) {
        this.googleAnalytics = googleAnalytics;
        this.mixPanel = mixPanel;
    }
    
    public void trackEvent(String eventName, Map<String, Object> data) {
        googleAnalytics.ifPresent(ga -> ga.track(eventName, data));
        mixPanel.ifPresent(mp -> mp.track(eventName, data));
    }
}

8. List Injection

Инъекция всех Bean'ов одного типа:

@Configuration
public class ValidatorConfig {
    
    @Bean
    public Validator emailValidator() {
        return new EmailValidator();
    }
    
    @Bean
    public Validator phoneValidator() {
        return new PhoneValidator();
    }
    
    @Bean
    public Validator lengthValidator() {
        return new LengthValidator();
    }
}

// Использование
@Service
public class ValidationChain {
    private final List<Validator> validators;
    
    // Все Validator Bean'ы инъектятся в список
    public ValidationChain(List<Validator> validators) {
        this.validators = validators;
    }
    
    public void validate(String input) {
        for (Validator validator : validators) {
            validator.validate(input);
        }
    }
}

9. Map Injection

Инъекция всех Bean'ов с ключами:

@Configuration
public class HandlerConfig {
    
    @Bean
    public Handler jsonHandler() {
        return new JsonHandler();
    }
    
    @Bean
    public Handler xmlHandler() {
        return new XmlHandler();
    }
    
    @Bean
    public Handler csvHandler() {
        return new CsvHandler();
    }
}

// Использование
@Service
public class FileProcessor {
    private final Map<String, Handler> handlers;
    
    // Ключи — это имена Bean'ов
    public FileProcessor(Map<String, Handler> handlers) {
        this.handlers = handlers;
    }
    
    public void process(String format, byte[] data) {
        Handler handler = handlers.get(format + "Handler");
        if (handler != null) {
            handler.handle(data);
        }
    }
}

10. Lookup Method Injection

Для внедрения Bean'ов с разными scope'ами:

// Bean с prototype scope
@Component
@Scope("prototype")
public class RequestContext {
    private String requestId;
    
    public RequestContext() {
        this.requestId = UUID.randomUUID().toString();
    }
}

// Singleton, который нужны новый RequestContext для каждого запроса
@Service
public abstract class RequestProcessor {
    
    @Lookup
    protected abstract RequestContext createRequestContext();
    
    public void processRequest(String data) {
        RequestContext context = createRequestContext();
        System.out.println("Processing with context: " + context.getRequestId());
    }
}

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

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

1. Используй Constructor Injection — это стандарт
2. Избегай Field Injection — сложно тестировать и скрытые зависимости
3. Используй Qualifier когда много реализаций одного интерфейса
4. Используй Optional для действительно опциональных зависимостей
5. Используй List/Map для plugin-подобной архитектуры
6. Проверяй на null в Constructor Injection
7. Не создавай циклические зависимости — это признак проблемы в дизайне
8. Логируй инъекции в отладке — помогает понять порядок инициализации
9. Используй @Lazy для отложенной инициализации дорогих Bean'ов
10. Разделяй Bean'ы по слоям — Repository, Service, Controller