Что такое принцип инверсии управления?

Принцип инверсии управления (IoC — Inversion of Control)

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

Суть принципа

В традиционном коде ваш код управляет фреймворком:

// ❌ Без IoC — управление в вашем коде
public class OrderService {
    public void processOrder(Order order) {
        // ВЫ создаёте зависимости
        Database db = new Database("localhost");
        EmailService email = new EmailService("smtp.gmail.com");
        
        // ВЫ управляете логикой
        db.save(order);
        email.sendConfirmation(order);
    }
}

С IoC фреймворк управляет вашим кодом:

// ✅ С IoC — управление в фреймворке (Spring)
@Service
public class OrderService {
    private final Database db;          // Зависимости внедряются
    private final EmailService email;
    
    // Конструктор инъекции — IoC контейнер создаёт экземпляры
    public OrderService(Database db, EmailService email) {
        this.db = db;
        this.email = email;
    }
    
    public void processOrder(Order order) {
        // ВЫ просто используете зависимости
        db.save(order);
        email.sendConfirmation(order);
    }
}

Как это работает в Spring

IoC контейнер Spring автоматически:

1. Создаёт экземпляры объектов (beans)
2. Внедряет зависимости
3. Управляет жизненным циклом объектов
4. Вызывает ваш код в нужное время

Регистрация beans

// Способ 1: @Component (автоматическое сканирование)
@Component
public class Database {
    public Database() {
        System.out.println("Database bean создан");
    }
}

// Способ 2: @Bean в конфигурации
@Configuration
public class AppConfig {
    @Bean
    public Database database() {
        return new Database();
    }
}

// Способ 3: XML конфигурация
<!-- <bean id="database" class="com.example.Database" /> -->

Внедрение зависимостей (DI)

Конструктор инъекция (рекомендуется):

@Service
public class OrderService {
    private final Database db;
    private final EmailService email;
    
    // Конструктор с параметрами — Spring внедрит зависимости
    public OrderService(Database db, EmailService email) {
        this.db = db;
        this.email = email;
    }
}

Setter инъекция:

@Service
public class OrderService {
    private Database db;
    private EmailService email;
    
    @Autowired
    public void setDatabase(Database db) {
        this.db = db;
    }
    
    @Autowired
    public void setEmailService(EmailService email) {
        this.email = email;
    }
}

Field инъекция (не рекомендуется):

@Service
public class OrderService {
    @Autowired
    private Database db;
    
    @Autowired
    private EmailService email;
}

Жизненный цикл bean'а

@Component
public class UserService implements InitializingBean, DisposableBean {
    
    // 1. Создание экземпляра
    public UserService() {
        System.out.println("1. Constructor");
    }
    
    // 2. Установка свойств
    @Autowired
    public void setDatabase(Database db) {
        System.out.println("2. Setter injection");
    }
    
    // 3. Инициализация
    @PostConstruct
    public void init() {
        System.out.println("3. @PostConstruct");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("3. afterPropertiesSet");
    }
    
    // Использование
    public User getUserById(String id) {
        System.out.println("4. Business method");
        return new User(id);
    }
    
    // 5. Уничтожение
    @PreDestroy
    public void cleanup() {
        System.out.println("5. @PreDestroy");
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("5. destroy");
    }
}

IoC vs DI (Dependency Injection)

IoC — общий принцип (фреймворк управляет потоком).

DI — способ реализации IoC (внедрение зависимостей).

// IoC в действии
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // Spring запускает приложение и управляет потоком
        ApplicationContext context = SpringApplication.run(Application.class, args);
        
        // Spring вызывает ваш код
        OrderService orderService = context.getBean(OrderService.class);
        orderService.processOrder(new Order());  // Ваш код вызывается фреймворком
    }
}

Примеры использования IoC

Пример 1: Сложные инициализации

// Без IoC — ручное управление
public class DataSourceManager {
    public DataSource createDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost/mydb");
        config.setUsername("user");
        config.setPassword("pass");
        config.setMaximumPoolSize(20);
        return new HikariDataSource(config);
    }
}

// С IoC — фреймворк управляет
@Configuration
public class DataSourceConfig {
    @Bean
    public DataSource dataSource(
        @Value("${db.url}") String url,
        @Value("${db.user}") String user,
        @Value("${db.password}") String password) {
        
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(url);
        config.setUsername(user);
        config.setPassword(password);
        config.setMaximumPoolSize(20);
        return new HikariDataSource(config);
    }
}

Пример 2: Тестирование

// Без IoC — сложно подменить зависимость
public class OrderService {
    public boolean processOrder(Order order) {
        Database db = new RealDatabase();  // Жёстко связано
        db.save(order);
        return true;
    }
}

// С IoC — легко подменить
@Service
public class OrderService {
    private final Database db;
    
    public OrderService(Database db) {
        this.db = db;
    }
    
    public boolean processOrder(Order order) {
        db.save(order);
        return true;
    }
}

// Тест с подменой
@Test
public void testOrderProcessing() {
    Database mockDb = mock(Database.class);
    OrderService service = new OrderService(mockDb);  // Внедрим mock
    
    service.processOrder(new Order());
    
    verify(mockDb).save(any(Order.class));
}

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

✅ Слабая связанность — компоненты не зависят друг от друга

✅ Легче тестировать — можно подменять зависимости

✅ Конфигурируемость — меняется поведение без изменения кода

✅ Переиспользуемость — компоненты работают в разных контекстах

✅ Управление жизненным циклом — фреймворк закрывает ресурсы

Недостатки IoC

❌ Магия — сложно отследить что происходит

❌ Производительность — reflection замедляет запуск

❌ Кривая обучения — нужно понимать как работает контейнер

Типы IoC контейнеров

Spring IoC — самый популярный для Java:

// ApplicationContext — основной IoC контейнер
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
OrderService service = context.getBean(OrderService.class);

Guice — более лёгкий альтернатива:

Injector injector = Guice.createInjector(new AppModule());
OrderService service = injector.getInstance(OrderService.class);

Dagger — для мобильных приложений (Android).

Inversion of Control — это фундаментальный принцип modern Java приложений, который делает код более гибким, тестируемым и поддерживаемым.