Как называется часть, содержащая бины в Spring Boot

# Application Context — контейнер бинов в Spring Boot

Основной ответ

Часть Spring Framework, которая содержит бины, называется Application Context (контекст приложения) или IoC Container (контейнер инверсии управления).

Что такое Application Context

Application Context — это центральный объект в Spring, который:

• Управляет бинами — создает, инициализирует, уничтожает объекты
• Разрешает зависимости — внедряет нужные объекты в нужные места (Dependency Injection)
• Управляет жизненным циклом — инициализация, работа, очистка
• Кеширует объекты — хранит созданные бины для переиспользования
• Предоставляет доступ к ресурсам — файлы, конфигурация, переменные окружения

Иерархия классов

BeanFactory
    ↓
ApplicationContext (extends BeanFactory)
    ↓
AbstractApplicationContext
    ↓
ClassPathXmlApplicationContext / AnnotationConfigApplicationContext / ...

В Spring Boot используется AnnotationConfigApplicationContext или SpringBootApplication.

Основные типы Application Context

1. AnnotationConfigApplicationContext

Успользуется при Java конфигурации (без XML):

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        // Создаем контекст приложения
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        
        // Получаем бин из контекста
        UserService userService = context.getBean(UserService.class);
        userService.doSomething();
        
        // Закрываем контекст (очистка ресурсов)
        ((AnnotationConfigApplicationContext) context).close();
    }
}

2. ClassPathXmlApplicationContext

Для XML конфигурации:

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        UserService userService = context.getBean(UserService.class);
        userService.doSomething();
        
        ((ClassPathXmlApplicationContext) context).close();
    }
}

3. Spring Boot — Встроенный контекст

В Spring Boot контекст создается автоматически:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication // Это аннотация, которая создает Application Context
public class MyApplication {
    public static void main(String[] args) {
        // SpringApplication создает ApplicationContext внутри себя
        SpringApplication.run(MyApplication.class, args);
        // Контекст уже создан и работает
    }
}

@Service
public class UserService {
    // Бины автоматически внедряются контекстом
}

Получение доступа к контексту

В Spring Boot через Autowired

@Component
public class MyComponent {
    @Autowired
    private ApplicationContext applicationContext;
    
    public void doSomething() {
        // Получить бин из контекста
        UserService userService = applicationContext.getBean(UserService.class);
        
        // Получить бин по имени
        UserService service = (UserService) applicationContext.getBean("userService");
        
        // Проверить наличие бина
        if (applicationContext.containsBean("userService")) {
            System.out.println("Бин найден");
        }
        
        // Получить все бины определенного типа
        Map<String, UserService> allServices = applicationContext.getBeansOfType(UserService.class);
    }
}

Через ApplicationContextAware

import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationContext;

@Component
public class MyComponent implements ApplicationContextAware {
    private ApplicationContext applicationContext;
    
    @Override
    public void setApplicationContext(ApplicationContext context) {
        this.applicationContext = context;
    }
    
    public void useContext() {
        UserService service = applicationContext.getBean(UserService.class);
    }
}

BeanFactory vs ApplicationContext

Вывод: ApplicationContext — более функциональна и используется в реальных приложениях.

Жизненный цикл Application Context

1. Создание контекста (new AnnotationConfigApplicationContext())
   ↓
2. Сканирование компонентов (@Component, @Service, @Repository, @Controller)
   ↓
3. Регистрация бинов (Bean Definition Registry)
   ↓
4. Инстанцирование бинов (создание объектов)
   ↓
5. Внедрение зависимостей (@Autowired)
   ↓
6. Вызов методов инициализации (@PostConstruct, initMethod)
   ↓
7. Контекст готов к работе
   ↓
8. Работа приложения
   ↓
9. Завершение приложения
   ↓
10. Вызов методов очистки (@PreDestroy, destroyMethod)
    ↓
11. Закрытие контекста (context.close())

Практический пример: Spring Boot с контекстом

// Конфигурация
@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
    
    @Bean
    public UserService userService(UserRepository repo) {
        return new UserService(repo);
    }
}

// Основной класс
@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        // Spring автоматически создает контекст
        ApplicationContext context = SpringApplication.run(MyApp.class, args);
        
        // Контекст содержит все бины
        UserService service = context.getBean(UserService.class);
        service.doSomething();
    }
}

// Компоненты
@Service
public class UserService {
    @Autowired
    private UserRepository repository;
    
    public void doSomething() {
        // Используем бины
    }
}

@Repository
public class UserRepository {
    // Доступ к БД
}

Методы ApplicationContext

ApplicationContext context = ...;

// Получение бинов
UserService service = context.getBean(UserService.class);
UserService service = (UserService) context.getBean("userService");
UserService service = context.getBean("userService", UserService.class);

// Проверка наличия бинов
boolean hasBean = context.containsBean("userService");
boolean isSingleton = context.isSingleton("userService");

// Получение информации
String[] beanNames = context.getBeanDefinitionNames();
Map<String, UserService> allServices = context.getBeansOfType(UserService.class);
int beanCount = context.getBeanDefinitionCount();

// Получение ресурсов
Resource resource = context.getResource("classpath:config.properties");

// Публикация событий
context.publishEvent(new MyEvent("message"));

// Закрытие контекста
if (context instanceof Closeable) {
    ((Closeable) context).close();
}

Связанные термины

• BeanFactory — базовый интерфейс для работы с бинами
• Bean Definition — описание бина (класс, зависимости, область видимости)
• Dependency Injection — процесс внедрения зависимостей контекстом
• IoC Container — синоним для Application Context
• Singleton — по умолчанию бины создаются как синглтоны (один объект на весь контекст)
• Prototype — область видимости, при которой создается новый объект при каждом запросе

Лучшие практики

✅ Используй автоматическое внедрение (@Autowired, конструкторы) вместо ручного получения из контекста

✅ Старайся минимизировать прямой доступ к ApplicationContext — это запах кода

✅ Используй события (ApplicationEvent) для слабой связанности между компонентами

✅ Профили (Profiles) для разных конфигураций в разных окружениях

❌ Не получай бины из контекста вручную при наличии автоматического внедрения

Заключение

Application Context — это сердце Spring приложения. Это специальный контейнер (IoC Container), который создает, управляет и внедряет бины. Понимание работы Application Context критично для эффективного использования Spring Framework.