Для чего нужен Application Context?

# Application Context в Spring: назначение и использование

Краткий ответ

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

1. Создаёт и управляет bean'ами (объектами приложения)
2. Хранит конфигурацию приложения
3. Внедряет зависимости между bean'ами
4. Управляет жизненным циклом объектов
5. Предоставляет доступ к ресурсам приложения

Что такое Application Context

Определение

public interface ApplicationContext extends EnvironmentCapable, 
    ListableBeanFactory, HierarchicalBeanFactory, MessageSource, 
    ApplicationEventPublisher, ResourcePatternResolver {
    
    // Основные методы
    Object getBean(String name);
    <T> T getBean(Class<T> requiredType);
    String[] getBeanDefinitionNames();
    // ... и другие
}

Иерархия

ApplicationContext
    ├── EnvironmentCapable (доступ к пропертям)
    ├── BeanFactory (создание/получение bean'ов)
    ├── MessageSource (интернационализация)
    ├── ApplicationEventPublisher (события)
    └── ResourcePatternResolver (ресурсы)

Основные функции

1. Создание и управление Bean'ами

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // Создание контекста
        ApplicationContext context = SpringApplication.run(Application.class, args);
        
        // ApplicationContext создаёт все @Component, @Service, @Repository
        // и другие bean'ы
    }
}

@Component
public class UserService {
    public void doSomething() { }
}

// Контекст создал bean:
// bean 'userService' (тип: UserService)

2. Получение Bean'ов

ApplicationContext context = SpringApplication.run(Application.class);

// По типу
UserService service = context.getBean(UserService.class);

// По имени
UserService service = (UserService) context.getBean("userService");

// По типу и имени
UserService service = context.getBean("userService", UserService.class);

// Получить все bean'ы определённого типа
Map<String, UserService> allServices = context.getBeansOfType(UserService.class);

// Получить имена всех bean'ов
String[] names = context.getBeanDefinitionNames();

3. Внедрение зависимостей (Dependency Injection)

@Service
public class UserService {
    private final UserRepository repository;  // Зависимость
    
    // Constructor injection
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

@Repository
public class UserRepository {
    // ...
}

// Application Context:
// 1. Создаёт UserRepository bean
// 2. Видит, что UserService требует UserRepository
// 3. Инъектирует зависимость в конструктор
// 4. Создаёт UserService bean с инъектированной зависимостью

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

@Component
public class DatabaseConnection {
    
    @PostConstruct
    public void init() {
        System.out.println("Connection opened");
        // ApplicationContext вызывает это после создания bean'а
    }
    
    @PreDestroy
    public void destroy() {
        System.out.println("Connection closed");
        // ApplicationContext вызывает это при закрытии контекста
    }
}

// Использование
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Application.class, args);
        // Output: Connection opened
        
        context.close();  // Закрываем контекст
        // Output: Connection closed
    }
}

5. Доступ к property'ям

@Component
public class AppConfig {
    
    @Autowired
    private Environment environment;  // Предоставляет ApplicationContext
    
    public void printConfig() {
        String port = environment.getProperty("server.port");
        String dbUrl = environment.getProperty("spring.datasource.url");
        
        System.out.println("Port: " + port);
        System.out.println("DB URL: " + dbUrl);
    }
}

Типы Application Context'ов

1. ClassPathXmlApplicationContext

// Загрузка конфигурации из XML файла
ApplicationContext context = new ClassPathXmlApplicationContext(
    "applicationContext.xml"
);

UserService service = context.getBean(UserService.class);

2. AnnotationConfigApplicationContext

// Загрузка конфигурации из Java классов с аннотациями
ApplicationContext context = new AnnotationConfigApplicationContext(
    AppConfig.class
);

UserService service = context.getBean(UserService.class);

3. WebApplicationContext (для веб приложений)

// Автоматически создаётся Spring Boot
ApplicationContext context = SpringApplication.run(Application.class);
// Это WebApplicationContext

Полный пример

// 1. Конфигурация
@Configuration
public class AppConfig {
    
    @Bean
    public DataSource dataSource() {
        return new DataSource("jdbc:mysql://localhost:3306/mydb");
    }
    
    @Bean
    public UserRepository userRepository(DataSource dataSource) {
        return new UserRepository(dataSource);
    }
    
    @Bean
    public UserService userService(UserRepository repository) {
        return new UserService(repository);
    }
}

// 2. Создание и использование контекста
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // Создание контекста
        ApplicationContext context = SpringApplication.run(Application.class, args);
        
        // ApplicationContext создал:
        // - DataSource bean
        // - UserRepository bean (с инъектированным DataSource)
        // - UserService bean (с инъектированным UserRepository)
        
        // Получение bean'а
        UserService service = context.getBean(UserService.class);
        service.findAllUsers();
        
        // Закрытие контекста
        context.close();  // Вызовет @PreDestroy методы
    }
}

Application Context vs Bean Factory

Практическое использование

Получение контекста в компонентах

@Component
public class MyService implements ApplicationContextAware {
    
    private ApplicationContext context;
    
    @Override
    public void setApplicationContext(ApplicationContext context) 
        throws BeansException {
        this.context = context;
    }
    
    public void doSomething() {
        // Использовать контекст
        UserRepository repo = context.getBean(UserRepository.class);
        repo.findAll();
    }
}

Слушание событий контекста

@Component
public class EventListener {
    
    @EventListener
    public void onContextRefresh(ContextRefreshedEvent event) {
        ApplicationContext context = event.getApplicationContext();
        System.out.println("Context refreshed");
    }
    
    @EventListener
    public void onContextClose(ContextClosedEvent event) {
        System.out.println("Context closed");
    }
}

Программное получение bean'ов

@Service
public class BeanRegistry {
    
    @Autowired
    private ApplicationContext context;
    
    public void printAllBeans() {
        String[] names = context.getBeanDefinitionNames();
        for (String name : names) {
            Object bean = context.getBean(name);
            System.out.println(name + ": " + bean.getClass().getSimpleName());
        }
    }
    
    public boolean containsBean(String name) {
        return context.containsBean(name);
    }
}

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

1. Инициализация ApplicationContext
   ↓
2. Сканирование конфигурации (@Component, @Bean)
   ↓
3. Создание bean'ов (нетерпеливое)
   ↓
4. Внедрение зависимостей
   ↓
5. Вызов @PostConstruct методов
   ↓
6. Приложение запущено и работает
   ↓
7. Получение события shutdown
   ↓
8. Вызов @PreDestroy методов
   ↓
9. Закрытие ресурсов
   ↓
10. Application Context закрывается

Заключение

Application Context — это сердце Spring приложения:

1. Управляет все bean'ы — создание, хранение, получение
2. Внедряет зависимости — автоматическое связывание
3. Управляет жизненным циклом — инициализация и уничтожение
4. Предоставляет сервисы — события, свойства, ресурсы
5. Предоставляет API — для программного доступа к bean'ам

Без Application Context Spring был бы просто набором аннотаций — именно контекст оживляет фреймворк.

Типичный разработчик редко работает с контекстом напрямую (Spring Boot управляет им за кулисами), но понимание его роли критично для глубокого понимания Spring'а.