Для чего нужен IoC?

IoC (Inversion of Control) в Java и Spring

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

Проблема без IoC

Без IoC приложение выглядит так:

public class UserService {
    private UserRepository repository;
    private EmailService emailService;
    
    public UserService() {
        // Сервис сам создаёт свои зависимости
        this.repository = new UserRepository();
        this.emailService = new EmailService();
    }
    
    public void registerUser(String email) {
        User user = new User(email);
        repository.save(user);
        emailService.sendWelcomeEmail(email);
    }
}

Проблемы:

• UserService жёстко привязан к конкретным реализациям UserRepository и EmailService
• Если нужно поменять реализацию, придётся менять код UserService
• Сложно тестировать (нельзя использовать mock объекты)
• Нарушается принцип Dependency Inversion (SOLID)

Решение с IoC

С IoC контейнер берёт на себя создание и управление объектами:

@Service
public class UserService {
    private final UserRepository repository;
    private final EmailService emailService;
    
    // Зависимости внедряются контейнером
    @Autowired
    public UserService(UserRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
    }
    
    public void registerUser(String email) {
        User user = new User(email);
        repository.save(user);
        emailService.sendWelcomeEmail(email);
    }
}

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

1. Слабая связанность (Loose Coupling)

Код зависит от интерфейсов, а не от конкретных реализаций:

public interface UserRepository {
    void save(User user);
}

public class JpaUserRepository implements UserRepository {
    @Override
    public void save(User user) { /* реализация */ }
}

public class MockUserRepository implements UserRepository {
    @Override
    public void save(User user) { /* mock для тестов */ }
}

Мы можем поменять реализацию без изменения UserService.

2. Тестируемость

@Test
public void testRegisterUser() {
    // Используем mock объекты в тестах
    UserRepository mockRepo = mock(UserRepository.class);
    EmailService mockEmail = mock(EmailService.class);
    
    UserService service = new UserService(mockRepo, mockEmail);
    service.registerUser("test@example.com");
    
    verify(mockRepo).save(any(User.class));
    verify(mockEmail).sendWelcomeEmail("test@example.com");
}

3. Гибкость и переиспользуемость

Вы можете создавать разные конфигурации для разных сценариев:

@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new JpaUserRepository();
    }
    
    @Bean
    public EmailService emailService() {
        return new SmtpEmailService();
    }
    
    @Bean
    public UserService userService(UserRepository repo, EmailService email) {
        return new UserService(repo, email);
    }
}

4. Управление жизненным циклом

Spring контейнер управляет инициализацией и уничтожением объектов:

@Component
public class DatabaseConnection {
    @PostConstruct
    public void init() {
        System.out.println("Подключение к БД");
    }
    
    @PreDestroy
    public void destroy() {
        System.out.println("Закрытие подключения");
    }
}

IoC в Spring

Spring имеет встроенный IoC контейнер (ApplicationContext), который:

• Сканирует классы с аннотациями (@Component, @Service, @Repository)
• Создаёт объекты и инъектит зависимости
• Управляет жизненным циклом объектов
• Обеспечивает синглтон-паттерн по умолчанию

Внедрение зависимостей в Spring

Конструктор (рекомендуется)

@Service
public class UserService {
    private final UserRepository repository;
    
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

Через @Autowired (удалённый подход)

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

Setter инъекция

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

IoC — это основной принцип, на котором построены все современные фреймворки. Он обеспечивает чистоту архитектуры, тестируемость и гибкость приложения.