Какая задача у контекста в Spring?

Какая задача у контекста в Spring?

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

Основные задачи ApplicationContext

1. Управление Beans (Dependency Injection)

// Spring ApplicationContext создаёт beans автоматически
public class UserService {
    private UserRepository repository;  // Внедряется автоматически
    
    @Autowired  // Spring найдёт и внедрит beans
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

// В конфиге
@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
    
    @Bean
    public UserService userService(UserRepository repo) {
        return new UserService(repo);  // Spring управляет зависимостями
    }
}

2. Жизненный цикл Beans

ApplicationContext контролирует весь жизненный цикл объекта:

public class MyBean implements InitializingBean, DisposableBean {
    
    @PostConstruct  // Вызывается после конструктора
    public void init() {
        System.out.println("Bean инициализирован");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // Альтернатива @PostConstruct
    }
    
    @PreDestroy  // Вызывается перед удалением
    public void cleanup() {
        System.out.println("Bean удаляется");
    }
    
    @Override
    public void destroy() throws Exception {
        // Альтернатива @PreDestroy
    }
}

Жизненный цикл:

1. Создание экземпляра (конструктор)
2. Внедрение зависимостей (@Autowired)
3. @PostConstruct инициализация
4. Использование bean
5. @PreDestroy удаление

3. Управление Scope

ApplicationContext определяет, как долго живут beans:

// Singleton: один экземпляр на всё приложение (по умолчанию)
@Bean
@Scope("singleton")
public UserService userService() {
    return new UserService();
}

// Prototype: новый экземпляр каждый раз
@Bean
@Scope("prototype")
public UserService userService() {
    return new UserService();
}

// Request scope: новый на каждый HTTP запрос (веб приложения)
@Bean
@Scope("request")
@Component
public UserService userService() {
    return new UserService();
}

// Session scope: один на всю сессию пользователя
@Bean
@Scope("session")
public UserService userService() {
    return new UserService();
}

4. Загрузка конфигурации

ApplicationContext загружает и парсит конфигурацию приложения:

// XML конфигурация
ApplicationContext context = new ClassPathXmlApplicationContext("config.xml");

// Java-based конфигурация (рекомендуется)
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// Spring Boot автоматически создаёт context
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
        // ApplicationContext создаётся автоматически
    }
}

5. Получение Beans из контекста

// Программный доступ к beans
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// Получить bean по типу
UserService userService = context.getBean(UserService.class);

// Получить bean по имени
UserService service = (UserService) context.getBean("userService");

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

// Проверить наличие bean
if (context.containsBean("userService")) {
    // ...
}

6. Event System

ApplicationContext публикует события жизненного цикла:

// Слушать события
@Component
public class AppEventListener {
    
    @EventListener
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // Вызывается когда ApplicationContext инициализирован
        System.out.println("Контекст инициализирован");
    }
    
    @EventListener
    public void onShutdown(ContextClosedEvent event) {
        // Вызывается перед закрытием контекста
        System.out.println("Контекст закрывается");
    }
    
    @EventListener
    public void onCustomEvent(MyCustomEvent event) {
        // Слушать custom события
    }
}

// Публиковать custom события
@Service
public class UserService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    public void registerUser(User user) {
        // ...
        eventPublisher.publishEvent(new UserRegisteredEvent(user));
    }
}

7. Property Resolution

ApplicationContext загружает и управляет properties:

// application.properties
app.name=MyApp
app.version=1.0
db.url=jdbc:postgres://localhost:5432/db
db.password=${DB_PASSWORD}  // Из environment variable

// Использование в коде
@Component
public class DatabaseConfig {
    
    @Value("${db.url}")
    private String dbUrl;
    
    @Value("${app.name:DefaultApp}")  // С дефолтным значением
    private String appName;
    
    @Autowired
    private Environment env;
    
    public void init() {
        String password = env.getProperty("db.password");
    }
}

8. Profile Management

ApplicationContext поддерживает profiles для разных сред:

// application.properties
spring.profiles.active=dev

// Beans в зависимости от profile
@Configuration
public class DataSourceConfig {
    
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        // Development database
    }
    
    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        // Production database (с шифрованием, кэшем и т.д.)
    }
}

// Или на методах
@Component
@Profile("!prod")  // Используется если НЕ production
public class DevelopmentLogger {
    // ...
}

9. Resource Loading

ApplicationContext загружает ресурсы (файлы, классы и т.д.):

@Component
public class FileReader {
    
    @Autowired
    private ResourceLoader resourceLoader;
    
    public void readFile() {
        // Загрузить файл из classpath
        Resource resource = resourceLoader.getResource("classpath:data.txt");
        File file = resource.getFile();
        
        // Или из файловой системы
        Resource fsResource = resourceLoader.getResource("file:/tmp/data.txt");
    }
}

// Или прямой инъект
@Component
public class ConfigLoader {
    
    @Value("classpath:config.xml")
    private Resource configFile;
}

10. AOP и Proxy

ApplicationContext применяет AOP (Aspect-Oriented Programming):

@Aspect
@Component
public class LoggingAspect {
    
    @Around("execution(* com.example..*Service.*(..))")  // Применяется на все Service методы
    public Object logExecution(ProceedingJoinPoint pjp) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = pjp.proceed();  // Выполнить оригинальный метод
        long duration = System.currentTimeMillis() - startTime;
        
        System.out.println(pjp.getSignature() + " took " + duration + "ms");
        return result;
    }
}

// ApplicationContext автоматически создаёт proxy вокруг beans
UserService userService = context.getBean(UserService.class);
// Это proxy, а не оригинальный объект!

Типы ApplicationContext

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

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // Spring создаёт ApplicationContext автоматически
        ApplicationContext context = SpringApplication.run(Application.class, args);
        
        // Можешь получить beans
        UserService userService = context.getBean(UserService.class);
        userService.registerUser(new User("John", "john@example.com"));
        
        // Проверить beans
        System.out.println("Beans: " + context.getBeanDefinitionCount());
    }
}

Вывод

ApplicationContext — это центр управления приложением. Он:

• Управляет beans и их зависимостями
• Контролирует жизненный цикл
• Загружает конфигурацию
• Поддерживает events и profiles
• Применяет AOP
• Предоставляет доступ к ресурсам

Без контекста — нет Spring!