Что реализует Spring из инверсии контроля

Что реализует Spring из инверсии контроля (IoC)

Инверсия контроля (Inversion of Control, IoC) — это принцип проектирования, где управление потоком выполнения и зависимостями передаётся фреймворку. Spring реализует этот принцип через контейнер IoC и dependency injection.

Суть инверсии контроля

Без IoC (обычный код):

public class OrderService {
    private OrderRepository repository;
    private EmailService emailService;
    private LogService logService;
    
    public OrderService() {
        // МЫ создаём все зависимости сами
        this.repository = new OrderRepository();
        this.emailService = new EmailService();
        this.logService = new LogService();
    }
    
    public void createOrder(Order order) {
        repository.save(order);
        emailService.sendConfirmation(order);
        logService.log("Order created");
    }
}

Проблемы:

• Класс тесно связан с реализациями
• Сложно тестировать (нельзя подменить зависимости)
• Если OrderRepository изменится, нужно изменить OrderService
• Много boilerplate кода

С IoC/Spring (инверсия):

@Service
public class OrderService {
    private final OrderRepository repository;
    private final EmailService emailService;
    private final LogService logService;
    
    // Spring создаёт зависимости и инъектирует их
    public OrderService(OrderRepository repository, 
                       EmailService emailService,
                       LogService logService) {
        this.repository = repository;
        this.emailService = emailService;
        this.logService = logService;
    }
    
    public void createOrder(Order order) {
        repository.save(order);
        emailService.sendConfirmation(order);
        logService.log("Order created");
    }
}

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

• Spring управляет жизненным циклом объектов
• Слабая связанность (loose coupling)
• Легко тестировать (подменяем mock объекты)
• Конфигурация отделена от логики

Как Spring реализует IoC

1. Application Context (контейнер)

Spring контейнер — это главный объект, управляющий всеми beans:

// Создание контекста
ApplicationContext context = new AnnotationConfigApplicationContext(
    AppConfig.class
);

// Получение bean-а из контейнера
OrderService orderService = context.getBean(OrderService.class);

Визуально:

Spring Container:
├── OrderService
├── OrderRepository
├── EmailService
└── LogService
    ↓
Все зависимости уже созданы и связаны

2. Bean Definition (описание компонента)

Spring должен знать, какие компоненты создавать. Это можно определить несколькими способами:

Способ 1: Аннотация @Bean в @Configuration

@Configuration
public class AppConfig {
    
    @Bean
    public OrderRepository orderRepository() {
        return new OrderRepository();
    }
    
    @Bean
    public EmailService emailService() {
        return new EmailService();
    }
    
    @Bean
    public OrderService orderService(OrderRepository repo, 
                                     EmailService email) {
        // Spring автоматически инъектирует зависимости
        return new OrderService(repo, email);
    }
}

Способ 2: Аннотация @Component/@Service/@Repository

@Component
public class OrderRepository { }

@Component
public class EmailService { }

@Service
public class OrderService {
    private final OrderRepository repository;
    private final EmailService emailService;
    
    // Spring ищет конструктор с аннотацией или единственный public конструктор
    @Autowired // (опционально в Spring 4.3+)
    public OrderService(OrderRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
    }
}

Spring сканирует пакеты (component-scan) и автоматически регистрирует все @Component.

3. Dependency Injection (инъекция зависимостей)

Это основной механизм IoC. Spring "вливает" зависимости несколькими способами:

Способ 1: Constructor Injection (рекомендуется)

@Service
public class OrderService {
    private final OrderRepository repository;
    
    // Spring вызовет этот конструктор
    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }
}

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

• Явная зависимость
• Легко тестировать
• Можно использовать final поля
• Гарантирует, что объект создан корректно

Способ 2: Setter Injection

@Service
public class OrderService {
    private OrderRepository repository;
    
    @Autowired
    public void setRepository(OrderRepository repository) {
        this.repository = repository;
    }
}

Способ 3: Field Injection (не рекомендуется)

@Service
public class OrderService {
    @Autowired
    private OrderRepository repository; // Плохо! Сложно тестировать
}

4. Bean Lifecycle (жизненный цикл)

Spring управляет не только созданием, но и всем жизненным циклом bean-a:

1. Instantiation      (создание объекта)
2. Dependency Inject  (инъекция зависимостей)
3. BeanNameAware      (@Aware интерфейсы)
4. BeanFactoryAware
5. @PostConstruct     (инициализация)
6. Bean Ready         (готов к использованию)
7. @PreDestroy        (перед удалением)
8. Destruction        (удаление)

Пример:

@Service
public class OrderService implements InitializingBean, DisposableBean {
    
    @PostConstruct
    public void init() {
        System.out.println("OrderService инициализирован");
        // Можно загрузить конфиг, подключиться к БД и т.д.
    }
    
    @PreDestroy
    public void cleanup() {
        System.out.println("OrderService удаляется");
        // Закрываем ресурсы, соединения и т.д.
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // То же самое что @PostConstruct
    }
    
    @Override
    public void destroy() throws Exception {
        // То же самое что @PreDestroy
    }
}

Пример: Полная работа IoC

// 1. Определяем интерфейс для слабой связанности
public interface PaymentProcessor {
    void process(Payment payment);
}

// 2. Реализация
@Component
public class StripePaymentProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) {
        System.out.println("Обработка через Stripe");
    }
}

// 3. Сервис использует интерфейс, не реализацию
@Service
public class OrderService {
    private final PaymentProcessor processor;
    
    public OrderService(PaymentProcessor processor) {
        this.processor = processor;
    }
    
    public void placeOrder(Order order) {
        Payment payment = order.getPayment();
        processor.process(payment); // Зовём интерфейс
    }
}

// 4. Если нужно поменять реализацию, просто меняем компонент:
@Component
public class PayPalPaymentProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) {
        System.out.println("Обработка через PayPal");
    }
}
// Spring автоматически использует новую реализацию!

Способ разрешения конфликтов (@Qualifier)

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

@Service
public class OrderService {
    private final PaymentProcessor processor;
    
    // Указываем, какую реализацию использовать
    public OrderService(@Qualifier("stripePaymentProcessor") 
                       PaymentProcessor processor) {
        this.processor = processor;
    }
}

Ор с @Primary:

@Component
@Primary // Используется по умолчанию
public class StripePaymentProcessor implements PaymentProcessor { }

Преимущества IoC в Spring

Типичные pattern-ы

1. Service Locator (старый подход, не рекомендуется)

// Плохо: явно ищем bean в контейнере
OrderRepository repo = context.getBean(OrderRepository.class);

2. Dependency Injection (правильно)

// Хорошо: Spring сам инъектирует
public OrderService(OrderRepository repo) { }