Как реализуется Dependency Injection в Spring Boot?

Dependency Injection в Spring Boot

Dependency Injection (DI) — это ключевой паттерн в Spring Boot, который позволяет автоматически подставлять зависимости в класс, вместо того чтобы класс сам их создавал. Это обеспечивает слабую связанность кода, упрощает тестирование и делает приложение более гибким и поддерживаемым.

Основные механизмы DI в Spring Boot

1. Автоматическая регистрация Bean с помощью аннотаций

Spring сканирует приложение и автоматически регистрирует компоненты с аннотациями @Component, @Service, @Repository, @Controller. Эти классы становятся Bean и управляются контейнером Spring.

@Service
public class UserService {
    public void saveUser(String name) {
        System.out.println("User saved: " + name);
    }
}

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    
    @GetMapping("/users/save")
    public void save() {
        userService.saveUser("John");
    }
}

Spring автоматически инъектирует UserService в UserController.

2. Внедрение через конструктор (рекомендуемый подход)

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

@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
    
    public void registerUser(String email) {
        userRepository.save(email);
        emailService.sendWelcomeEmail(email);
    }
}

3. Внедрение через поле с @Autowired

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

@Service
public class PaymentService {
    @Autowired
    private TransactionRepository transactionRepository;
    
    @Autowired
    private NotificationService notificationService;
    
    public void processPayment(double amount) {
        transactionRepository.save(amount);
        notificationService.notify("Payment processed: " + amount);
    }
}

4. Внедрение через Setter

@Service
public class ReportService {
    private DataSource dataSource;
    
    @Autowired
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

Жизненный цикл Bean в Spring

Весь процесс управления Bean'ами в Spring контейнере:

1. Instantiation — создание экземпляра класса
2. Dependency Injection — внедрение зависимостей
3. Initialization — вызов методов инициализации
4. Ready for Use — Bean готов к использованию
5. Destruction — вызов методов очистки при завершении приложения

Qualifier для разрешения неоднозначности

Если существует несколько Bean одного типа, используй @Qualifier для указания конкретного Bean'а:

interface PaymentProcessor {
    void process(double amount);
}

@Component("creditCard")
public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void process(double amount) {
        System.out.println("Processing: " + amount);
    }
}

@Service
public class OrderService {
    private final PaymentProcessor paymentProcessor;
    
    public OrderService(@Qualifier("creditCard") PaymentProcessor processor) {
        this.paymentProcessor = processor;
    }
}

Scope Bean'ов

Spring поддерживает различные области видимости Bean'ов:

• Singleton (по умолчанию) — один экземпляр на всё приложение
• Prototype — новый экземпляр для каждого запроса
• Request — один экземпляр на HTTP запрос
• Session — один экземпляр на HTTP сессию

@Component
@Scope("prototype")
public class RequestLogger {
    // Новый экземпляр для каждого использования
}

Dependency Injection в Spring Boot значительно упрощает разработку, тестирование и поддержку приложений, позволяя разработчикам сосредоточиться на бизнес-логике вместо управления зависимостями.