Как можно использовать бины с внедрением зависимостей?

Использование бинов с внедрением зависимостей в Spring

Внедрение зависимостей (Dependency Injection) — это ключевой паттерн в Spring Framework. Вот различные способы использования бинов с DI, которые я применяю в разработке.

1. Аннотация @Autowired — классический способ

Самый базовый и распространённый способ:

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private EmailService emailService;
    
    public User createUser(String email) {
        User user = new User(email);
        userRepository.save(user);
        emailService.sendWelcomeEmail(email);
        return user;
    }
}

Проблема: если бин не найден, вызовется исключение. Можно сделать опциональным:

@Autowired(required = false)
private OptionalService optionalService;

2. Constructor Injection — рекомендуемый способ

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

@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    // Spring автоматически найдёт бины и внедрит их
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
    
    public User createUser(String email) {
        User user = new User(email);
        userRepository.save(user);
        emailService.sendWelcomeEmail(email);
        return user;
    }
}

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

• Зависимости явные
• Можно использовать final поля (immutable)
• Легче тестировать
• Работает без @Autowired

3. Setter Injection

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

@Service
public class UserService {
    private UserRepository userRepository;
    private EmailService emailService;
    
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @Autowired(required = false)
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
}

4. Injection через аннотацию @Inject (Jakarta/Java)

Стандарт Java вместо Spring аннотации:

import jakarta.inject.Inject;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Inject
    private UserRepository userRepository;
    
    @Inject
    private EmailService emailService;
}

5. Inject Optional зависимостей

Для зависимостей, которые могут отсутствовать:

import java.util.Optional;

@Service
public class UserService {
    private final UserRepository userRepository;
    private final Optional<NotificationService> notificationService;
    
    public UserService(UserRepository userRepository, 
                      Optional<NotificationService> notificationService) {
        this.userRepository = userRepository;
        this.notificationService = notificationService;
    }
    
    public void notifyUser(Long userId, String message) {
        notificationService.ifPresent(service -> 
            service.notify(userId, message)
        );
    }
}

6. Injection List или Set бинов

Когда нужно внедрить все реализации интерфейса:

public interface EventHandler {
    void handle(Event event);
}

@Component
public class EmailEventHandler implements EventHandler {
    @Override
    public void handle(Event event) {
        System.out.println("Email: " + event);
    }
}

@Component
public class LogEventHandler implements EventHandler {
    @Override
    public void handle(Event event) {
        System.out.println("Log: " + event);
    }
}

// В сервисе:
@Service
public class EventService {
    private final List<EventHandler> handlers;
    
    public EventService(List<EventHandler> handlers) {
        this.handlers = handlers; // Оба хендлера будут внедрены
    }
    
    public void processEvent(Event event) {
        handlers.forEach(handler -> handler.handle(event));
    }
}

7. Qualifier для уточнения бина

Когда несколько реализаций одного интерфейса:

public interface PaymentGateway {
    void pay(BigDecimal amount);
}

@Service
@Qualifier("stripe")
public class StripePaymentGateway implements PaymentGateway {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Paying via Stripe: " + amount);
    }
}

@Service
@Qualifier("paypal")
public class PayPalPaymentGateway implements PaymentGateway {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Paying via PayPal: " + amount);
    }
}

// Использование:
@Service
public class PaymentService {
    private final PaymentGateway stripeGateway;
    private final PaymentGateway paypalGateway;
    
    public PaymentService(
            @Qualifier("stripe") PaymentGateway stripeGateway,
            @Qualifier("paypal") PaymentGateway paypalGateway) {
        this.stripeGateway = stripeGateway;
        this.paypalGateway = paypalGateway;
    }
}

8. Primary бин

Для случаев, когда один бин используется чаще:

@Service
@Primary
public class PrimaryPaymentGateway implements PaymentGateway {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Primary gateway");
    }
}

// Будет использована PrimaryPaymentGateway по умолчанию
@Service
public class OrderService {
    private final PaymentGateway gateway;
    
    public OrderService(PaymentGateway gateway) {
        this.gateway = gateway;
    }
}

9. Создание бинов через @Bean в конфигурации

Для внешних классов или сложной инициализации:

@Configuration
public class AppConfig {
    
    @Bean
    public UserRepository userRepository() {
        return new JpaUserRepository();
    }
    
    @Bean
    public EmailService emailService() {
        // Сложная инициализация
        SmtpConfig config = new SmtpConfig("smtp.gmail.com", 587);
        return new GmailEmailService(config);
    }
    
    // Автоматически найдётся userRepository благодаря параметру
    @Bean
    public UserService userService(UserRepository userRepository, 
                                   EmailService emailService) {
        return new UserService(userRepository, emailService);
    }
}

10. Lazy инициализация

Для бинов, которые инициализируются редко:

@Service
@Lazy
public class ExpensiveService {
    public ExpensiveService() {
        System.out.println("Инициализация дорогой операции");
    }
}

// ExpensiveService будет создан только когда его используют
@Service
public class MainService {
    private final ObjectProvider<ExpensiveService> expensiveServiceProvider;
    
    public MainService(ObjectProvider<ExpensiveService> provider) {
        this.expensiveServiceProvider = provider;
    }
    
    public void doSomething() {
        ExpensiveService service = expensiveServiceProvider.getObject();
        service.process();
    }
}

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

1. Constructor Injection — используй как основной метод
2. Final fields — для immutability
3. Явные зависимости — видно с первого взгляда
4. @Qualifier — когда несколько реализаций
5. @Primary — для default реализации
6. Тестируемость — DI облегчает unit-тесты

Этот подход делает код более гибким, тестируемым и легко поддерживаемым.