Что такое IoC контейнер в Spring?

IoC контейнер в Spring

IoC (Inversion of Control) контейнер — это сердце Spring Framework. Это один из самых важных концептов в Spring, который кардинально меняет архитектуру Java приложений.

Что такое IoC контейнер

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

// ❌ БЕЗ IoC контейнера (старый подход)
public class UserService {
    private UserRepository repository;
    private EmailService emailService;
    
    public UserService() {
        // Создаём объекты вручную
        this.repository = new UserRepository(); //硬 зависимость!
        this.emailService = new EmailService();
    }
}

// ✅ С IoC контейнером (Spring подход)
@Service
public class UserService {
    private final UserRepository repository;
    private final EmailService emailService;
    
    // Spring автоматически инъектирует зависимости
    public UserService(UserRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
    }
}

Основные интерфейсы

ApplicationContext — главный интерфейс IoC контейнера

// Запуск приложения
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // Spring создаёт ApplicationContext и инициализирует контейнер
        ApplicationContext context = SpringApplication.run(Application.class, args);
        
        // Получение бина из контейнера
        UserService userService = context.getBean(UserService.class);
        
        // Все зависимости уже инъектированы!
        userService.createUser(new User("John"));
    }
}

BeanFactory — базовый интерфейс для работы с бинами

// ApplicationContext наследует BeanFactory и более функционален
public interface BeanFactory {
    Object getBean(String name);
    <T> T getBean(Class<T> requiredType);
    <T> T getBean(String name, Class<T> requiredType);
    // ...
}

Как работает IoC контейнер

1. Сканирование (Component Scanning)
   ↓
2. Создание инстанций (Instantiation)
   ↓
3. Инъекция зависимостей (Dependency Injection)
   ↓
4. Инициализация (@PostConstruct)
   ↓
5. Ready to use

Шаг 1: Сканирование

@Configuration
@ComponentScan(basePackages = "com.example.service") // Указываем, где искать компоненты
public class AppConfig {
}

// Spring находит все классы с аннотациями:
// @Component, @Service, @Repository, @Controller

Шаг 2-3: Создание и инъекция

@Service // Spring находит этот класс
public class UserService {
    private final UserRepository repository;
    private final NotificationService notificationService;
    
    @Autowired // Spring инъектирует зависимости
    public UserService(UserRepository repository, 
                       NotificationService notificationService) {
        this.repository = repository;
        this.notificationService = notificationService;
    }
}

@Repository // Spring создаёт singleton инстанцию
public class UserRepository {
    // ...
}

@Service // Spring создаёт singleton инстанцию
public class NotificationService {
    // ...
}

Шаг 4: Инициализация

@Service
public class DatabaseService {
    private Connection connection;
    
    @PostConstruct // Вызывается после создания бина
    public void init() {
        this.connection = DriverManager.getConnection("jdbc:...");
        System.out.println("DatabaseService initialized");
    }
    
    @PreDestroy // Вызывается при shutdown контейнера
    public void cleanup() {
        connection.close();
    }
}

Регистрация бинов: разные способы

1. Через @Component аннотацию

@Component // Регистрируется автоматически
public class MyComponent {
}

@Service // Specialization of @Component для сервисов
public class MyService {
}

@Repository // Specialization of @Component для репозиториев
public class MyRepository {
}

@Controller // Specialization of @Component для контроллеров
public class MyController {
}

2. Через @Bean в @Configuration

@Configuration
public class AppConfig {
    @Bean // Явно регистрируем бин
    public DatabaseConnection databaseConnection() {
        return new DatabaseConnection("jdbc:...");
    }
    
    @Bean
    public UserRepository userRepository(DatabaseConnection connection) {
        // Spring передаёт другой бин как аргумент
        return new UserRepository(connection);
    }
    
    @Bean
    public UserService userService(UserRepository repository) {
        return new UserService(repository);
    }
}

3. Программная регистрация

public class ManualRegistration {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext();
        
        // Регистрируем бин программно
        ((AnnotationConfigApplicationContext) context)
            .register(UserService.class);
        ((AnnotationConfigApplicationContext) context).refresh();
        
        UserService service = context.getBean(UserService.class);
    }
}

Инъекция зависимостей: способы

1. Constructor Injection (рекомендуемый)

@Service
public class UserService {
    private final UserRepository repository; // final — immutable
    private final EmailService emailService;
    
    @Autowired // Или просто конструктор (в Spring 4.3+)
    public UserService(UserRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
    }
}

// Плюсы:
// ✅ Immutability (final поля)
// ✅ Все зависимости видны в конструкторе
// ✅ Легко тестировать (new UserService(mock, mock))
// ✅ Невозможно создать неполный объект

2. Setter Injection

@Service
public class UserService {
    private UserRepository repository;
    
    @Autowired // Optional зависимость
    public void setRepository(UserRepository repository) {
        this.repository = repository;
    }
}

// Минусы:
// ❌ Можно забыть инъектировать
// ❌ Не immutable
// ❌ Сложнее в тестировании

3. Field Injection

@Service
public class UserService {
    @Autowired // Прямая инъекция в поле
    private UserRepository repository;
}

// Минусы:
// ❌ НЕ рекомендуется!
// ❌ Сложно видеть зависимости
// ❌ Нельзя инъектировать в unit тестах
// ❌ Не immutable

Жизненный цикл бина

public class BeanLifecycle {
    // 1. Instantiation (создание через конструктор)
    public BeanLifecycle() {
        System.out.println("1. Constructor called");
    }
    
    // 2. Setter injection
    @Autowired
    public void setDependency(Dependency dep) {
        System.out.println("2. Setter called");
    }
    
    // 3. BeanNameAware, BeanClassLoaderAware, BeanFactoryAware
    // (примечание: обычно не используется)
    
    // 4. PostConstruct (инициализация)
    @PostConstruct
    public void init() {
        System.out.println("3. @PostConstruct called");
    }
    
    // 5. ready to use
    public void doSomething() {
        System.out.println("Bean is ready!");
    }
    
    // 6. PreDestroy (очистка)
    @PreDestroy
    public void destroy() {
        System.out.println("4. @PreDestroy called");
    }
}

// Логи:
// 1. Constructor called
// 2. Setter called
// 3. @PostConstruct called
// (Использование)
// 4. @PreDestroy called (при shutdown)

Практический пример

// 1. Определяем сервис
@Service
public class UserService {
    private final UserRepository repository;
    private final EmailService emailService;
    private final Logger logger;
    
    @Autowired
    public UserService(UserRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
        this.logger = LoggerFactory.getLogger(UserService.class);
    }
    
    public void createUser(CreateUserRequest request) {
        User user = new User(request.getName(), request.getEmail());
        repository.save(user);
        emailService.sendWelcomeEmail(user.getEmail());
        logger.info("User created: {}", user.getId());
    }
}

// 2. Spring автоматически инъектирует
@RestController
@RequestMapping("/api/users")
public class UserController {
    private final UserService userService; // Spring знает, что это нужно инъектировать
    
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @PostMapping
    public ResponseEntity<User> create(@RequestBody CreateUserRequest request) {
        userService.createUser(request);
        return ResponseEntity.ok().build();
    }
}

// 3. Spring управляет всем
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Application.class, args);
        // IoC контейнер создал все зависимости и связал их автоматически
    }
}

Преимущества IoC контейнера

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

// Без IoC: класс зависит от конкретной реализации
public class UserService {
    private PostgresUserRepository repository = new PostgresUserRepository();
}

// С IoC: класс зависит от интерфейса
public class UserService {
    private UserRepository repository; // Может быть любая реализация
}

2. Легко тестировать

// Unit тест с mock'ом
@Test
public void testCreateUser() {
    UserRepository mockRepo = mock(UserRepository.class);
    UserService service = new UserService(mockRepo); // Легко инъектировать тестовую реализацию
    
    service.createUser(new User("John"));
    
    verify(mockRepo).save(any(User.class));
}

3. Конфигурация в одном месте

@Configuration
public class AppConfig {
    @Bean
    public DataSource dataSource() {
        return new DataSource("jdbc:...");
    }
    // Все зависимости конфигурируются централизованно
}

4. Управление жизненным циклом Spring автоматически управляет созданием и уничтожением объектов.

Заключение

IoC контейнер — это фундамент Spring Framework. Он позволяет:

• Автоматически управлять зависимостями
• Делать код более гибким и тестируемым
• Снизить сложность архитектуры
• Следовать SOLID принципам (особенно Dependency Inversion)

Это не просто фича — это парадигма разработки на Spring.