Как Application Context связан с Inversion of Control

Ответ

Application Context и Inversion of Control (IoC)

ApplicationContext в Spring — это конкретная реализация IoC контейнера, который управляет жизненным циклом объектов и их зависимостями. Это один из фундаментальных концептов Spring Framework.

Что такое Inversion of Control (IoC)

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

// БЕЗ IoC (традиционный подход — ваш код управляет зависимостями)
public class UserService {
    private UserRepository userRepository;
    private EmailService emailService;
    
    public UserService() {
        // Сервис создаёт свои зависимости сам
        this.userRepository = new UserRepositoryImpl();  // Жёсткая связанность
        this.emailService = new EmailServiceImpl();
    }
    
    public void registerUser(String name, String email) {
        User user = new User(name, email);
        userRepository.save(user);
        emailService.sendWelcomeEmail(email);
    }
}

// ПРОБЛЕМЫ:
// 1. Трудно тестировать (нельзя использовать mock'и)
// 2. Жёсткие зависимости
// 3. Трудно заменить реализацию

// С IoC (Spring управляет зависимостями)
public class UserService {
    private UserRepository userRepository;
    private EmailService emailService;
    
    // Spring внедрит зависимости через конструктор
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
    
    public void registerUser(String name, String email) {
        User user = new User(name, email);
        userRepository.save(user);
        emailService.sendWelcomeEmail(email);
    }
}

// ПРЕИМУЩЕСТВА:
// 1. Легко тестировать (можно передать mock'и)
// 2. Слабая связанность
// 3. Легко заменить реализацию

Что такое Application Context

Application Context — это контейнер Spring, который:

1. Создаёт бины (bean = управляемый объект)
2. Управляет жизненным циклом (создание, инициализация, уничтожение)
3. Внедряет зависимости (dependency injection)
4. Предоставляет доступ к бинам (через название или тип)

public interface ApplicationContext extends BeanFactory {
    // Получить бин по имени
    Object getBean(String name);
    
    // Получить бин по типу
    <T> T getBean(Class<T> requiredType);
    
    // Получить все бины определённого типа
    <T> Map<String, T> getBeansOfType(Class<T> type);
    
    // Получить конфигурацию приложения
    String getApplicationName();
    
    // Получить окружение (переменные, профили)
    Environment getEnvironment();
}

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

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

// Spring сканирует пакеты и находит классы с аннотациями
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

// OR в application.properties
// spring.application.name=myapp

Шаг 2: Регистрация бинов

Spring находит классы с аннотациями и регистрирует их как бины:

@Service
public class UserService {
    // Spring автоматически создаст бин для этого класса
}

@Repository
public class UserRepositoryImpl implements UserRepository {
    // Также станет бином
}

@Component
public class EmailServiceImpl implements EmailService {
    // И это тоже бин
}

Шаг 3: Внедрение зависимостей

Spring анализирует конструкторы, setter'ы и поля с @Autowired:

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

Шаг 4: Использование ApplicationContext

@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.registerUser("John", "john@example.com");
    }
}

Полный цикл жизни бина в ApplicationContext

public class BeanLifecycleExample implements InitializingBean, DisposableBean {
    
    public BeanLifecycleExample() {
        System.out.println("1. Конструктор вызван");
    }
    
    @PostConstruct
    public void init() {
        System.out.println("2. @PostConstruct (инициализация)");
        // Здесь инициализируйте ресурсы: подключение к БД, загрузка конфига
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("3. InitializingBean.afterPropertiesSet()");
    }
    
    public void doSomething() {
        System.out.println("4. Бин используется в приложении");
    }
    
    @PreDestroy
    public void cleanup() {
        System.out.println("5. @PreDestroy (очистка)");
        // Закрывайте ресурсы: соединения, файлы
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("6. DisposableBean.destroy()");
    }
}

// Порядок вывода:
// 1. Конструктор вызван
// 2. @PostConstruct
// 3. InitializingBean.afterPropertiesSet()
// 4. Бин используется
// 5. @PreDestroy
// 6. DisposableBean.destroy()

Типы ApplicationContext

// 1. ClassPathXmlApplicationContext (старый способ)
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

// 2. AnnotationConfigApplicationContext (аннотации)
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// 3. WebApplicationContext (для веб-приложений)
// Используется автоматически в Spring Boot

// 4. In Spring Boot (рекомендуется)
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Практический пример: конфигурация бинов

@Configuration
public class AppConfig {
    
    // Способ 1: @Bean метод
    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
    
    @Bean
    public EmailService emailService() {
        return new EmailServiceImpl();
    }
    
    // Spring автоматически внедрит зависимости в параметры
    @Bean
    public UserService userService(UserRepository userRepository, EmailService emailService) {
        return new UserService(userRepository, emailService);
    }
}

// Способ 2: Аннотации
@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    // Spring найдёт зависимости автоматически
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
}

Разница между BeanFactory и ApplicationContext

BeanFactory (старый интерфейс):
- Базовый интерфейс для управления бинами
- Ленивая инициализация
- Минимальный функционал

ApplicationContext (более мощный):
- Расширяет BeanFactory
- Активная инициализация
- Поддержка AOP, event publishing, i18n
- Используется везде в Spring Boot

Вывод

ApplicationContext — это материализация IoC контейнера в Spring. Это фундамент, на котором построена вся Spring экосистема. Понимание того, как ApplicationContext создаёт бины, внедряет зависимости и управляет жизненным циклом, критично для написания качественного Spring кода.