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

Инверсия контроля (IoC) и Spring Framework

Инверсия контроля - это принцип проектирования, который переворачивает традиционный ход управления выполнением программы. В контексте Spring, IoC является фундаментальной концепцией, которая делает фреймворк мощным инструментом для создания масштабируемых приложений.

Основная идея IoC

// ОБЫЧНЫЙ подход (без IoC) - вы управляете созданием объектов
public class UserService {
    private UserRepository repository;
    
    public UserService() {
        // Сервис сам создает зависимость
        this.repository = new UserRepository(); // Жесткая привязка!
    }
    
    public User getUserById(Long id) {
        return repository.findById(id);
    }
}

// IoC подход (Spring управляет) - контроль передан Spring
@Service
public class UserService {
    private final UserRepository repository;
    
    // Spring инъектирует зависимость автоматически
    @Autowired
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
    
    public User getUserById(Long id) {
        return repository.findById(id);
    }
}

Spring IoC Container

Spring использует IoC контейнер для управления жизненным циклом объектов (beans):

// 1. Конфигурация через аннотации (рекомендуется)
@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
    
    @Bean
    public UserService userService(UserRepository userRepository) {
        return new UserService(userRepository);
    }
}

// 2. Конфигурация через XML
<beans>
    <bean id="userRepository" class="com.example.UserRepository"/>
    <bean id="userService" class="com.example.UserService">
        <constructor-arg ref="userRepository"/>
    </bean>
</beans>

// 3. Автоматическое сканирование (component scanning)
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Component
public class UserRepository { }

@Service
public class UserService {
    @Autowired
    private UserRepository repository;
}

Три основных типа инъекции зависимостей

// 1. Constructor Injection (рекомендуется)
@Service
public class OrderService {
    private final UserRepository userRepository;
    private final PaymentService paymentService;
    
    public OrderService(UserRepository userRepository, 
                       PaymentService paymentService) {
        this.userRepository = userRepository;
        this.paymentService = paymentService;
    }
}

// 2. Setter Injection
@Service
public class NotificationService {
    private EmailService emailService;
    
    @Autowired(required = false)
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
}

// 3. Field Injection
@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;
}

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

@Component
public class BeanLifecycle implements InitializingBean, DisposableBean {
    public BeanLifecycle() {
        System.out.println("1. Constructor");
    }
    
    @PostConstruct
    public void init() {
        System.out.println("3. PostConstruct");
    }
    
    @PreDestroy
    public void cleanup() {
        System.out.println("5. PreDestroy");
    }
}

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

1. Слабая связанность - компоненты не зависят друг от друга напрямую
2. Тестируемость - легко подменять реальные объекты на mock'и
3. Переиспользуемость - один сервис может работать с разными реализациями
4. Управление жизненным циклом - Spring автоматически создает и уничтожает объекты
5. Централизованная конфигурация - все зависимости в одном месте

Spring IoC контейнер - это сердце фреймворка, позволяющее разработчикам сосредоточиться на бизнес-логике вместо управления объектами.